vStationURM/Server/vCloud.Server.Core/Cache/SyncHelper.cs

using vCloud.Server.Infrastructures;
using vCloud.Server.ServerProtocol;
using Vinno.vCloud.Protocol.Infrastructures;
using vCloud.Server.Utilities;
using vCloud.Server.Services.Live.Sync;
using System.Collections.Generic;
using System.Linq;
using Vinno.IUS.Common.Log;
using System.Reflection;
using System;

namespace vCloud.Server.Cache
{
    internal class SyncEntityCreater
    {
        public static MemorySyncContentMessage ConvertMessager<T, T1>(ICacheManager<T, T1> cacheManager, T key, MessageOperateType? operate, T1 result, string serverUrl = "")
        {
            if (operate != null)
            {
                var message = new MemorySyncContentMessage();
                var type = typeof(T1);
                var toJsonMethod = type.GetMethod("ToJson");
                if (toJsonMethod != null)
                {
                    message.Content = toJsonMethod.Invoke(result, null)?.ToString();
                }
                else
                {
                    message.Content = result.ToJson();
                }
                message.Operate = (MessageOperateType)operate;
                message.Collection = cacheManager.Name;
                message.Key = key.ToString();
                message.ServerUrl = serverUrl;
                return message;
            }
            return null;
        }

        public static MemorySyncContentMessage ConvertMessager<T, T1>(ICacheManager<T, T1> cacheManager, T key, MessageOperateType? operate, ItemContents result, string serverUrl = "")
        {
            if (operate != null)
            {
                var message = new MemorySyncContentMessage();
                var type = result.GetType();
                var toJsonMethod = type.GetMethod("ToJson");
                if (toJsonMethod != null)
                {
                    message.Content = toJsonMethod.Invoke(result, null)?.ToString();
                }
                else
                {
                    message.Content = result.ToJson();
                }
                message.Operate = (MessageOperateType)operate;
                message.Collection = cacheManager.Name;
                message.Key = key.ToString();
                message.ServerUrl = serverUrl;
                return message;
            }
            return null;
        }


        /// <summary>
        /// 创建实例
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="content"></param>
        /// <returns></returns>
        public object CreateInstance(string content)
        {
            var entity = content.JsonToObj<SyncEntity>();
            if (entity.ClassType == null)
            {
                var itemContents = content.JsonToObj<ItemContents>();
                if (itemContents != null)
                {
                    return itemContents;
                }
                else
                {
                    return content.JsonToObj(typeof(object));
                }
            }
            else
            {
                if (entity.Value != null)
                {
                    if (entity.ClassType.IsEnum)
                    {
                        return Enum.Parse(entity.ClassType, entity.Value.ToString());
                    }
                    return entity.Value;
                }
                try
                {
                    var createInstance = GetType().GetMethod("CheckSyncEntity", BindingFlags.Instance | BindingFlags.Public);
                    var genericMethod = createInstance.MakeGenericMethod(entity.ClassType);
                    var itemValue = genericMethod.Invoke(this, new object[] { entity });
                    return itemValue;
                }
                catch (Exception ex)
                {
                    Logger.WriteLineError($"CreateInstance error entity:{entity.ToJson()}");
                    throw ex;
                }
            }
        }

        public T CheckSyncEntity<T>(SyncEntity entity) where T : class
        {
            if (entity != null)
            {
                if (entity.ClassType.Name == typeof(T).Name)
                {
                    T instance = null;
                    ConstructorInfo constructor = null;
                    if (entity.SyncParams == null || entity.SyncParams.Count == 0)
                    {
                        constructor = entity.ClassType.GetConstructors()[0];
                        instance = constructor.Invoke(null) as T;
                        SetPropertys(entity, instance);
                    }
                    else
                    {
                        var createrParams = entity.SyncParams.Select(f => f.ClassType).ToArray();
                        constructor = entity.ClassType.GetConstructor(createrParams);
                        instance = GetInstance<T>(entity, constructor);
                        SetPropertys(entity, instance);
                    }
                    return instance;
                }
            }
            return null;
        }

