internal static void ExtractCustomAttributeArgumentType(ITypeUniverse universe, Module module, byte[] customAttributeBlob, ref int index, out System.Reflection.Adds.CorElementType argumentTypeId, out Type argumentType)
{
argumentTypeId = SignatureUtil.ExtractElementType(customAttributeBlob, ref index);
SignatureUtil.VerifyElementType((System.Reflection.Adds.CorElementType)((int)argumentTypeId));
if ((int)argumentTypeId == 29)
{
System.Reflection.Adds.CorElementType corElementType = SignatureUtil.ExtractElementType(customAttributeBlob, ref index);
SignatureUtil.VerifyElementType(corElementType);
if (corElementType == (System.Reflection.Adds.CorElementType.Byref | System.Reflection.Adds.CorElementType.Modifier | System.Reflection.Adds.CorElementType.Sentinel | System.Reflection.Adds.CorElementType.ValueType | System.Reflection.Adds.CorElementType.Void | System.Reflection.Adds.CorElementType.Type))
{
argumentType = universe.GetBuiltInType(System.Reflection.Adds.CorElementType.Object).MakeArrayType();
return;
}
argumentType = universe.GetBuiltInType(corElementType).MakeArrayType();
return;
}
if ((int)argumentTypeId != 85)
{
if ((int)argumentTypeId == 81)
{
argumentType = null;
return;
}
argumentType = universe.GetBuiltInType((System.Reflection.Adds.CorElementType)((int)argumentTypeId));
}
else
{
argumentType = SignatureUtil.ExtractTypeValue(universe, module, customAttributeBlob, ref index);
if (argumentType == null)
{
throw new ArgumentException(MetadataStringTable.InvalidCustomAttributeFormatForEnum);
}
}
}
public Type ConvertToType(ITypeUniverse universe, Module moduleContext)
{
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
object[] mTypeName = new object[] { this.m_TypeName, this.m_AssemblyName.FullName };
string str = string.Format(invariantCulture, "{0},{1}", mTypeName);
return(System.Reflection.Adds.TypeNameParser.ParseTypeName(universe, moduleContext, str));
}
public static bool LookupPrimitive(Type type, out System.Reflection.Adds.CorElementType result)
{
result = System.Reflection.Adds.CorElementType.End;
ITypeUniverse typeUniverse = Helpers.Universe(type);
if (typeUniverse != null && !typeUniverse.GetSystemAssembly().Equals(type.Assembly))
{
return(false);
}
return(SignatureUtil.TypeMapForAttributes.s_typeNameMapForAttributes.TryGetValue(type.FullName, out result));
}
public static Type ParseTypeName(ITypeUniverse universe, Module module, string input, bool throwOnError)
{
Func <AssemblyName, Assembly> func = (AssemblyName assemblyName) => System.Reflection.Adds.TypeNameParser.DetermineAssembly(assemblyName, module, universe);
Func <Assembly, string, bool, Type> func1 = (Assembly assembly, string simpleTypeName, bool ignoreCase) => {
bool flag = false;
if (assembly != null)
{
return(assembly.GetType(simpleTypeName, flag, ignoreCase));
}
return(module.GetType(simpleTypeName, flag, ignoreCase));
};
return(Type.GetType(input, func, func1, throwOnError));
}
internal static bool IsAssignableFromHelper(Type current, Type target)
{
if (target == null)
{
return(false);
}
if (current.Equals(target))
{
return(true);
}
if (target.IsSubclassOf(current))
{
return(true);
}
Type[] interfaces = target.GetInterfaces();
for (int i = 0; i < (int)interfaces.Length; i++)
{
if (interfaces[i].Equals(current))
{
return(true);
}
if (current.IsAssignableFrom(interfaces[i]))
{
return(true);
}
}
if (target.IsGenericParameter)
{
Type[] genericParameterConstraints = target.GetGenericParameterConstraints();
for (int j = 0; j < (int)genericParameterConstraints.Length; j++)
{
if (MetadataOnlyTypeDef.IsAssignableFromHelper(current, genericParameterConstraints[j]))
{
return(true);
}
}
}
ITypeUniverse typeUniverse = Helpers.Universe(current);
if (typeUniverse == null || !current.Equals(typeUniverse.GetTypeXFromName("System.Object")))
{
return(false);
}
if (target.IsPointer || target.IsInterface)
{
return(true);
}
return(target.IsArray);
}
private bool QuickSerializationCastCheck()
{
ITypeUniverse typeUniverse = Helpers.Universe(this);
Type typeXFromName = typeUniverse.GetTypeXFromName("System.Enum");
Type type = typeUniverse.GetTypeXFromName("System.Delegate");
for (Type i = this.UnderlyingSystemType; i != null; i = i.BaseType)
{
if (i.Equals(typeXFromName) || i.Equals(type))
{
return(true);
}
}
return(false);
}
internal static Type ExtractTypeValue(ITypeUniverse universe, Module module, byte[] blob, ref int index)
{
Type type = null;
string str = SignatureUtil.ExtractStringValue(blob, ref index);
if (!string.IsNullOrEmpty(str))
{
type = System.Reflection.Adds.TypeNameParser.ParseTypeName(universe, module, str, false);
if (type == null)
{
module = universe.GetSystemAssembly().ManifestModule;
type = System.Reflection.Adds.TypeNameParser.ParseTypeName(universe, module, str);
}
}
return(type);
}
public static Assembly CreateAssembly(ITypeUniverse typeUniverse, MetadataFile manifestModuleImport, MetadataFile[] netModuleImports, IReflectionFactory factory, string manifestFile, string[] netModuleFiles)
{
int length = 1;
if (netModuleImports != null)
{
length = length + (int)netModuleImports.Length;
}
MetadataOnlyModule[] metadataOnlyModule = new MetadataOnlyModule[length];
metadataOnlyModule[0] = new MetadataOnlyModule(typeUniverse, manifestModuleImport, factory, manifestFile);
if (length > 1)
{
for (int i = 0; i < (int)netModuleImports.Length; i++)
{
metadataOnlyModule[i + 1] = new MetadataOnlyModule(typeUniverse, netModuleImports[i], factory, netModuleFiles[i]);
}
}
return(new MetadataOnlyAssembly(metadataOnlyModule, manifestFile));
}
public static IEnumerable <CustomAttributeData> GetTypeForwardedToAttributes(MetadataOnlyModule manifestModule)
{
ITypeUniverse assemblyResolver = manifestModule.AssemblyResolver;
Type builtInType = assemblyResolver.GetBuiltInType(System.Reflection.Adds.CorElementType.Type);
Assembly assembly = assemblyResolver.GetSystemAssembly();
Type type = assembly.GetType("System.Runtime.CompilerServices.TypeForwardedToAttribute", false, false);
if (type != null)
{
foreach (UnresolvedTypeName rawTypeForwardedToAttribute in PseudoCustomAttributes.GetRawTypeForwardedToAttributes(manifestModule))
{
ConstructorInfo[] constructorInfoArray = type.GetConstructors();
Type type1 = rawTypeForwardedToAttribute.ConvertToType(assemblyResolver, manifestModule);
List <CustomAttributeTypedArgument> customAttributeTypedArguments = new List <CustomAttributeTypedArgument>(1)
{
new CustomAttributeTypedArgument(builtInType, type1)
};
List <CustomAttributeNamedArgument> customAttributeNamedArguments = new List <CustomAttributeNamedArgument>(0);
yield return(new MetadataOnlyCustomAttributeData(constructorInfoArray[0], customAttributeTypedArguments, customAttributeNamedArguments));
}
}
}
protected AssemblyProxy(ITypeUniverse universe)
{
this.m_universe = universe;
}
public MetadataExtensionsPolicy20(ITypeUniverse u)
{
this.m_universe = u;
}
public static Assembly CreateAssembly(ITypeUniverse typeUniverse, MetadataFile metadataImport, IReflectionFactory factory, string manifestFile)
{
return(AssemblyFactory.CreateAssembly(typeUniverse, metadataImport, null, factory, manifestFile, null));
}
public static Type ParseTypeName(ITypeUniverse universe, Module module, string input)
{
return(System.Reflection.Adds.TypeNameParser.ParseTypeName(universe, module, input, true));
}
private static Assembly DetermineAssembly(AssemblyName assemblyName, Module defaultTokenResolver, ITypeUniverse universe)
{
Module module = defaultTokenResolver;
if (assemblyName == null)
{
if (defaultTokenResolver == null)
{
throw new ArgumentException(MetadataStringTable.DefaultTokenResolverRequired);
}
return(module.Assembly);
}
if (universe == null)
{
throw new ArgumentException(MetadataStringTable.HostSpecifierMissing);
}
Assembly assembly = universe.ResolveAssembly(assemblyName);
if (assembly == null)
{
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
string universeCannotResolveAssembly = MetadataStringTable.UniverseCannotResolveAssembly;
object[] objArray = new object[] { assemblyName };
throw new ArgumentException(string.Format(invariantCulture, universeCannotResolveAssembly, objArray));
}
return(assembly);
}
public AssemblyRef(AssemblyName name, ITypeUniverse universe) : base(universe)
{
this.m_name = name;
}
public static Assembly CreateAssembly(ITypeUniverse typeUniverse, MetadataFile metadataImport, string manifestFile)
{
return(AssemblyFactory.CreateAssembly(typeUniverse, metadataImport, new DefaultFactory(), manifestFile));
}
public static Assembly CreateAssembly(ITypeUniverse typeUniverse, MetadataFile manifestModuleImport, MetadataFile[] netModuleImports, string manifestFile, string[] netModuleFiles)
{
return(AssemblyFactory.CreateAssembly(typeUniverse, manifestModuleImport, netModuleImports, new DefaultFactory(), manifestFile, netModuleFiles));
}
internal static IList <CustomAttributeTypedArgument> ExtractListOfValues(Type elementType, ITypeUniverse universe, Module module, uint size, byte[] blob, ref int index)
{
System.Reflection.Adds.CorElementType typeId = SignatureUtil.GetTypeId(elementType);
List <CustomAttributeTypedArgument> customAttributeTypedArguments = new List <CustomAttributeTypedArgument>((int)size);
if (typeId == System.Reflection.Adds.CorElementType.Object)
{
for (int i = 0; (long)i < (ulong)size; i++)
{
System.Reflection.Adds.CorElementType corElementType = SignatureUtil.ExtractElementType(blob, ref index);
SignatureUtil.VerifyElementType(corElementType);
Type builtInType = null;
object obj = null;
if (corElementType == System.Reflection.Adds.CorElementType.SzArray)
{
throw new NotImplementedException(MetadataStringTable.ArrayInsideArrayInAttributeNotSupported);
}
if (corElementType != System.Reflection.Adds.CorElementType.Enum)
{
builtInType = universe.GetBuiltInType(corElementType);
obj = SignatureUtil.ExtractValue(corElementType, blob, ref index);
}
else
{
builtInType = SignatureUtil.ExtractTypeValue(universe, module, blob, ref index);
if (builtInType == null)
{
throw new ArgumentException(MetadataStringTable.InvalidCustomAttributeFormatForEnum);
}
System.Reflection.Adds.CorElementType typeId1 = SignatureUtil.GetTypeId(MetadataOnlyModule.GetUnderlyingType(builtInType));
obj = SignatureUtil.ExtractValue(typeId1, blob, ref index);
}
customAttributeTypedArguments.Add(new CustomAttributeTypedArgument(builtInType, obj));
}
}
else if (typeId != System.Reflection.Adds.CorElementType.Type)
{
if (typeId == System.Reflection.Adds.CorElementType.SzArray)
{
throw new ArgumentException(MetadataStringTable.JaggedArrayInAttributeNotSupported);
}
for (int j = 0; (long)j < (ulong)size; j++)
{
object obj1 = SignatureUtil.ExtractValue(typeId, blob, ref index);
customAttributeTypedArguments.Add(new CustomAttributeTypedArgument(elementType, obj1));
}
}
else
{
for (int k = 0; (long)k < (ulong)size; k++)
{
object obj2 = SignatureUtil.ExtractTypeValue(universe, module, blob, ref index);
customAttributeTypedArguments.Add(new CustomAttributeTypedArgument(elementType, obj2));
}
}
return(customAttributeTypedArguments.AsReadOnly());
}
