public static void InvokeMethod(this object instance, string methodName, IResolveObject objectResolver)
{
var method = instance.GetType().GetMethod(methodName);
var parameters = method.GetParameters();
var arguments = new List<object>();
if (parameters != null && parameters.Any())
{
foreach (var item in parameters)
arguments.Add(objectResolver.ResolveType(item.ParameterType));
}
method.Invoke(instance, arguments.ToArray());
}
public ObjectRecordService(object objectToEnter, IRecordService lookupService,
IDictionary <string, IEnumerable <string> > optionSetLimitedValues, ObjectRecordService parentService, string parentServiceReference, IResolveObject objectResolver, IDictionary <string, Type> objectTypeMaps = null)
{
ObjectResolver = objectResolver;
ParentServiceReference = parentServiceReference;
ParentService = parentService;
ObjectToEnter = objectToEnter;
_lookupService = lookupService;
OptionSetLimitedValues = optionSetLimitedValues;
ObjectTypeMaps = objectTypeMaps;
var objectTypeFieldMetadata = new List <FieldMetadata>();
var type = ObjectToEnter.GetType();
objectTypeFieldMetadata.AddRange(RecordMetadataFactory.GetClassFieldMetadata(type, ObjectTypeMaps));
FieldMetadata.Add(type.AssemblyQualifiedName, objectTypeFieldMetadata);
foreach (var field in objectTypeFieldMetadata.Where(f => f.FieldType == RecordFieldType.Enumerable))
{
//need to add the field metadata for any nested types
var asEnumerable = (EnumerableFieldMetadata)field;
if (!FieldMetadata.ContainsKey(asEnumerable.EnumeratedTypeQualifiedName))
{
var metadata = RecordMetadataFactory.GetClassFieldMetadata(GetClassType(asEnumerable.EnumeratedTypeQualifiedName), ObjectTypeMaps);
FieldMetadata.Add(asEnumerable.EnumeratedTypeQualifiedName, metadata);
}
//if the property is an interface we also want to load the metadata for any instance types
var propertyValue = ObjectToEnter.GetPropertyValue(field.SchemaName);
if (propertyValue != null)
{
var enumerable = ((IEnumerable)propertyValue);
foreach (var item in enumerable)
{
var instanceType = item.GetType();
if (!FieldMetadata.ContainsKey(instanceType.AssemblyQualifiedName))
{
var metadata = RecordMetadataFactory.GetClassFieldMetadata(instanceType, ObjectTypeMaps);
FieldMetadata.Add(instanceType.AssemblyQualifiedName, metadata);
}
}
}
}
}
public ObjectRecordService(object objectToEnter, IRecordService lookupService,
IDictionary <string, IEnumerable <string> > optionSetLimitedValues, IResolveObject objectResolver, IDictionary <string, Type> objectTypeMaps = null)
: this(objectToEnter, lookupService, optionSetLimitedValues, null, null, objectResolver, objectTypeMaps)
{
}
public ObjectRecordService(object objectToEnter, IResolveObject objectResolver, IDictionary <string, Type> objectTypeMaps = null)
: this(objectToEnter, null, null, objectResolver, objectTypeMaps)
{
}
public static T ResolveType <T>(this IResolveObject objectResolver)
{
return((T)objectResolver.ResolveType(typeof(T)));
}
/// <summary>
/// 设置对象属性
/// </summary>
/// <param name="source"></param>
/// <param name="configNode"></param>
/// <returns></returns>
public static IResolveObject DeserializeObject(this IResolveObject source, IConfigNode configNode)
{
return((IResolveObject)DeserializeObject((object)source, configNode));
}
public static IRecordService LoadService(Lookup lookup, IRecordService recordService, IStoredObjectFields objectConfig, IResolveObject objectResolver)
{
var connection = recordService.LoadObject(lookup, objectConfig);
var type = connection.GetType();
var connectionConfigs = objectResolver.ResolveType(typeof(ConnectionConfigs)) as ConnectionConfigs;
if (connectionConfigs == null)
{
throw new NullReferenceException(string.Format("Error loading {0}. The resolved value is null", typeof(ConnectionConfigs).Name));
}
var matchingConfig = connectionConfigs.ConnectionTypes.Where(c => type == c.ConnectionType);
if (!matchingConfig.Any())
{
throw new NullReferenceException(string.Format("Error loading {0}. No {1} has ConnectionType of {2}. Need to add the {1} to the {3} object", typeof(IRecordService).Name, typeof(ConnectionConfig).Name, type.Name, typeof(ConnectionConfigs).Name));
}
return(LoadServiceForConnection(connection, matchingConfig.First().ServiceType));
}
public static IRecordService LoadServiceForConnection(object connection, Type serviceType, IResolveObject objectResolver)
{
var connectionType = connection.GetType();
var connectionConstructors = serviceType
.GetConstructors()
.Where(c => c.GetCustomAttributes(false).Any(a => a is ConnectionConstructor))
.ToArray();
if (connectionConstructors.Any())
{
var constructor = connectionConstructors.First();
var args = new List <object>();
foreach (var parameter in constructor.GetParameters())
{
if (connection.GetType().IsTypeOf(parameter.ParameterType))
{
args.Add(connection);
}
else
{
args.Add(objectResolver.ResolveType(parameter.ParameterType));
}
}
return((IRecordService)constructor.Invoke(args.ToArray()));
}
if (!serviceType.HasConstructorFor(connectionType))
{
throw new NullReferenceException(
string.Format(
"The Type {0} Does Not Have A Constructor For Type {1}",
serviceType.Name, connectionType.Name));
}
return((IRecordService)serviceType.CreateFromConstructorFor(connection));
}