        /// <summary>
        /// 设置属性
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="instance"></param>
        public void SetPropertys<T>(SyncEntity entity, T instance) where T : class
        {
            var props = instance.GetType().GetProperties();
            foreach (var prop in props)
            {
                if (entity.SyncPropertys.Count(f => f.Key == prop.Name) > 0)
                {
                    var syncProp = entity.SyncPropertys.FirstOrDefault(f => f.Key == prop.Name);
                    var syncItem = GetSyncItem(syncProp.ClassType, syncProp.Value);
                    prop.SetValue(instance, syncItem ?? syncProp.Value);
                }
            }
        }

        /// <summary>
        /// 获取Item中对象的实际类型
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        public object GetSyncItem(Type type, string json)
        {
            var entityList = ConvertHelper.JsonToObj<List<SyncEntity>>(json);
            if (entityList != null && entityList.Count > 0)
            {
                var genericType = type.GenericTypeArguments[0];
                var tempList = Activator.CreateInstance(typeof(List<>).MakeGenericType(new Type[] { genericType }));
                var addMethod = tempList.GetType().GetMethod("Add");
                foreach (var item in entityList)
                {
                    var createInstance = GetType().GetMethod("CheckSyncEntity", BindingFlags.Instance | BindingFlags.Public);
                    var genericMethod = createInstance.MakeGenericMethod(item.ClassType);
                    var itemValue = genericMethod.Invoke(this, new object[] { item });
                    addMethod.Invoke(tempList, new object[] { itemValue });
                }
                return tempList;
            }
            var entityArray = ConvertHelper.JsonToObj<SyncEntity[]>(json);
            if (entityArray != null && entityArray.Length > 0)
            {
                var elementType = GetArrayElementType(type);
                var tempList = Activator.CreateInstance(typeof(List<>).MakeGenericType(new Type[] { elementType }));
                var addMethod = tempList.GetType().GetMethod("Add");
                var toArray = tempList.GetType().GetMethod("ToArray");
                foreach (var item in entityArray)
                {
                    var createInstance = GetType().GetMethod("CheckSyncEntity", BindingFlags.Instance | BindingFlags.Public);
                    var genericMethod = createInstance.MakeGenericMethod(item.ClassType);
                    var itemValue = genericMethod.Invoke(this, new object[] { item });
                    addMethod.Invoke(tempList, new object[] { itemValue });
                }
                return toArray.Invoke(tempList, null);
            }
            var entity = ConvertHelper.JsonToObj<SyncEntity>(json);
            if (entity != null)
            {
                if (entity.ClassType != null)
                {
                    var createInstance = GetType().GetMethod("CheckSyncEntity", BindingFlags.Instance | BindingFlags.Public);
                    var genericMethod = createInstance.MakeGenericMethod(entity.ClassType);
                    var itemValue = genericMethod.Invoke(this, new object[] { entity });
                    return itemValue;
                }
            }
            return json.JsonToObj(type);
        }

        /// <summary>
        /// 获取对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="constructor"></param>
        /// <returns></returns>
        public T GetInstance<T>(SyncEntity entity, ConstructorInfo constructor) where T : class
        {
            List<object> constructorParams = new List<object>();
            var paramList = constructor.GetParameters();
            foreach (var param in paramList)
            {
                var paraJson = entity.SyncParams.FirstOrDefault(f => f.Key == param.Name);
                if (paraJson != null)
                {
                    var syncItem = GetSyncItem(paraJson.ClassType, paraJson.Value);
                    constructorParams.Add(syncItem);
                }
                else
                {
                    Logger.WriteLineInfo($"Sync GetInstance not found param name:{param.Name}");
                }

            }
            var instance = constructor.Invoke(constructorParams.ToArray()) as T;
            return instance;
        }

        public static Type GetArrayElementType(Type t)
        {
            if (!t.IsArray) return t;
            string tName = t.FullName.Replace("[]", string.Empty);
            Type elType = t.Assembly.GetType(tName);
            return elType;
        }
    }
}