Comparers serialization

Author: alex-kulakov

Orm/Xtensive.Orm/Comparison/AdvancedComparerBase.cs

@@ -1,33 +1,35 @@
-// Copyright (C) 2003-2010 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2008-2021 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
 // Created by: Dmitri Maximov
 // Created:    2008.01.23
 
 using System;
 using System.Collections;
 using System.Diagnostics;
 using System.Runtime.Serialization;
+using System.Security;
 using Xtensive.Arithmetic;
 using Xtensive.Collections;
 using Xtensive.Core;
 
 
-
 namespace Xtensive.Comparison
 {
   /// <summary>
   /// Base class for <see cref="IAdvancedComparer{T}"/> implementations.
   /// </summary>
   /// <typeparam name="T">The type to compare.</typeparam>
   [Serializable]
-  public abstract class AdvancedComparerBase<T>: IAdvancedComparer<T>, 
+  public abstract class AdvancedComparerBase<T>: IAdvancedComparer<T>,
+    ISerializable,
     IDeserializationCallback
   {
     private static Arithmetic<T> cachedArithmetic;
     [NonSerialized]
     private ThreadSafeDictionary<ComparisonRules, AdvancedComparer<T>> cachedComparers = 
       ThreadSafeDictionary<ComparisonRules, AdvancedComparer<T>>.Create(new object());
+
     private IComparerProvider provider;
     private ValueRangeInfo<T> valueRangeInfo;
 
@@ -43,28 +45,27 @@ public abstract class AdvancedComparerBase<T>: IAdvancedComparer<T>,
     protected readonly int DefaultDirectionMultiplier;
 
     /// <inheritdoc/>
-    public IComparerProvider Provider 
+    public IComparerProvider Provider
     {
       [DebuggerStepThrough]
-      get { return provider; }
+      get => provider;
     }
 
     /// <inheritdoc/>
-    ComparisonRules IAdvancedComparerBase.ComparisonRules 
+    ComparisonRules IAdvancedComparerBase.ComparisonRules
     {
       [DebuggerStepThrough]
-      get { return ComparisonRules; }
+      get => ComparisonRules;
     }
 
     /// <inheritdoc/>
     public ValueRangeInfo<T> ValueRangeInfo
     {
-      get { return valueRangeInfo; }
+      get => valueRangeInfo;
       protected set {
-        if (ComparisonRules.Value.Direction!=Direction.Negative)
-          valueRangeInfo = value;
-        else
-          valueRangeInfo = value.Invert();
+        valueRangeInfo = ComparisonRules.Value.Direction != Direction.Negative
+          ? value
+          : value.Invert();
       }
     }
 
@@ -77,15 +78,9 @@ public AdvancedComparer<T> ApplyRules(ComparisonRules rules)
     }
 
     /// <inheritdoc/>
-    public virtual Func<T, TSecond, int> GetAsymmetric<TSecond>()
-    {
-      throw new NotSupportedException();
-    }
+    public virtual Func<T, TSecond, int> GetAsymmetric<TSecond>() => throw new NotSupportedException();
 
-    int IComparer.Compare(object x, object y)
-    {
-      return Compare((T) x, (T) y);
-    }
+    int IComparer.Compare(object x, object y) => Compare((T) x, (T) y);
 
     /// <inheritdoc/>
     public abstract int Compare(T x, T y);
@@ -99,24 +94,21 @@ int IComparer.Compare(object x, object y)
     /// <inheritdoc/>
     public virtual T GetNearestValue(T value, Direction direction)
     {
-      if (!valueRangeInfo.HasDeltaValue)
-        throw new NotSupportedException();
-      Arithmetic<T> arithmetic = GetArithmetic();
-      if (arithmetic==null)
+      if (!valueRangeInfo.HasDeltaValue) {
         throw new NotSupportedException();
-
-      if (direction==ComparisonRules.Value.Direction) {
-        if (valueRangeInfo.HasMaxValue && Equals(value, valueRangeInfo.MaxValue))
-          return value;
-        else
-          return arithmetic.Add(value, valueRangeInfo.DeltaValue);
       }
-      else {
-        if (valueRangeInfo.HasMinValue && Equals(value, valueRangeInfo.MinValue))
-          return value;
-        else
-          return arithmetic.Subtract(value, valueRangeInfo.DeltaValue);
+      var arithmetic = GetArithmetic();
+      if (arithmetic == null) {
+        throw new NotSupportedException();
       }
+
+      return direction == ComparisonRules.Value.Direction
+        ? valueRangeInfo.HasMaxValue && Equals(value, valueRangeInfo.MaxValue)
+          ? value
+          : arithmetic.Add(value, valueRangeInfo.DeltaValue)
+        : valueRangeInfo.HasMinValue && Equals(value, valueRangeInfo.MinValue)
+          ? value
+          : arithmetic.Subtract(value, valueRangeInfo.DeltaValue);
     }
 
     /// <summary>
@@ -125,8 +117,9 @@ public virtual T GetNearestValue(T value, Direction direction)
     /// <returns>Default arithmetic.</returns>
     protected static Arithmetic<T> GetArithmetic()
     {
-      if (cachedArithmetic==null)
+      if (cachedArithmetic == null) {
         cachedArithmetic = Arithmetic<T>.Default;
+      }
       return cachedArithmetic;
     }
 
@@ -136,10 +129,9 @@ protected static Arithmetic<T> GetArithmetic()
     /// <typeparam name="TTarget">The type to provide the comparer for (by wrapping this comparer).</typeparam>
     public AdvancedComparer<TTarget> Cast<TTarget>()
     {
-      if (typeof(TTarget)==typeof(T))
-        return new AdvancedComparer<TTarget>(this as IAdvancedComparer<TTarget>);
-      else
-        return new AdvancedComparer<TTarget>(new CastingComparer<T, TTarget>(new AdvancedComparer<T>(this)));
+      return typeof(TTarget) == typeof(T)
+        ? new AdvancedComparer<TTarget>(this as IAdvancedComparer<TTarget>)
+        : new AdvancedComparer<TTarget>(new CastingComparer<T, TTarget>(new AdvancedComparer<T>(this)));
     }
 
     /// <summary>
@@ -166,7 +158,15 @@ public AdvancedComparerBase(IComparerProvider provider, ComparisonRules comparis
         false, default(T));
       this.provider = provider;
       ComparisonRules = comparisonRules;
-      DefaultDirectionMultiplier = comparisonRules.Value.Direction==Direction.Negative ? -1 : 1;
+      DefaultDirectionMultiplier = comparisonRules.Value.Direction == Direction.Negative ? -1 : 1;
+    }
+
+    public AdvancedComparerBase(SerializationInfo info, StreamingContext context)
+    {
+      provider = (IComparerProvider) info.GetValue(nameof(provider), typeof(IComparerProvider));
+      valueRangeInfo = (ValueRangeInfo<T>) info.GetValue(nameof(valueRangeInfo), typeof(ValueRangeInfo<T>));
+      ComparisonRules = (ComparisonRules) info.GetValue(nameof(ComparisonRules), typeof(ComparisonRules));
+      DefaultDirectionMultiplier = info.GetInt32(nameof(DefaultDirectionMultiplier));
     }
 
     /// <summary>
@@ -175,13 +175,25 @@ public AdvancedComparerBase(IComparerProvider provider, ComparisonRules comparis
     /// <param name="sender"></param>
     public virtual void OnDeserialization(object sender)
     {
-      if (provider==null) 
+      if (provider == null) {
         provider = ComparerProvider.Default;
-      else if (provider.GetType()==typeof(ComparerProvider))
+      }
+      else if (provider.GetType() == typeof(ComparerProvider)) {
         provider = ComparerProvider.Default;
-      else if (provider is SystemComparerProvider)
+      }
+      else if (provider is SystemComparerProvider) {
         provider = ComparerProvider.System;
+      }
       cachedComparers = ThreadSafeDictionary<ComparisonRules, AdvancedComparer<T>>.Create(new object());
     }
+
+    [SecurityCritical]
+    public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
+    {
+      info.AddValue(nameof(provider), provider, provider.GetType());
+      info.AddValue(nameof(valueRangeInfo), valueRangeInfo, valueRangeInfo.GetType());
+      info.AddValue(nameof(ComparisonRules), ComparisonRules, ComparisonRules.GetType());
+      info.AddValue(nameof(DefaultDirectionMultiplier), DefaultDirectionMultiplier);
+    }
   }
 }

Orm/Xtensive.Orm/Comparison/CastingComparer.cs

@@ -1,10 +1,11 @@
-// Copyright (C) 2003-2010 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2008-2021 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
 // Created by: 
 // Created:    2008.03.06
 
 using System;
+using System.Runtime.Serialization;
 using Xtensive.Conversion;
 using Xtensive.Core;
 using Xtensive.Reflection;
@@ -20,64 +21,51 @@ namespace Xtensive.Comparison
   [Serializable]
   public sealed class CastingComparer<TSource, TTarget>: AdvancedComparerBase<TTarget>
   {
-    private static readonly Converter<TTarget, TSource> toSource = AdvancedConverterStruct<TTarget, TSource>.Default.Convert;
-    private static readonly Converter<TSource, TTarget> toTarget = AdvancedConverterStruct<TSource, TTarget>.Default.Convert;
-    private readonly AdvancedComparer<TSource> sourceComparer;
-
-    internal class AsymmetricCompareHandler<TSecond>:
+    private class AsymmetricCompareHandler<TSecond> :
       IComparer<TTarget, TSecond>
     {
       private readonly Func<TSource, TSecond, int> baseCompare;
 
-      public int Compare(TTarget x, TSecond y)
-      {
-        return baseCompare(toSource(x), y);
-      }
+      public int Compare(TTarget x, TSecond y) => baseCompare(ToSource(x), y);
 
       public AsymmetricCompareHandler(Func<TSource, TSecond, int> baseCompare)
       {
         this.baseCompare = baseCompare;
       }
     }
 
+    private static readonly Converter<TTarget, TSource> ToSource = AdvancedConverterStruct<TTarget, TSource>.Default.Convert;
+    private static readonly Converter<TSource, TTarget> ToTarget = AdvancedConverterStruct<TSource, TTarget>.Default.Convert;
+
+    private readonly AdvancedComparer<TSource> sourceComparer;
+
     /// <inheritdoc/>
     protected override IAdvancedComparer<TTarget> CreateNew(ComparisonRules rules)
-    {
-      return new CastingComparer<TSource, TTarget>(sourceComparer.ApplyRules(rules));
-    }
+      => new CastingComparer<TSource, TTarget>(sourceComparer.ApplyRules(rules));
 
     /// <inheritdoc/>
     public override int Compare(TTarget x, TTarget y)
-    {
-      return sourceComparer.Compare(toSource(x), toSource(y));
-    }
+      => sourceComparer.Compare(ToSource(x), ToSource(y));
 
     /// <inheritdoc/>
-    public override bool Equals(TTarget x, TTarget y)
-    {
-      return sourceComparer.Equals(toSource(x), toSource(y));
-    }
+    public override bool Equals(TTarget x, TTarget y) => sourceComparer.Equals(ToSource(x), ToSource(y));
 
     /// <inheritdoc/>
-    public override int GetHashCode(TTarget obj)
-    {
-      return sourceComparer.GetHashCode(toSource(obj));
-    }
+    public override int GetHashCode(TTarget obj) => sourceComparer.GetHashCode(ToSource(obj));
 
     /// <inheritdoc/>
-    public override TTarget GetNearestValue(TTarget value, Direction direction)
-    {
-      return toTarget(sourceComparer.GetNearestValue(toSource(value), direction));
-    }
+    public override TTarget GetNearestValue(TTarget value, Direction direction) => ToTarget(sourceComparer.GetNearestValue(ToSource(value), direction));
 
     /// <inheritdoc/>
     public override Func<TTarget, TSecond, int> GetAsymmetric<TSecond>()
     {
-      Func<TSource, TSecond, int> asymmetricCompare = sourceComparer.GetAsymmetric<TSecond>();
-      if (asymmetricCompare == null)
+      var asymmetricCompare = sourceComparer.GetAsymmetric<TSecond>();
+      if (asymmetricCompare == null) {
         throw new NotSupportedException();
-      AsymmetricCompareHandler<TSecond> h = new AsymmetricCompareHandler<TSecond>(asymmetricCompare);
-      return h.Compare;
+      }
+
+      var handler = new AsymmetricCompareHandler<TSecond>(asymmetricCompare);
+      return handler.Compare;
     }
 
 
@@ -90,15 +78,20 @@ public CastingComparer(AdvancedComparer<TSource> sourceComparer)
       : base(sourceComparer.Provider, sourceComparer.ComparisonRules)
     {
       this.sourceComparer = sourceComparer;
-      ValueRangeInfo<TSource> vi = sourceComparer.ValueRangeInfo;
+      var vi = sourceComparer.ValueRangeInfo;
       ValueRangeInfo =
         new ValueRangeInfo<TTarget>(
           vi.HasMinValue,
-          vi.HasMinValue ? toTarget(vi.MinValue) : default(TTarget),
+          vi.HasMinValue ? ToTarget(vi.MinValue) : default(TTarget),
           vi.HasMaxValue,
-          vi.HasMaxValue ? toTarget(vi.MaxValue) : default(TTarget),
+          vi.HasMaxValue ? ToTarget(vi.MaxValue) : default(TTarget),
           vi.HasDeltaValue,
-          vi.HasDeltaValue ? toTarget(vi.DeltaValue) : default(TTarget));
+          vi.HasDeltaValue ? ToTarget(vi.DeltaValue) : default(TTarget));
+    }
+
+    public CastingComparer(SerializationInfo info, StreamingContext context)
+      : base(info, context)
+    {
     }
   }
 }