Refactoring.

Author: ChebanovDD

src/UnityMvvmToolkit.Core/Converters/ParameterValueConverters/ParameterValueConverter.cs renamed to src/UnityMvvmToolkit.Core/Converters/ParameterValueConverters/ParameterValueConverter.TTarget.cs

@@ -4,24 +4,24 @@
 
 namespace UnityMvvmToolkit.Core.Converters.PropertyValueConverters
 {
-    public abstract class PropertyValueConverter<TSourceType, TTargetType> 
-        : IPropertyValueConverter<TSourceType, TTargetType>
+    public abstract class PropertyValueConverter<TSource, TTarget> 
+        : IPropertyValueConverter<TSource, TTarget>
     {
         protected PropertyValueConverter()
         {
             Name = GetType().Name;
-            SourceType = typeof(TSourceType);
-            TargetType = typeof(TTargetType);
+            SourceType = typeof(TSource);
+            TargetType = typeof(TTarget);
         }
 
         public string Name { get; }
         public Type SourceType { get; }
         public Type TargetType { get; }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public abstract TTargetType Convert(TSourceType value);
+        public abstract TTarget Convert(TSource value);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public abstract TSourceType ConvertBack(TTargetType value);
+        public abstract TSource ConvertBack(TTarget value);
     }
 }

src/UnityMvvmToolkit.Core/Converters/PropertyValueConverters/PropertyValueConverter.cs renamed to src/UnityMvvmToolkit.Core/Converters/PropertyValueConverters/PropertyValueConverter.TSource.TTarget.cs

@@ -0,0 +1,10 @@
+using System.Runtime.CompilerServices;
+
+namespace UnityMvvmToolkit.Core.Interfaces
+{
+    public interface IParameterValueConverter<out TTargetType> : IParameterValueConverter
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        TTargetType Convert(string parameter);
+    }
+}

src/UnityMvvmToolkit.Core/Interfaces/IParameterValueConverter.TTarget.cs

@@ -1,16 +1,9 @@
 using System;
-using System.Runtime.CompilerServices;
 
 namespace UnityMvvmToolkit.Core.Interfaces
 {
     public interface IParameterValueConverter : IValueConverter
     {
         Type TargetType { get; }
     }
-
-    public interface IParameterValueConverter<out TTargetType> : IParameterValueConverter
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        TTargetType Convert(string parameter);
-    }
 }

src/UnityMvvmToolkit.Core/Interfaces/IParameterValueConverter.cs

@@ -0,0 +1,14 @@
+using System.Runtime.CompilerServices;
+
+namespace UnityMvvmToolkit.Core.Interfaces
+{
+    public interface IProperty<T> : IReadOnlyProperty<T>
+    {
+        new T Value { get; set; }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        bool TrySetValue(T value);
+
+        internal void ForceSetValue(T value);
+    }
+}

src/UnityMvvmToolkit.Core/Interfaces/IProperty.T.cs

@@ -0,0 +1,13 @@
+using System.Runtime.CompilerServices;
+
+namespace UnityMvvmToolkit.Core.Interfaces
+{
+    public interface IPropertyValueConverter<TSource, TTarget> : IPropertyValueConverter
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        TTarget Convert(TSource value);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        TSource ConvertBack(TTarget value);
+    }
+}

src/UnityMvvmToolkit.Core/Interfaces/IProperty.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Runtime.CompilerServices;
 
 namespace UnityMvvmToolkit.Core.Interfaces
 {
@@ -8,13 +7,4 @@ public interface IPropertyValueConverter : IValueConverter
         Type SourceType { get; }
         Type TargetType { get; }
     }
-
-    public interface IPropertyValueConverter<TSourceType, TTargetType> : IPropertyValueConverter
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        TTargetType Convert(TSourceType value);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        TSourceType ConvertBack(TTargetType value);
-    }
 }

src/UnityMvvmToolkit.Core/Interfaces/IPropertyValueConverter.TSource.TTarget.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace UnityMvvmToolkit.Core.Interfaces
+{
+    public interface IReadOnlyProperty<T> : IBaseProperty
+    {
+        T Value { get; }
+
+        event EventHandler<T> ValueChanged;
+    }
+}