private IEnumerable <PropertyMapper> FindProperties(TypeMapper mapper, ref object entity) { IEnumerable <PropertyMapper> pms = mapper.Properties; var entityType = entity.GetType(); if (entityType.IsAssignableFrom(mapper.Type)) { return(pms); } var mapper2 = TypeMapper.Create(entityType); var query = from op in pms join np in mapper2.Properties on op.Property.Name.ToLower() equals np.Name.ToLower() select new { op, np }; var entity2 = Activator.CreateInstance(mapper.Type, true); List <PropertyMapper> pms2 = new List <PropertyMapper>(); foreach (var item in query) { pms2.Add(item.op); item.op.SetValue(entity2, item.np.GetValue(entity)); } entity = entity2; return(pms2); }
public object CreateAny(object value) { if (value == null) { return(null); } var mp = TypeMapper.Create(value.GetType()); var d = this._ctor.GetParameters().ToDictionary(s => s.Name, s => (object)null); foreach (var p in mp.Properties) { d[p.Name] = p.GetValue(value); } return(DynamicFactory.CreateConstructorHandler(_ctor)(d.Values.ToArray())); }
// Serialize custom object graph private void SerializeCustomObject(object o, StringBuilder sb, int depth, Hashtable objectsInUse) { var first = true; var type = o.GetType(); sb.Append('{'); // Serialize the object type if we have a type resolver if (TypeResolver != null) { // Only do this if the context is actually aware of this type var typeString = TypeResolver.ResolveTypeId(type); if (typeString != null) { SerializeString(ServerTypeFieldName, sb); sb.Append(':'); SerializeValue(typeString, sb, depth, objectsInUse); first = false; } } var props = type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetProperty); var typeMapper = TypeMapper.Create(type); foreach (var propertyMapper in typeMapper.Properties) { if (propertyMapper.IsIgnore) { continue; } if (!first) { sb.Append(','); } var name = propertyMapper.Name; if (this.EnabledCamelCaseName) { name = name.ToCamelCase(); } SerializeString(name, sb); sb.Append(':'); this.SerializeValue(propertyMapper.GetValue(o, false), sb, depth, objectsInUse, propertyMapper); first = false; } sb.Append('}'); }
IExecutorMetadata <TCommand> IExecutorFactory.Create <TCommand>(TCommand command) { var executor = Executors.TryGetValue(typeof(TCommand)) as IExecutorMetadata <TCommand>; if (executor == null) { if (_queues.Count == 0) { throw new NotSupportedException($"命令{typeof(TCommand).FullName}没有模拟执行器。"); } var handler = _queues.Dequeue(); if (handler != null) { return(new ExecutorMetadata <TCommand>(new MockExecutor <TCommand>((cont, cmd) => { var result = handler(cmd); if (result == null) { return; } var type = cmd.GetType(); foreach (var interfaceType in type.GetInterfaces()) { if (interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition() == typeof(ICommand <>)) { var resultType = interfaceType.GetGenericArguments()[0]; if (resultType.IsAnonymous()) { result = new AnonymousTypeObject(resultType).CreateAny(result); } break; } } TypeMapper.Create(type)["Result"].SetValue(cmd, result); }))); } throw new NotSupportedException($"没有模拟实现命令 { typeof(TCommand).FullName } 的执行器。"); } return(executor); }
/// <summary> /// 指定解析一个任意对象,添加到集合中。 /// </summary> /// <param name="objectInstance">匿名参数集合实例。</param> public ExecuteParameterCollection Parse(object objectInstance) { if (objectInstance == null) { return(this); } if (objectInstance is IExecuteParameter) { this.Add(objectInstance as IExecuteParameter); return(this); } var isCommandObject = objectInstance is CommandModel.ICommand; var objType = objectInstance.GetType(); var mapper = TypeMapper.Create(objType); object value; foreach (var prop in mapper.Properties) { if (prop.IsIgnore || (isCommandObject && prop.Name == "ResultValue")) { continue; } value = prop.GetValue(objectInstance, true); if (value is IExecuteParameter) { this.Add(value as IExecuteParameter); } else { this.Add(prop.Name, value); } } return(this); }
/// <summary> /// 指定解析一个任意对象,添加到集合中。 /// </summary> /// <param name="objectInstance">一个任意对象。</param> public void AddObject(object objectInstance) { if (objectInstance == null) { return; } var objType = objectInstance.GetType(); if (objType == ExecuteParameterType) { this.Add(objectInstance as ExecuteParameter); return; } var mapper = TypeMapper.Create(objType); object value; foreach (var prop in mapper.Properties) { if (prop.IsIgnore) { continue; } value = prop.GetValue(objectInstance); if (prop.Property.PropertyType == ExecuteParameterType) { this.Add(value as ExecuteParameter); } else { this.Add(prop.Name, value); } } }
// Method that converts an IDictionary<string, object> to an object of the right type private static bool ConvertDictionaryToObject(IDictionary <string, object> dictionary, Type type, JSerializer serializer, bool throwOnError, out object convertedObject) { // The target type to instantiate. Type targetType = type; object s; string serverTypeName = null; object o = dictionary; // Check if __serverType exists in the dictionary, use it as the type. if (dictionary.TryGetValue(JSerializer.ServerTypeFieldName, out s)) { // Convert the __serverType value to a string. if (!ConvertObjectToTypeMain(s, typeof(String), serializer, throwOnError, out s)) { convertedObject = false; return(false); } serverTypeName = (string)s; if (serverTypeName != null) { // If we don't have the JavaScriptTypeResolver, we can't use it if (serializer.TypeResolver != null) { // Get the actual type from the resolver. targetType = serializer.TypeResolver.ResolveType(serverTypeName); // In theory, we should always find the type. If not, it may be some kind of attack. if (targetType == null) { if (throwOnError) { throw new InvalidOperationException(); } convertedObject = null; return(false); } } // Remove the serverType from the dictionary, even if the resolver was null dictionary.Remove(JSerializer.ServerTypeFieldName); } } JConverter converter = null; if (targetType != null && serializer.ConverterExistsForType(targetType, out converter)) { try { convertedObject = converter.Deserialize(dictionary, targetType, serializer); return(true); } catch { if (throwOnError) { throw; } convertedObject = null; return(false); } } // Instantiate the type if it's coming from the __serverType argument. if (serverTypeName != null || IsClientInstantiatableType(targetType, serializer)) { // First instantiate the object based on the type. o = Activator.CreateInstance(targetType); } // Use a different collection to avoid modifying the original during keys enumeration. List <String> memberNames = new List <String>(dictionary.Keys); // Try to handle the IDictionary<K, V> case if (IsGenericDictionary(type)) { Type keyType = type.GetGenericArguments()[0]; if (keyType != typeof(string) && keyType != typeof(object)) { if (throwOnError) { throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.JSON_DictionaryTypeNotSupported, type.FullName)); } convertedObject = null; return(false); } Type valueType = type.GetGenericArguments()[1]; IDictionary dict = null; if (IsClientInstantiatableType(type, serializer)) { dict = (IDictionary)Activator.CreateInstance(type); } else { // Get the strongly typed Dictionary<K, V> Type t = _dictionaryGenericType.MakeGenericType(keyType, valueType); dict = (IDictionary)Activator.CreateInstance(t); } if (dict != null) { foreach (string memberName in memberNames) { object memberObject; if (!ConvertObjectToTypeMain(dictionary[memberName], valueType, serializer, throwOnError, out memberObject)) { convertedObject = null; return(false); } dict[memberName] = memberObject; } convertedObject = dict; return(true); } } // Fail if we know we cannot possibly return the required type. if (type != null && !type.IsAssignableFrom(o.GetType())) { if (!throwOnError) { convertedObject = null; return(false); } ConstructorInfo constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, s_emptyTypeArray, null); if (constructorInfo == null) { throw new MissingMethodException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.JSON_NoConstructor, type.FullName)); } throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.JSON_DeserializerTypeMismatch, type.FullName)); } var typeMapper = TypeMapper.Create(o.GetType()); foreach (string memberName in memberNames) { object propertyValue = dictionary[memberName]; // Assign the value into a property or field of the object if (!AssignToProperty(typeMapper, propertyValue, o, memberName, serializer, throwOnError)) { convertedObject = null; return(false); } } convertedObject = o; return(true); }