private static AssemblyBuilder BuildAssembly(DynamicTypeInfo info) { AppDomain aDomain = Thread.GetDomain(); // Build the assembly AssemblyName asmName = new AssemblyName(); asmName.Name = info.DynamicTypeName + DynamicTypeInfo.DynamicAssemblyNameSuffix; AssemblyBuilder asmBuilder; if (info.DynamicTypeShouldSave) { if (String.IsNullOrEmpty(info.DynamicTypeFileDirectory)) { asmBuilder = aDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave); } else { asmBuilder = aDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave, info.DynamicTypeFileDirectory); } } else { asmBuilder = aDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Run); } return(asmBuilder); }
private static void BuildProperties(DynamicTypeInfo info, TypeBuilder typBuilder, List <FieldBuilder> fieldBuilders, GenericTypeParameterBuilder[] parameterBuilders) { for (int i = 0; i < info.PropertyNames.Count; i++) { //var propBuilder = typBuilder.DefineProperty( // info.PropertyNames[i], PropertyAttributes.None, parameterBuilders[i], Type.EmptyTypes); var propBuilder = typBuilder.DefineProperty( info.PropertyNames[i], PropertyAttributes.HasDefault, parameterBuilders[i], Type.EmptyTypes); // Build Get prop var getMethBuilder = typBuilder.DefineMethod( "get_" + info.PropertyNames[i], MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, parameterBuilders[i], Type.EmptyTypes); var generator = getMethBuilder.GetILGenerator(); generator.Emit(OpCodes.Ldarg_0); // load 'this' generator.Emit(OpCodes.Ldfld, fieldBuilders[i]); // load the field generator.Emit(OpCodes.Ret); propBuilder.SetGetMethod(getMethBuilder); // Build Set prop var setMethBuilder = typBuilder.DefineMethod( "set_" + info.PropertyNames[i], MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, typeof(void), new Type[] { fieldBuilders[i].FieldType }); generator = setMethBuilder.GetILGenerator(); generator.Emit(OpCodes.Ldarg_0); // load 'this' generator.Emit(OpCodes.Ldarg_1); // load value generator.Emit(OpCodes.Stfld, fieldBuilders[i]); generator.Emit(OpCodes.Ret); propBuilder.SetSetMethod(setMethBuilder); } }
private static GenericTypeParameterBuilder[] BuildGenericParameters(DynamicTypeInfo info, TypeBuilder typBuilder) { // generates the names T0, T1, T2 ... String[] parameterNames = Enumerable.Range(0, info.PropertyNames.Count).Select(i => "T" + i.ToString()).ToArray(); var parameterBuilders = typBuilder.DefineGenericParameters(parameterNames); return(parameterBuilders); }
public static Func <IQueryable, IQueryable> BuildSelectFunc(Type elementType, List <String> selectClauses) { var propSigs = selectClauses.Select(sc => new PropertySignature(elementType, sc)).ToList(); var dti = DynamicTypeInfo.FindOrCreate(propSigs.Select(ps => ps.Name), propSigs.Select(ps => ps.ReturnType)); var lambdaExpr = CreateNewLambda(dti, propSigs); var method = TypeFns.GetMethodByExample((IQueryable <String> q) => q.Select(s => s.Length), elementType, dti.DynamicType); var func = BuildIQueryableFunc(elementType, method, lambdaExpr); return(func); }
/// <summary> /// Either finds a dynamic type that matches the specified anon or dynamic type or /// creates a new DynamicTypeInfo that does. /// </summary> /// <param name="anonOrDynType"></param> /// <returns></returns> public static DynamicTypeInfo FindOrCreate(Type anonOrDynType) { if (DynamicTypeInfo.IsDynamicType(anonOrDynType)) { return(FindByDynamicTypeName(anonOrDynType.Name)); } else { return(null); } }
//// This method does not work for Silverlight. It executes but the call to Equals fails with a VerificationException at runtime //private static void BuildEqualsMethod(DynamicTypeInfo info, TypeBuilder typBuilder, List<FieldBuilder> fields) { // var methodBuilder = typBuilder.DefineMethod("Equals", // MethodAttributes.Public | MethodAttributes.ReuseSlot | // MethodAttributes.Virtual | MethodAttributes.HideBySig, // typeof(bool), new Type[] { typeof(object) }); // var generator = methodBuilder.GetILGenerator(); // LocalBuilder other = generator.DeclareLocal(typBuilder); // Label next = generator.DefineLabel(); // generator.Emit(OpCodes.Ldarg_1); // generator.Emit(OpCodes.Isinst, typBuilder); // generator.Emit(OpCodes.Stloc, other); // generator.Emit(OpCodes.Ldloc, other); // generator.Emit(OpCodes.Brtrue_S, next); // generator.Emit(OpCodes.Ldc_I4_0); // generator.Emit(OpCodes.Ret); // generator.MarkLabel(next); // var tuples = info.PropertyTypes.Zip(fields, (t, f) => Tuple.Create(t, f)); // foreach (var tuple in tuples) { // // can't use field.FieldType because it returns an unresolved generic type. // Type fieldType = tuple.Item1; // field.FieldType; // FieldBuilder field = tuple.Item2; // Type ct = typeof(EqualityComparer<>).MakeGenericType(fieldType); // next = generator.DefineLabel(); // generator.EmitCall(OpCodes.Call, ct.GetMethod("get_Default"), null); // generator.Emit(OpCodes.Ldarg_0); // generator.Emit(OpCodes.Ldfld, field); // generator.Emit(OpCodes.Ldloc, other); // generator.Emit(OpCodes.Ldfld, field); // generator.EmitCall(OpCodes.Callvirt, ct.GetMethod("Equals", new Type[] { fieldType, fieldType }), null); // generator.Emit(OpCodes.Brtrue_S, next); // generator.Emit(OpCodes.Ldc_I4_0); // generator.Emit(OpCodes.Ret); // generator.MarkLabel(next); // } // generator.Emit(OpCodes.Ldc_I4_1); // generator.Emit(OpCodes.Ret); //} //// This method does not work for Silverlight. It executes but the call to GetHashCode fails with a VerificationException at runtime //private static void BuildGetHashCodeMethod(DynamicTypeInfo info, TypeBuilder typBuilder, List<FieldBuilder> fields) { // var mb = typBuilder.DefineMethod("GetHashCode", // MethodAttributes.Public | MethodAttributes.ReuseSlot | // MethodAttributes.Virtual | MethodAttributes.HideBySig, // typeof(int), Type.EmptyTypes); // var generator = mb.GetILGenerator(); // generator.Emit(OpCodes.Ldc_I4_0); // var tuples = info.PropertyTypes.Zip(fields, (t, f) => Tuple.Create(t, f)); // foreach (var tuple in tuples) { // Type fieldType = tuple.Item1; // field.FieldType; // var field = tuple.Item2; // Type ct = typeof(EqualityComparer<>).MakeGenericType(fieldType); // generator.EmitCall(OpCodes.Call, ct.GetMethod("get_Default"), null); // generator.Emit(OpCodes.Ldarg_0); // generator.Emit(OpCodes.Ldfld, field); // generator.EmitCall(OpCodes.Callvirt, ct.GetMethod("GetHashCode", new Type[] { fieldType }), null); // generator.Emit(OpCodes.Xor); // } // generator.Emit(OpCodes.Ret); //} private static IEnumerable <FieldBuilder> BuildFields(DynamicTypeInfo info, TypeBuilder typBuilder, GenericTypeParameterBuilder[] parameterBuilders) { var propertyCount = info.PropertyNames.Count; for (int i = 0; i < propertyCount; i++) { yield return(typBuilder.DefineField("_" + info.PropertyNames[i], parameterBuilders[i], FieldAttributes.Private | FieldAttributes.InitOnly)); } }
private static LambdaExpression CreateNewLambda(DynamicTypeInfo dti, IEnumerable <PropertySignature> selectors) { var paramExpr = Expression.Parameter(selectors.First().InstanceType, "t"); // cannot create a NewExpression on a dynamic type becasue of EF restrictions // so we always create a MemberInitExpression with bindings ( i.e. a new Foo() { a=1, b=2 } instead of new Foo(1,2); var newExpr = Expression.New(dti.DynamicEmptyConstructor); var propertyExprs = selectors.Select(s => s.BuildMemberExpression(paramExpr)); var dynamicProperties = dti.DynamicType.GetProperties(); var bindings = dynamicProperties.Zip(propertyExprs, (prop, expr) => Expression.Bind(prop, expr)); var memberInitExpr = Expression.MemberInit(newExpr, bindings.Cast <MemberBinding>()); var newLambda = Expression.Lambda(memberInitExpr, paramExpr); return(newLambda); }
private static Assembly AssemblyResolveHandler(object pSender, ResolveEventArgs pArgs) { DynamicTypeInfo info = FindByAssemblyName(pArgs.Name); if (info == null) { // return Assembly.GetExecutingAssembly(); // will allow caller throw a standard unable to resolve exception return(null); } else { return(info.DynamicType.Assembly); } }
private static TypeBuilder BuildType(DynamicTypeInfo info, ModuleBuilder modBuilder) { // Build the type var typBuilder = modBuilder.DefineType(info.DynamicTypeName, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.AutoLayout, // typeof(Object)); typeof(DynamicTypeBase)); return(typBuilder); }
private static ModuleBuilder BuildModule(DynamicTypeInfo info, AssemblyBuilder asmBuilder) { // Build the module ModuleBuilder modBuilder; if (info.DynamicTypeShouldSave) { modBuilder = asmBuilder.DefineDynamicModule("DynamicAnonTypeModule_" + info.TypeName, asmBuilder.GetName().Name + ".dll"); } else { modBuilder = asmBuilder.DefineDynamicModule("DynamicAnonTypeModule_" + info.TypeName); } return(modBuilder); }
private static void AddToMap(DynamicTypeInfo info) { if (info._isInMap) { return; } lock (__lock) { TypeInfoMap[info.OriginalType] = info; TypeInfoNameMap[info.DynamicTypeName] = info; if (info.DynamicType == info.OriginalType) { TypeShapeMap[new TypeShape(info)] = info; } info._isInMap = true; } }
private static void BuildEmptyCtor(DynamicTypeInfo info, TypeBuilder typBuilder) { var ctorBuilder = typBuilder.DefineConstructor( MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard, new Type[0]); var generator = ctorBuilder.GetILGenerator(); generator.Emit(OpCodes.Ldarg_0); var baseCtorInfo = typeof(Object).GetConstructor(new Type[0]); generator.Emit(OpCodes.Call, baseCtorInfo); generator.Emit(OpCodes.Ret); }
private static void BuildCtor(DynamicTypeInfo info, TypeBuilder typBuilder, List <FieldBuilder> fieldBuilders, GenericTypeParameterBuilder[] parameterBuilders) { Type[] ctorParams = parameterBuilders; var ctorBuilder = typBuilder.DefineConstructor( MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard, ctorParams); ILGenerator ctorIL = ctorBuilder.GetILGenerator(); ctorIL.Emit(OpCodes.Ldarg_0); // var baseCtorInfo = typeof(Object).GetConstructor(new Type[0]); var baseCtorInfo = typeof(DynamicTypeBase).GetConstructor(new Type[0]); ctorIL.Emit(OpCodes.Call, baseCtorInfo); for (byte i = 0; i < info.PropertyNames.Count; i++) { ctorIL.Emit(OpCodes.Ldarg_0); if (i == 0) { ctorIL.Emit(OpCodes.Ldarg_1); } else if (i == 1) { ctorIL.Emit(OpCodes.Ldarg_2); } else if (i == 2) { ctorIL.Emit(OpCodes.Ldarg_3); } else { ctorIL.Emit(OpCodes.Ldarg_S, i + 1); } ctorIL.Emit(OpCodes.Stfld, fieldBuilders[i]); } //Get the base constructor ctorIL.Emit(OpCodes.Ret); }
/// <summary> /// Constructs a new dynamic entity type from the specified DynamicTypeInfo. /// </summary> /// <param name="info">An DynamicTypeInfo instance</param> /// <returns></returns> /// <exception cref="ArgumentException">Thrown if the dynamic type key name is already defined.</exception> public static Type CreateType(DynamicTypeInfo info) { if (info == null) { throw new ArgumentNullException("info"); } AssemblyBuilder asmBuilder = BuildAssembly(info); ModuleBuilder modBuilder = BuildModule(info, asmBuilder); TypeBuilder typBuilder = BuildType(info, modBuilder); GenericTypeParameterBuilder[] parameterBuilders = BuildGenericParameters(info, typBuilder); // Build the fields var fieldBuilders = BuildFields(info, typBuilder, parameterBuilders).ToList(); // Build an empty (parameterless) ctor BuildEmptyCtor(info, typBuilder); // Build a ctor that includes all properties. BuildCtor(info, typBuilder, fieldBuilders, parameterBuilders); // Build Properties BuildProperties(info, typBuilder, fieldBuilders, parameterBuilders); // BuildEqualsMethod(info, typBuilder, fieldBuilders); // BuildGetHashCodeMethod(info, typBuilder, fieldBuilders); var openGenericType = typBuilder.CreateType(); var returnType = openGenericType.MakeGenericType(info.PropertyTypes.ToArray()); //OnDynamicEntityTypeCreated(new DynamicEntityTypeCreatedEventArgs(returnType)); if (info.DynamicTypeShouldSave) { #if !SILVERLIGHT asmBuilder.Save(asmBuilder.GetName().Name + ".dll"); #endif } return(returnType); }
/// <summary> /// Constructs a new dynamic entity type from the specified DynamicTypeInfo. /// </summary> /// <param name="info">An DynamicTypeInfo instance</param> /// <returns></returns> /// <exception cref="ArgumentException">Thrown if the dynamic type key name is already defined.</exception> public static Type CreateType(DynamicTypeInfo info) { if (info == null) { throw new ArgumentNullException("info"); } AssemblyBuilder asmBuilder = BuildAssembly(info); ModuleBuilder modBuilder = BuildModule(info, asmBuilder); TypeBuilder typBuilder = BuildType(info, modBuilder); GenericTypeParameterBuilder[] parameterBuilders = BuildGenericParameters(info, typBuilder); // Build the fields var fieldBuilders = BuildFields(info, typBuilder, parameterBuilders).ToList(); // Build an empty (parameterless) ctor BuildEmptyCtor(info, typBuilder); // Build a ctor that includes all properties. BuildCtor(info, typBuilder, fieldBuilders, parameterBuilders); // Build Properties BuildProperties(info, typBuilder, fieldBuilders, parameterBuilders); // BuildEqualsMethod(info, typBuilder, fieldBuilders); // BuildGetHashCodeMethod(info, typBuilder, fieldBuilders); var openGenericType = typBuilder.CreateType(); var returnType = openGenericType.MakeGenericType(info.PropertyTypes.ToArray()); //OnDynamicEntityTypeCreated(new DynamicEntityTypeCreatedEventArgs(returnType)); if (info.DynamicTypeShouldSave) { #if !SILVERLIGHT asmBuilder.Save(asmBuilder.GetName().Name + ".dll"); #endif } return returnType; }
private static TypeBuilder BuildType(DynamicTypeInfo info, ModuleBuilder modBuilder) { // Build the type var typBuilder = modBuilder.DefineType(info.DynamicTypeName, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.AutoLayout, // typeof(Object)); typeof(DynamicTypeBase)); return typBuilder; }
///// <summary> ///// Converts a anon type to a dynamic type and returns non-anon types unchanged. If the same anon type is converted more than once the same dynamic type will be returned. ///// </summary> ///// <param name="t"></param> ///// <returns></returns> //public static Type ConvertType(Type t) { // if (!AnonymousFns.IsAnonymousType(t)) return t; // var dti = DynamicTypeInfo.FindOrCreate(t); // return dti.DynamicType; //} /// <summary> /// Return the DynamicTypeInfo for the specified assembly name containing a dynamic type. /// </summary> /// <param name="pAssemblyName"></param> /// <returns></returns> public static DynamicTypeInfo FindByAssemblyName(String pAssemblyName) { String dynamicTypeName = ConvertDynamicAssemblyNameToDynamicTypeName(pAssemblyName); return(DynamicTypeInfo.FindByDynamicTypeName(dynamicTypeName)); }
//// This method does not work for Silverlight. It executes but the call to Equals fails with a VerificationException at runtime //private static void BuildEqualsMethod(DynamicTypeInfo info, TypeBuilder typBuilder, List<FieldBuilder> fields) { // var methodBuilder = typBuilder.DefineMethod("Equals", // MethodAttributes.Public | MethodAttributes.ReuseSlot | // MethodAttributes.Virtual | MethodAttributes.HideBySig, // typeof(bool), new Type[] { typeof(object) }); // var generator = methodBuilder.GetILGenerator(); // LocalBuilder other = generator.DeclareLocal(typBuilder); // Label next = generator.DefineLabel(); // generator.Emit(OpCodes.Ldarg_1); // generator.Emit(OpCodes.Isinst, typBuilder); // generator.Emit(OpCodes.Stloc, other); // generator.Emit(OpCodes.Ldloc, other); // generator.Emit(OpCodes.Brtrue_S, next); // generator.Emit(OpCodes.Ldc_I4_0); // generator.Emit(OpCodes.Ret); // generator.MarkLabel(next); // var tuples = info.PropertyTypes.Zip(fields, (t, f) => Tuple.Create(t, f)); // foreach (var tuple in tuples) { // // can't use field.FieldType because it returns an unresolved generic type. // Type fieldType = tuple.Item1; // field.FieldType; // FieldBuilder field = tuple.Item2; // Type ct = typeof(EqualityComparer<>).MakeGenericType(fieldType); // next = generator.DefineLabel(); // generator.EmitCall(OpCodes.Call, ct.GetMethod("get_Default"), null); // generator.Emit(OpCodes.Ldarg_0); // generator.Emit(OpCodes.Ldfld, field); // generator.Emit(OpCodes.Ldloc, other); // generator.Emit(OpCodes.Ldfld, field); // generator.EmitCall(OpCodes.Callvirt, ct.GetMethod("Equals", new Type[] { fieldType, fieldType }), null); // generator.Emit(OpCodes.Brtrue_S, next); // generator.Emit(OpCodes.Ldc_I4_0); // generator.Emit(OpCodes.Ret); // generator.MarkLabel(next); // } // generator.Emit(OpCodes.Ldc_I4_1); // generator.Emit(OpCodes.Ret); //} //// This method does not work for Silverlight. It executes but the call to GetHashCode fails with a VerificationException at runtime //private static void BuildGetHashCodeMethod(DynamicTypeInfo info, TypeBuilder typBuilder, List<FieldBuilder> fields) { // var mb = typBuilder.DefineMethod("GetHashCode", // MethodAttributes.Public | MethodAttributes.ReuseSlot | // MethodAttributes.Virtual | MethodAttributes.HideBySig, // typeof(int), Type.EmptyTypes); // var generator = mb.GetILGenerator(); // generator.Emit(OpCodes.Ldc_I4_0); // var tuples = info.PropertyTypes.Zip(fields, (t, f) => Tuple.Create(t, f)); // foreach (var tuple in tuples) { // Type fieldType = tuple.Item1; // field.FieldType; // var field = tuple.Item2; // Type ct = typeof(EqualityComparer<>).MakeGenericType(fieldType); // generator.EmitCall(OpCodes.Call, ct.GetMethod("get_Default"), null); // generator.Emit(OpCodes.Ldarg_0); // generator.Emit(OpCodes.Ldfld, field); // generator.EmitCall(OpCodes.Callvirt, ct.GetMethod("GetHashCode", new Type[] { fieldType }), null); // generator.Emit(OpCodes.Xor); // } // generator.Emit(OpCodes.Ret); //} private static IEnumerable<FieldBuilder> BuildFields(DynamicTypeInfo info, TypeBuilder typBuilder, GenericTypeParameterBuilder[] parameterBuilders) { var propertyCount = info.PropertyNames.Count; for (int i = 0; i < propertyCount; i++) { yield return typBuilder.DefineField("_" + info.PropertyNames[i], parameterBuilders[i], FieldAttributes.Private | FieldAttributes.InitOnly); } }
private static void BuildProperties(DynamicTypeInfo info, TypeBuilder typBuilder, List<FieldBuilder> fieldBuilders, GenericTypeParameterBuilder[] parameterBuilders) { for (int i = 0; i < info.PropertyNames.Count; i++) { //var propBuilder = typBuilder.DefineProperty( // info.PropertyNames[i], PropertyAttributes.None, parameterBuilders[i], Type.EmptyTypes); var propBuilder = typBuilder.DefineProperty( info.PropertyNames[i], PropertyAttributes.HasDefault, parameterBuilders[i], Type.EmptyTypes); // Build Get prop var getMethBuilder = typBuilder.DefineMethod( "get_" + info.PropertyNames[i], MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, parameterBuilders[i], Type.EmptyTypes); var generator = getMethBuilder.GetILGenerator(); generator.Emit(OpCodes.Ldarg_0); // load 'this' generator.Emit(OpCodes.Ldfld, fieldBuilders[i]); // load the field generator.Emit(OpCodes.Ret); propBuilder.SetGetMethod(getMethBuilder); // Build Set prop var setMethBuilder = typBuilder.DefineMethod( "set_" + info.PropertyNames[i], MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, typeof(void), new Type[] { fieldBuilders[i].FieldType }); generator = setMethBuilder.GetILGenerator(); generator.Emit(OpCodes.Ldarg_0); // load 'this' generator.Emit(OpCodes.Ldarg_1); // load value generator.Emit(OpCodes.Stfld, fieldBuilders[i]); generator.Emit(OpCodes.Ret); propBuilder.SetSetMethod(setMethBuilder); } }
private static void BuildCtor(DynamicTypeInfo info, TypeBuilder typBuilder, List<FieldBuilder> fieldBuilders, GenericTypeParameterBuilder[] parameterBuilders) { Type[] ctorParams = parameterBuilders; var ctorBuilder = typBuilder.DefineConstructor( MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard, ctorParams); ILGenerator ctorIL = ctorBuilder.GetILGenerator(); ctorIL.Emit(OpCodes.Ldarg_0); // var baseCtorInfo = typeof(Object).GetConstructor(new Type[0]); var baseCtorInfo = typeof(DynamicTypeBase).GetConstructor(new Type[0]); ctorIL.Emit(OpCodes.Call, baseCtorInfo); for (byte i = 0; i < info.PropertyNames.Count; i++) { ctorIL.Emit(OpCodes.Ldarg_0); if (i == 0) { ctorIL.Emit(OpCodes.Ldarg_1); } else if (i == 1) { ctorIL.Emit(OpCodes.Ldarg_2); } else if (i == 2) { ctorIL.Emit(OpCodes.Ldarg_3); } else { ctorIL.Emit(OpCodes.Ldarg_S, i + 1); } ctorIL.Emit(OpCodes.Stfld, fieldBuilders[i]); } //Get the base constructor ctorIL.Emit(OpCodes.Ret); }
public TypeShape(DynamicTypeInfo dti) { PropertyNames = dti._propertyNames; PropertyTypes = dti._propertyTypes; }
private static ModuleBuilder BuildModule(DynamicTypeInfo info, AssemblyBuilder asmBuilder) { // Build the module ModuleBuilder modBuilder; #if !SILVERLIGHT if (info.DynamicTypeShouldSave) { modBuilder = asmBuilder.DefineDynamicModule("DynamicAnonTypeModule_" + info.TypeName, asmBuilder.GetName().Name + ".dll"); } else { modBuilder = asmBuilder.DefineDynamicModule("DynamicAnonTypeModule_" + info.TypeName); } #else modBuilder = asmBuilder.DefineDynamicModule("DynamicAnonTypeModule_" + info.TypeName); #endif return modBuilder; }
private static void AddToMap(DynamicTypeInfo info) { if (info._isInMap) return; lock (__lock) { TypeInfoMap[info.OriginalType] = info; TypeInfoNameMap[info.DynamicTypeName] = info; if (info.DynamicType == info.OriginalType) { TypeShapeMap[new TypeShape(info)] = info; } info._isInMap = true; } }
private static AssemblyBuilder BuildAssembly(DynamicTypeInfo info) { AppDomain aDomain = Thread.GetDomain(); // Build the assembly AssemblyName asmName = new AssemblyName(); asmName.Name = info.DynamicTypeName + DynamicTypeInfo.DynamicAssemblyNameSuffix; AssemblyBuilder asmBuilder; #if !SILVERLIGHT if (info.DynamicTypeShouldSave) { if (String.IsNullOrEmpty(info.DynamicTypeFileDirectory)) { asmBuilder = aDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave); } else { asmBuilder = aDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave, info.DynamicTypeFileDirectory); } } else { asmBuilder = aDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Run); } #else asmBuilder = aDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Run); #endif return asmBuilder; }
private static GenericTypeParameterBuilder[] BuildGenericParameters(DynamicTypeInfo info, TypeBuilder typBuilder) { // generates the names T0, T1, T2 ... String[] parameterNames = Enumerable.Range(0, info.PropertyNames.Count).Select(i => "T" + i.ToString()).ToArray(); var parameterBuilders = typBuilder.DefineGenericParameters(parameterNames); return parameterBuilders; }