ExtensionMethods.IAPIType.cs

Go to the documentation of this file.

using System;
using System.Linq.Expressions;
using System.Reflection;
 
using AnalyzeRe.JsonConverters;
using AnalyzeRe.Utilities;
using Newtonsoft.Json;
 
// ReSharper disable once CheckNamespace (Extension methods work best on the root namespace)
namespace AnalyzeRe
{
    public static partial class ExtensionMethods
    {
        private static readonly AnalyzeReJsonConverter CloningSerializer;
 
        static ExtensionMethods()
        {
            // For purposes of cloning an object, we need to also serialize its server-generated
            // properties so that a new object can be constructed as though it were deserializing
            // a JSON response from the server. Therefore, we change the serializer settings
            // to use a new contract resolver that ignores server-generated properties.
            CloningSerializer = new AnalyzeReJsonConverter();
            CloningSerializer.SerializerSettings.ContractResolver =
                new AnalyzeReSerializationContractResolver(ignoreServerGeneratedProperties: false);
            // We must include null values in the serialized JSON so that members that normally
            // get initialized to some non-null default (e.g. Lists and Dictionaries) will
            // get overridden with null once again when deserializing the original's JSON.
            CloningSerializer.SerializerSettings.NullValueHandling = NullValueHandling.Include;
            CloningSerializer.DeserializerSettings.NullValueHandling = NullValueHandling.Include;
        }
 
        public static T ShallowCopy<T>(this T obj) where T : IAPIType
        {
            return obj.ShallowCopy<T>();
        }
 
        public static T DeepCopy<T>(this T obj) where T : IAPIType
        {
            string serializedObj = CloningSerializer.Serialize(obj);
            if (typeof(T) == obj.GetType())
                return CloningSerializer.Deserialize<T>(serializedObj);
            // If the method invocation isn't strongly typed enough, the deserialize may fail,
            // so call a deserializer with the explicit object type passed in, and cast the result
            return (T)CloningSerializer.Deserialize(serializedObj, obj.GetType());
        }
 
        public static string Serialize(this IAPIType obj, bool pretty = false,
            bool includeServerGeneratedProperties = true, bool includeNullProperties = false)
        {
            if(includeServerGeneratedProperties && includeNullProperties)
                return CloningSerializer.Serialize(obj, pretty);
            if (!includeServerGeneratedProperties && !includeNullProperties)
                return AnalyzeReJsonConverter.Default.Serialize(obj, pretty);
            AnalyzeReJsonConverter converter = new AnalyzeReJsonConverter();
            if(includeServerGeneratedProperties)
                converter.SerializerSettings.ContractResolver =
                    new AnalyzeReSerializationContractResolver(false);
            if (includeNullProperties)
            {
                converter.SerializerSettings.NullValueHandling = NullValueHandling.Include;
                converter.DeserializerSettings.NullValueHandling = NullValueHandling.Include;
            }
            return converter.Serialize(obj, pretty);
        }
 
        public static T Change<T, TProperty>(
            this T obj, Expression<Func<T, TProperty>> propertyExpression, TProperty newValue)
            where T : IAPIType
        {
            PropertyInfo property;
            string propertyName;
            // First, get the property information from the expression given.
            try
            {
                property = (PropertyInfo)ReflectionUtilities.GetMemberInfo(propertyExpression);
                propertyName = property.Name;
            }
            catch (Exception ex)
            {
                throw new ArgumentException($"Error: Invalid property expression: {propertyExpression}", ex);
            }
            // If the PropertyInfo resolved is from a base class or interface, we must
            // get the PropertyInfo for the concrete type corresponding to the obj instance.
            Type runtimeType = obj.GetType();
            Type declaringType = property.DeclaringType;
            if (runtimeType != declaringType)
                property = runtimeType.GetProperty(propertyName);
            if (property == null)
                throw new ArgumentException($"The property {propertyName} defined on the type " +
                    $"{declaringType.NiceTypeName()} could not be found on the object " +
                    $"supplied with the instance type {runtimeType.NiceTypeName()}");
            // Finally, set the property value on the instance object provided.
            try
            {
                property.SetValue(obj, newValue, null);
            }
            catch (Exception ex)
            {
                throw new ArgumentException("The supplied value of type " +
                    $"{newValue?.GetType().NiceTypeName() ?? "(null)"} is invalid for the " +
                    $"property {propertyName} on the type {runtimeType.NiceTypeName()}. " +
                    $"The expected type is {property.PropertyType.NiceTypeName()}", ex);
            }
 
            return obj;
        }
    }
}