public override bool IsAssignableFrom(ITypeId type)
{
if (type == null || !type.IsResolvable)
{
return(false);
}
if (this.knownUnreferencedType != KnownUnreferencedType.None)
{
IUnreferencedTypeId unreferencedTypeId = type as IUnreferencedTypeId;
if (unreferencedTypeId != null && unreferencedTypeId.IsKnownUnreferencedType(this.knownUnreferencedType))
{
return(true);
}
}
IType type1 = (IType)type;
IType type2 = type1.PlatformMetadata.ResolveType(this);
if (type2.IsResolvable)
{
return(type2.IsAssignableFrom(type));
}
ProjectContextType projectContextType = type1 as ProjectContextType;
if (projectContextType != null)
{
type2 = projectContextType.TypeResolver.ResolveType(this);
if (type2 != null)
{
return(type2.IsAssignableFrom(type));
}
}
return(false);
}
public void Initialize(IXmlNamespace xmlNamespace, Type type, string key)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
PlatformTypes platformMetadata = (PlatformTypes)this.PlatformMetadata;
this.isBuilt = true;
this.xmlNamespace = xmlNamespace;
this.type = type;
Type nearestSupportedType = platformMetadata.GetNearestSupportedType(this.type);
if (nearestSupportedType != null)
{
this.nearestSupportedType = platformMetadata.GetType(nearestSupportedType);
}
this.lastResolvedType = this.type;
this.name = ProjectContextType.GetNameIncludingAnyDeclaringTypes(this.type);
Assembly assembly = this.type.Assembly;
IAssembly projectAssembly = this.typeResolver.ProjectAssembly;
if (projectAssembly == null || !projectAssembly.CompareTo(assembly))
{
this.assemblyName = AssemblyHelper.GetAssemblyName(assembly).Name;
if (projectAssembly != null)
{
bool name = this.assemblyName == projectAssembly.Name;
}
}
this.members = new MemberCollection(this.typeResolver, this);
this.assembly = this.GetAssembly(this.typeResolver, this.assemblyName);
if (type.IsArray)
{
this.arrayItemType = ProjectContextType.GetItemType(this.typeResolver, type);
this.arrayRank = type.GetArrayRank();
}
this.genericTypeArguments = PlatformTypeHelper.GetGenericTypeArguments(this.typeResolver, this.type);
if (this.genericTypeArguments.Count > 0)
{
foreach (IType genericTypeArgument in this.genericTypeArguments)
{
ProjectContextType projectContextType = genericTypeArgument as ProjectContextType;
if (projectContextType == null)
{
continue;
}
this.genericDepth = Math.Max(projectContextType.genericDepth + 1, this.genericDepth);
}
}
this.Cache();
this.hashCode = key.GetHashCode();
}
private IType GetType(string key, IAssembly assembly, Type type)
{
ProjectContextType projectContextType;
IType type1 = this.platformTypes.GetType(type);
if (type1 != null)
{
return(type1);
}
if (assembly == null)
{
assembly = this.GetAssembly(type.Assembly);
if (assembly == null)
{
IAssembly assembly1 = this.platformTypes.CreateAssembly(type.Assembly, AssemblySource.Unknown);
foreach (IAssembly assemblyReference in this.AssemblyReferences)
{
if (!assembly1.Name.StartsWith(assemblyReference.Name, StringComparison.OrdinalIgnoreCase))
{
continue;
}
string str = assembly1.Name.Substring(assemblyReference.Name.Length);
if (string.Compare(str, ".design", StringComparison.OrdinalIgnoreCase) != 0 && string.Compare(str, ".expression.design", StringComparison.OrdinalIgnoreCase) != 0)
{
continue;
}
assembly = assembly1;
}
if (assembly == null)
{
return(null);
}
}
}
if (key == null)
{
key = this.GetKey(assembly, type);
if (key == null)
{
return(null);
}
}
if (!this.typeIds.TryGetValue(key, out projectContextType))
{
projectContextType = new ProjectContextType(this, key);
this.typeIds.Add(key, projectContextType);
IXmlNamespace @namespace = this.ProjectNamespaces.GetNamespace(assembly, type);
projectContextType.Initialize(@namespace, type, key);
}
return(projectContextType);
}
public override bool Equals(object obj)
{
if (this == obj)
{
return(true);
}
ITypeId typeId = obj as ITypeId;
if (typeId == null)
{
return(false);
}
ProjectContextType projectContextType = this.typeResolver.ResolveType(typeId) as ProjectContextType;
if (projectContextType == null)
{
return(false);
}
return(projectContextType.internalName == this.internalName);
}
public IType GetType(string assemblyName, string typeName)
{
IAssembly assembly;
ProjectContextType projectContextType;
UnbuiltTypeDescription unbuiltTypeDescription;
IType type = null;
if (string.IsNullOrEmpty(typeName))
{
throw new ArgumentException(ExceptionStringTable.GetTypeCannotBeCalledWithNullOrEmptyTypeName, "typeName");
}
assembly = (!string.IsNullOrEmpty(assemblyName) ? this.GetAssembly(assemblyName) : this.ProjectAssembly);
if (assembly != null)
{
string key = this.GetKey(assembly, typeName);
if (this.typeIds.TryGetValue(key, out projectContextType))
{
return(projectContextType);
}
Type type1 = null;
try
{
type1 = PlatformTypeHelper.GetType(assembly, typeName);
}
catch (Exception exception)
{
}
if (type1 != null)
{
type = this.GetType(key, assembly, type1);
}
if (type == null && this.unbuiltTypeInfo.TryGetValue(key, out unbuiltTypeDescription))
{
projectContextType = new ProjectContextType(this, key);
this.typeIds.Add(key, projectContextType);
projectContextType.Initialize(unbuiltTypeDescription, key);
type = projectContextType;
}
}
return(type);
}
private string GetKey(IAssemblyId assembly, Type type)
{
string nameIncludingAnyDeclaringTypes = ProjectContextType.GetNameIncludingAnyDeclaringTypes(type);
string key = this.GetKey(assembly, Microsoft.Expression.DesignModel.Metadata.TypeHelper.CombineNamespaceAndTypeName(type.Namespace, nameIncludingAnyDeclaringTypes));
if (!type.IsGenericType)
{
return(key);
}
StringBuilder stringBuilder = new StringBuilder(key);
stringBuilder.Append('<');
Type[] genericTypeArguments = PlatformTypeHelper.GetGenericTypeArguments(type);
if (genericTypeArguments == null)
{
return(null);
}
for (int i = 0; i < (int)genericTypeArguments.Length; i++)
{
Type type1 = genericTypeArguments[i];
if (i > 0)
{
stringBuilder.Append(',');
}
IAssembly assembly1 = this.GetAssembly(type1.Assembly);
if (assembly1 == null)
{
return(null);
}
string str = this.GetKey(assembly1, type1);
if (str == null)
{
return(null);
}
stringBuilder.Append(str);
}
stringBuilder.Append('>');
return(stringBuilder.ToString());
}
public override bool Equals(object obj)
{
bool flag;
if (this == obj)
{
return(true);
}
ITypeId typeId = obj as ITypeId;
if (typeId != null && (base.FullName == typeId.FullName || this.MatchesPotentialFullName(typeId.FullName)))
{
ProjectContextType projectContextType = typeId as ProjectContextType;
if (projectContextType == null)
{
return(true);
}
IPlatformTypes platformMetadata = (IPlatformTypes)projectContextType.PlatformMetadata;
using (IEnumerator <IAssemblyId> enumerator = platformMetadata.GetAssemblyGroup(this.AssemblyGroup).GetEnumerator())
{
while (enumerator.MoveNext())
{
IAssemblyId current = enumerator.Current;
if (projectContextType.RuntimeAssembly.Name != current.Name)
{
continue;
}
flag = true;
return(flag);
}
return(false);
}
return(flag);
}
return(false);
}
public bool Refresh()
{
ITypeId typeId = this.baseType;
IPropertyId propertyId = this.nameProperty;
IPropertyId propertyId1 = this.defaultContentProperty;
ITypeId typeId1 = this.itemType;
ITypeId typeId2 = this.nullableType;
System.ComponentModel.TypeConverter typeConverter = this.typeConverter;
IAssembly assembly = this.GetAssembly(this.typeResolver, this.assemblyName);
if (!assembly.IsLoaded)
{
return(true);
}
this.assembly = assembly;
this.type = this.GetRuntimeType();
this.typeConverter = null;
this.initializationException = null;
if (this.type != null)
{
this.lastResolvedType = this.type;
this.isBuilt = true;
}
this.Cache();
bool flag = true;
if (this.constructors != null)
{
foreach (Constructor constructor in this.constructors)
{
ICachedMemberInfo cachedMemberInfo = constructor;
if (cachedMemberInfo == null || cachedMemberInfo.Refresh())
{
continue;
}
flag = false;
}
if (flag && this.type != null)
{
int num = 0;
ConstructorInfo[] constructors = PlatformTypeHelper.GetConstructors(this.type);
if (constructors != null)
{
ConstructorInfo[] constructorInfoArray = constructors;
for (int i = 0; i < (int)constructorInfoArray.Length; i++)
{
if (PlatformTypeHelper.IsAccessibleConstructor(constructorInfoArray[i]))
{
num++;
}
}
}
if (num != this.constructors.Count)
{
flag = false;
}
}
}
if (!this.members.Refresh())
{
flag = false;
}
if (flag && (typeId != this.baseType || typeId1 != this.itemType || typeId2 != this.nullableType))
{
flag = false;
}
if (flag && (propertyId != this.nameProperty || propertyId1 != this.defaultContentProperty))
{
flag = false;
}
if (flag && ProjectContextType.GetTypeConverterId(typeConverter) != ProjectContextType.GetTypeConverterId(this.typeConverter))
{
flag = false;
}
if (flag && this.constructorArgumentProperties != null)
{
IConstructorArgumentProperties constructorArgumentProperties = PlatformTypeHelper.GetConstructorArgumentProperties(this);
if (constructorArgumentProperties.Count == this.constructorArgumentProperties.Count)
{
foreach (string constructorArgumentProperty in constructorArgumentProperties)
{
if (constructorArgumentProperties[constructorArgumentProperty] == this.constructorArgumentProperties[constructorArgumentProperty])
{
continue;
}
flag = false;
break;
}
}
else
{
flag = false;
}
}
return(flag);
}
private Type GetRuntimeType(ITypeResolver typeResolver, ProjectContextType typeId)
{
Type type;
if (RuntimeGeneratedTypesHelper.IsControlEditingAssembly(typeId.assembly))
{
Type sourceType = ControlEditingDesignTypeGenerator.GetSourceType(typeId.RuntimeType);
if (sourceType != null)
{
ProjectContextType projectContextType = typeResolver.GetType(sourceType) as ProjectContextType;
if (projectContextType != null)
{
Type runtimeType = projectContextType.GetRuntimeType();
if (runtimeType != sourceType && runtimeType != null)
{
Type type1 = (new ControlEditingDesignTypeGenerator(typeResolver)).DefineType(runtimeType);
if (type1 != typeId.RuntimeType)
{
this.assemblyName = AssemblyHelper.GetAssemblyName(type1.Assembly).Name;
this.assembly = this.GetAssembly(this.typeResolver, this.assemblyName);
return(type1);
}
}
}
}
}
if (typeId.arrayItemType == null)
{
IAssembly runtimeAssembly = typeId.RuntimeAssembly;
if (runtimeAssembly != null)
{
runtimeAssembly = this.GetAssembly(typeResolver, runtimeAssembly.Name);
}
if (runtimeAssembly != null)
{
Type type2 = PlatformTypeHelper.GetType(runtimeAssembly, typeId.FullName);
if (type2 != null)
{
if (!typeId.IsGenericType)
{
return(type2);
}
IList <IType> genericTypeArguments = typeId.GetGenericTypeArguments();
int count = genericTypeArguments.Count;
if (count > 0)
{
Type[] typeArray = new Type[count];
for (int i = 0; i < count; i++)
{
Type runtimeType1 = this.GetRuntimeType(genericTypeArguments[i]);
if (runtimeType1 == null)
{
return(null);
}
typeArray[i] = runtimeType1;
}
try
{
type = type2.MakeGenericType(typeArray);
}
catch (ArgumentException argumentException)
{
return(null);
}
return(type);
}
}
}
}
else
{
Type runtimeType2 = this.GetRuntimeType(typeId.arrayItemType);
if (runtimeType2 != null)
{
if (typeId.arrayRank <= 1)
{
return(runtimeType2.MakeArrayType());
}
return(runtimeType2.MakeArrayType(typeId.arrayRank));
}
}
return(null);
}
private void Cache()
{
Type runtimeType;
ITypeMetadata metadata;
if (this.isBuilt)
{
this.baseType = null;
if (this.type != null)
{
Type baseType = this.type.BaseType;
if (baseType != null)
{
this.baseType = this.typeResolver.GetType(baseType);
}
}
else if (this.lastResolvedType != null && this.lastResolvedType.BaseType != null)
{
this.baseType = this.typeResolver.GetType(this.lastResolvedType.BaseType);
}
if (this.baseType == null && !this.IsInterface)
{
this.baseType = this.typeResolver.ResolveType(PlatformTypes.Object);
}
}
if (this.NearestResolvedType != null)
{
runtimeType = this.NearestResolvedType.RuntimeType;
}
else
{
runtimeType = null;
}
Type type = runtimeType;
if (type == null)
{
type = typeof(object);
}
if (this.typeResolver.MetadataFactory != null)
{
metadata = this.typeResolver.MetadataFactory.GetMetadata(type);
}
else
{
metadata = null;
}
this.metadata = metadata;
if (this.metadata == null || this.genericDepth >= 10)
{
this.nameProperty = null;
this.defaultContentProperty = null;
}
else
{
this.nameProperty = this.metadata.NameProperty;
this.defaultContentProperty = this.metadata.DefaultContentProperty;
}
this.itemType = ProjectContextType.GetItemType(this.typeResolver, type);
this.nullableType = null;
Type nullableType = PlatformTypeHelper.GetNullableType(type);
if (nullableType != null)
{
this.nullableType = this.typeResolver.GetType(nullableType);
}
if (this.PlatformMetadata != null)
{
this.typeConverter = this.PlatformMetadata.GetTypeConverter(type);
}
}
