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);
}
