public CommandResult Handle(object command)
{
var handlerType = typeof(ICommandHandler <>).MakeGenericType(command.GetType());
dynamic handler = _typeResolver.GetType(handlerType);
var result = handler.Handle((dynamic)command);
return(result);
}
public TResult Map <TResult>(object source)
{
if (source == null)
{
return(default(TResult));
}
var sourceType = typeResolver.GetType(source);
var mapper = context.Resolve(typeof(IMap <,>).MakeGenericType(sourceType, typeof(TResult)));
return((TResult)mapper.GetType().GetMethod("Map", new[] { sourceType }).Invoke(mapper, new[] { source }));
}
public IMember Clone(ITypeResolver typeResolver)
{
string name;
string str;
if (typeResolver == this.typeResolver)
{
return(this);
}
if (this.IsGenericType)
{
if (this.RuntimeType == null)
{
return(null);
}
return(typeResolver.GetType(this.RuntimeType));
}
if (this.xmlNamespace != null)
{
return(typeResolver.GetType(this.xmlNamespace, this.Name));
}
if (this.typeResolver.ProjectAssembly != null)
{
name = this.typeResolver.ProjectAssembly.Name;
}
else
{
name = null;
}
string str1 = name;
if (typeResolver.ProjectAssembly != null)
{
str = typeResolver.ProjectAssembly.Name;
}
else
{
str = null;
}
string str2 = str;
string str3 = (this.assemblyName == null ? str1 : this.assemblyName);
if (str2 == str3)
{
str3 = null;
}
return(typeResolver.GetType(str3, TypeHelper.CombineNamespaceAndTypeName(this.Namespace, this.Name)));
}
public static IndexedClrPropertyReferenceStep GetReferenceStep(ITypeResolver typeResolver, Type declaringType, int index, bool throwOnFailure)
{
Type[] typeArray = new Type[] { typeof(int) };
string str = "Item";
System.Reflection.PropertyInfo property = declaringType.GetProperty(str, BindingFlags.Instance | BindingFlags.Public, null, null, typeArray, null);
if (property == null)
{
if (typeof(IList).IsAssignableFrom(declaringType))
{
property = typeof(IList).GetProperty(str, BindingFlags.Instance | BindingFlags.Public, null, null, typeArray, null);
}
if (property == null)
{
if (throwOnFailure)
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
string typeDoesNotDeclareAnIndexer = ExceptionStringTable.TypeDoesNotDeclareAnIndexer;
object[] name = new object[] { declaringType.Name };
throw new ArgumentException(string.Format(currentCulture, typeDoesNotDeclareAnIndexer, name), "declaringType");
}
return(null);
}
}
IType type = typeResolver.GetType(declaringType);
IType propertyTypeId = PlatformTypeHelper.GetPropertyTypeId(typeResolver, property);
IPlatformMetadata platformMetadata = typeResolver.PlatformMetadata;
object[] objArray = new object[] { index };
ClrPropertyImplementationBase localClrPropertyImplementation = new LocalClrPropertyImplementation(platformMetadata, property, null, objArray);
return(new IndexedClrPropertyReferenceStep(type, str, propertyTypeId, localClrPropertyImplementation, index));
}
public static ReadOnlyCollection <DefaultStateRecord> GetDefaultStateRecords(IType controlType, ITypeResolver typeResolver)
{
List <DefaultStateRecord> list = new List <DefaultStateRecord>();
if (controlType == null || typeResolver == null || (typeResolver.PlatformMetadata.IsNullType((ITypeId)controlType) || typeResolver.PlatformMetadata.IsNullType((ITypeId)typeResolver.ResolveType(ProjectNeutralTypes.VisualStateManager))))
{
return(new ReadOnlyCollection <DefaultStateRecord>((IList <DefaultStateRecord>)list));
}
foreach (Attribute attribute in TypeUtilities.GetAttributes(controlType.RuntimeType))
{
Type type1 = attribute.GetType();
IType type2 = typeResolver.GetType(type1);
if (!typeResolver.PlatformMetadata.IsNullType((ITypeId)type2) && ProjectNeutralTypes.TemplateVisualStateAttribute.IsAssignableFrom((ITypeId)type2))
{
DefaultStateRecord defaultStateRecord = new DefaultStateRecord();
PropertyInfo property1 = type1.GetProperty("Name");
defaultStateRecord.StateName = property1.GetValue((object)attribute, (object[])null) as string;
PropertyInfo property2 = type1.GetProperty("GroupName");
defaultStateRecord.GroupName = property2.GetValue((object)attribute, (object[])null) as string;
if (!string.IsNullOrEmpty(defaultStateRecord.StateName) && !string.IsNullOrEmpty(defaultStateRecord.GroupName))
{
list.Add(defaultStateRecord);
}
}
}
return(new ReadOnlyCollection <DefaultStateRecord>((IList <DefaultStateRecord>)list));
}
internal static IType GetTypeId(ITypeResolver typeResolver, ClrNamespaceUriParseCache documentNamespaces, XmlNamespace xmlNamespace, string typeName, bool instantiateUnrecognizedTypes, bool inMarkupExtension)
{
IType designTimeType = typeResolver.PlatformMetadata.GetDesignTimeType(typeResolver, (IXmlNamespace)xmlNamespace, typeName);
if (designTimeType != null)
{
return(designTimeType);
}
AssemblyNamespace assemblyNamespace;
documentNamespaces.GetNamespace((IXmlNamespace)xmlNamespace, out assemblyNamespace);
IType type;
if (assemblyNamespace != null)
{
type = XamlTypeHelper.ResolveType(typeResolver, (IXmlNamespaceTypeResolver)documentNamespaces, xmlNamespace, typeName, inMarkupExtension);
if (type == null && instantiateUnrecognizedTypes)
{
IAssembly assembly = assemblyNamespace.Assembly;
string clrNamespace = assemblyNamespace.ClrNamespace;
type = typeResolver.GetType(assembly.Name, TypeHelper.CombineNamespaceAndTypeName(clrNamespace, typeName)) ?? typeResolver.PlatformMetadata.CreateUnknownType(typeResolver, assembly, clrNamespace, typeName);
}
}
else
{
type = XamlTypeHelper.ResolveType(typeResolver, typeResolver.ProjectNamespaces, xmlNamespace, typeName, inMarkupExtension);
if (type == null && instantiateUnrecognizedTypes)
{
type = typeResolver.PlatformMetadata.CreateUnknownType(typeResolver, (IXmlNamespace)xmlNamespace, typeName);
}
}
return(type);
}
/// <summary>
/// Registers the default implementation for the given interface <paramref name="implementationTypeName"/>
/// so that <see cref="CreateGrain{TInterface}(object[])"/> can be used.
/// </summary>
/// <typeparam name="TInterface"></typeparam>
public void RegisterDefaultImplementation <TInterface>(string implementationTypeName)
where TInterface : class
{
Type implementationType;
if (_customTypeResolver != null)
{
implementationType = _customTypeResolver.GetType(implementationTypeName);
}
else
{
implementationType = TypeResolver.GetType(implementationTypeName);
}
_registry.RegisterDefaultImplementation(implementationType, typeof(TInterface));
}
public QualifiedType Add(GenericName identifier, ITypeResolver resolver)
{
var type = Type;
if (type != null)
{
throw new InvalidOperationException("Cannot further qualify an existing type.");
}
var typeArguments = identifier.TypeArguments;
var typeName = TypeName != null ? TypeName + "." + identifier.Name : identifier.Name;
if (typeArguments != Type.EmptyTypes)
{
typeName += "`" + typeArguments.Length;
}
type = resolver.GetType(typeName);
if (typeArguments != Type.EmptyTypes)
{
type = type.MakeGenericType(typeArguments);
}
return(new QualifiedType(type, typeName));
}
private IDocumentNodePropertyBuilder GetDefaultHandler(ITypeResolver typeResolver, Type type)
{
IDocumentNodePropertyBuilder documentNodePropertyBuilder;
base.InitializeIfNecessary();
IType type1 = typeResolver.GetType(type);
if (type1 != null)
{
if (type.IsValueType && type1.TypeConverter != null && !PlatformTypes.TypeConverter.Equals(typeResolver.GetType(type1.TypeConverter.GetType())))
{
return(null);
}
MemberAccessTypes allowableMemberAccess = TypeHelper.GetAllowableMemberAccess(typeResolver, type1);
using (IEnumerator <IProperty> enumerator = type1.Metadata.Properties.GetEnumerator())
{
while (enumerator.MoveNext())
{
IProperty current = enumerator.Current;
if (!current.ShouldSerialize || !TypeHelper.IsSet(allowableMemberAccess, current.WriteAccess) && current.PropertyType.ItemType == null)
{
continue;
}
documentNodePropertyBuilder = this.defaultPropertyBuilder;
return(documentNodePropertyBuilder);
}
return(null);
}
return(documentNodePropertyBuilder);
}
return(null);
}
private Type ReadTypeInformation(BinaryReader reader)
{
var typeName = ReadValueAsString(reader);
var type = _typeResolver?.GetType(typeName) ?? Type.GetType(typeName);
return(type);
}
private void LogContainerInitialization()
{
_logger.LogDebugDetails(BootstrapLogEvents.BOOTSTRAP_INITIALIZE, "Container Setup", new
{
TypeResolver = _typeResover.GetType(),
Configs = _configs.Keys.Select(ct => ct.AssemblyQualifiedName)
});
}
public IMember Clone(ITypeResolver typeResolver)
{
if (this.PlatformMetadata == typeResolver.PlatformMetadata)
{
return(this);
}
return(typeResolver.GetType(this.type));
}
public T Handle <T>(IQuery <T> query)
{
var handlerType = typeof(IQueryHandler <,>).MakeGenericType(query.GetType(), typeof(T));
dynamic handler = _typeResolver.GetType(handlerType);
var result = handler.Handle((dynamic)query);
return(result);
}
private Type GetType(string assemblyQualifiedName)
{
if (_customTypeResolver != null)
{
return(_customTypeResolver.GetType(assemblyQualifiedName));
}
return(TypeResolver.GetType(assemblyQualifiedName));
}
public static bool IsAccessibleType(ITypeResolver typeResolver, Type type)
{
IType type1 = typeResolver.GetType(type);
if (type1 != null)
{
return(TypeHelper.IsAccessibleType(typeResolver, type1));
}
return(false);
}
public static IType GetFieldTypeId(ITypeResolver typeResolver, FieldInfo fieldInfo)
{
Type fieldType = PlatformTypeHelper.GetFieldType(fieldInfo);
if (fieldType != (Type)null)
{
return(typeResolver.GetType(fieldType));
}
return((IType)null);
}
internal static IType GetType(ITypeResolver typeResolver, IAssembly assembly, string typeName)
{
Type type = PlatformTypeHelper.GetType(assembly, typeName);
if (type != (Type)null)
{
return(typeResolver.GetType(type));
}
return((IType)null);
}
public static IType GetPropertyTypeId(ITypeResolver typeResolver, PropertyInfo propertyInfo)
{
Type propertyType = PlatformTypeHelper.GetPropertyType(propertyInfo);
if (propertyType != (Type)null)
{
return(typeResolver.GetType(propertyType));
}
return((IType)null);
}
internal static IMember GetMember(ITypeResolver typeResolver, Type type, MemberType memberTypes, string memberName)
{
if (TypeHelper.IsSet(memberTypes, MemberType.Property))
{
ITypeId typeId = (ITypeId)typeResolver.GetType(type);
IProperty property = (IProperty)PlatformTypeHelper.GetProperty(typeResolver, typeId, memberTypes & MemberType.Property, memberName);
if (property != null)
{
return((IMember)property);
}
}
if (TypeHelper.IsSet(memberTypes, MemberType.Event))
{
IEvent @event = PlatformTypeHelper.GetEvent(typeResolver, type, memberName);
if (@event != null)
{
return((IMember)@event);
}
}
if (TypeHelper.IsSet(memberTypes, MemberType.Field))
{
FieldInfo fieldInfo = PlatformTypeHelper.GetFieldInfo(type, memberName);
if (fieldInfo != (FieldInfo)null)
{
return((IMember)FieldReferenceStep.GetReferenceStep(typeResolver, fieldInfo));
}
}
if (TypeHelper.IsSet(memberTypes, MemberType.Method))
{
MethodInfo method = PlatformTypeHelper.GetMethod(type, memberName);
if (method != (MethodInfo)null)
{
IType type1 = typeResolver.GetType(method.DeclaringType);
if (type1 == null)
{
return((IMember)null);
}
return((IMember)Method.GetMethod(typeResolver, type1, method));
}
}
return((IMember)null);
}
private static IType GetItemType(ITypeResolver typeResolver, Type type)
{
CollectionAdapterDescription adapterDescription = CollectionAdapterDescription.GetAdapterDescription(type);
IType type1 = null;
if (adapterDescription != null)
{
type1 = typeResolver.GetType(adapterDescription.ItemType);
}
return(type1);
}
private Type ResolveTypeName(string typeName)
{
Type type;
if (TypeNameTobuiltInType.TryGetValue(typeName, out type))
{
return(type);
}
type = _typeResolver?.GetType(typeName) ?? Type.GetType(typeName);
return(type);
}
protected virtual DocumentCompositeNode CreateCompositeNode(IDocumentContext documentContext, Type instanceType, Type childType)
{
ITypeResolver typeResolver = documentContext.TypeResolver;
IType type = typeResolver.GetType(instanceType);
if (type == null || !TypeHelper.IsAccessibleType(typeResolver, type))
{
return(null);
}
IType type1 = null;
if (childType != null)
{
type1 = typeResolver.GetType(childType);
if (type1 == null || !TypeHelper.IsAccessibleType(typeResolver, type1))
{
return(null);
}
}
return(new DocumentCompositeNode(documentContext, type, type1));
}
public static IEvent GetEvent(ITypeResolver typeResolver, Type targetType, string memberName)
{
IType type = typeResolver.GetType(targetType);
if (type == null)
{
return((IEvent)null);
}
MemberAccessTypes allowableMemberAccess = TypeHelper.GetAllowableMemberAccess(typeResolver, type);
return((IEvent)type.GetMember(MemberType.Event, memberName, allowableMemberAccess));
}
public static IMemberId GetRoutedCommandMember(ITypeResolver typeResolver, Type type, string commandName)
{
IType type1 = typeResolver.GetType(type);
if (type1 == null)
{
return((IMemberId)null);
}
MemberAccessTypes allowableMemberAccess = TypeHelper.GetAllowableMemberAccess(typeResolver, type1);
return(type1.GetMember(MemberType.LocalProperty | MemberType.Field, commandName, allowableMemberAccess) ?? type1.GetMember(MemberType.LocalProperty | MemberType.Field, commandName + "Command", allowableMemberAccess));
}
public static bool CanCreateTypeInXaml(ITypeResolver typeResolver, Type type)
{
IType type1 = typeResolver.GetType(type);
if (typeResolver.PlatformMetadata.IsNullType(type1) || !TypeHelper.IsAccessibleType(typeResolver, type1) || Nullable.GetUnderlyingType(type) != null)
{
return(false);
}
if (type == typeof(string) || TypeUtilities.HasDefaultConstructor(type, typeResolver.InTargetAssembly(type1)))
{
return(true);
}
return(type1.TypeConverter.CanConvertFrom(typeof(string)));
}
public IType GetType(ITypeResolver typeResolver, string typeName)
{
if (this.Assembly.IsLoaded)
{
string typeName1 = TypeHelper.CombineNamespaceAndTypeName(this.ClrNamespace, typeName);
try
{
return(typeResolver.GetType(this.Assembly, typeName1));
}
catch (Exception ex)
{
}
}
return((IType)null);
}
public static IEvent GetEvent(ITypeResolver typeResolver, RoutedEvent routedEvent)
{
IType type = typeResolver.GetType(routedEvent.OwnerType);
if (type != null)
{
MemberAccessTypes allowableMemberAccess = TypeHelper.GetAllowableMemberAccess(typeResolver, type);
Event @event = (Event)type.GetMember(MemberType.Event, routedEvent.Name, allowableMemberAccess);
if (@event != null && @event.RoutedEvent == routedEvent)
{
return((IEvent)@event);
}
}
return((IEvent)null);
}
private static IList GetVisualStateGroups(object hostElement, ITypeResolver typeResolver)
{
IType type1 = typeResolver.ResolveType(ProjectNeutralTypes.VisualStateManager);
typeResolver.ResolveType(ProjectNeutralTypes.VisualStateGroup);
IType type2 = typeResolver.GetType(hostElement.GetType());
if (!PlatformTypes.FrameworkElement.IsAssignableFrom((ITypeId)type2))
{
return((IList) new List <object>());
}
return(PlatformTypeHelper.GetMethod(type1.RuntimeType, "GetVisualStateGroups").Invoke(null, new object[1]
{
hostElement
}) as IList);
}
private static ReferenceStep GetContentProperty(ITypeResolver typeResolver, Type type, string propertyName)
{
IType type1 = typeResolver.GetType(type);
if (type1 == null)
{
return(null);
}
MemberAccessTypes allowableMemberAccess = TypeHelper.GetAllowableMemberAccess(typeResolver, type1);
if (PlatformTypes.UserControl.IsAssignableFrom(type1))
{
allowableMemberAccess = allowableMemberAccess | MemberAccessTypes.Protected;
}
return((ReferenceStep)type1.GetMember(MemberType.Property, propertyName, allowableMemberAccess));
}
public static IEnumerable <PropertyInformation> GetPropertiesForType(Type objectType, ITypeResolver typeResolver)
{
IType type = typeResolver.GetType(objectType);
if (type != null)
{
foreach (IProperty property in ITypeExtensions.GetProperties(type, MemberAccessTypes.PublicOrInternal, true))
{
DependencyPropertyReferenceStep dependencyPropertyReferenceStep = property as DependencyPropertyReferenceStep;
if (dependencyPropertyReferenceStep != null)
{
yield return(new PropertyInformation(dependencyPropertyReferenceStep));
}
}
}
}
