internal static TypeBuilder CreateType(IEdmStructuredType targetType, ModuleBuilder moduleBuilder, string moduleName)
{
if (_typeBuildersDict.ContainsKey(moduleName))
{
Type myTypeInfo = _typeBuildersDict[moduleName].Builder.AsType();
return((TypeBuilder)myTypeInfo);
}
if (targetType.BaseType != null)
{
TypeBuilder previouslyBuiltType = null;
if (!_typeBuildersDict.ContainsKey(moduleName))
{
previouslyBuiltType = CreateType(targetType.BaseType, moduleBuilder, targetType.BaseType.FullTypeName());
}
var typeBuilder = moduleBuilder.DefineType(moduleName, TypeAttributes.Class | TypeAttributes.Public, previouslyBuiltType);
// Add [ComplexType] attribute to complex types
if (targetType.TypeKind == EdmTypeKind.Complex)
{
var complexAttrBuilder = new CustomAttributeBuilder(typeof(ComplexTypeAttribute).GetConstructor(Type.EmptyTypes), Array.Empty <object>());
typeBuilder.SetCustomAttribute(complexAttrBuilder);
var ownedAttrBuilder = new CustomAttributeBuilder(typeof(OwnedAttribute).GetConstructor(Type.EmptyTypes), Array.Empty <object>());
typeBuilder.SetCustomAttribute(ownedAttrBuilder);
}
var typeBuilderInfo = new TypeBuilderInfo()
{
Builder = typeBuilder.GetTypeInfo(), IsDerived = true
};
_typeBuildersDict.Add(moduleName, typeBuilderInfo);
_builderQueue.Enqueue(typeBuilderInfo);
return(typeBuilder);
}
else
{
var typeBuilder = moduleBuilder.DefineType(moduleName, TypeAttributes.Class | TypeAttributes.Public);
// Add [ComplexType] attribute to complex types
if (targetType.TypeKind == EdmTypeKind.Complex)
{
var complexAttrBuilder = new CustomAttributeBuilder(typeof(ComplexTypeAttribute).GetConstructor(Type.EmptyTypes), Array.Empty <object>());
typeBuilder.SetCustomAttribute(complexAttrBuilder);
var ownedAttrBuilder = new CustomAttributeBuilder(typeof(OwnedAttribute).GetConstructor(Type.EmptyTypes), Array.Empty <object>());
typeBuilder.SetCustomAttribute(ownedAttrBuilder);
}
var builderInfo = new TypeBuilderInfo()
{
Builder = typeBuilder.GetTypeInfo(), IsDerived = false
};
_typeBuildersDict.Add(moduleName, builderInfo);
_builderQueue.Enqueue(builderInfo);
return(typeBuilder);
}
}
internal static EnumBuilder CreateType(IEdmEnumType targetType, ModuleBuilder moduleBuilder, string moduleName)
{
if (_typeBuildersDict.ContainsKey(moduleName))
{
return((EnumBuilder)(object)_typeBuildersDict[moduleName].Builder.AsType());
}
EnumBuilder typeBuilder = moduleBuilder.DefineEnum(moduleName, TypeAttributes.Public, typeof(int));
var builderInfo = new TypeBuilderInfo()
{
Builder = typeBuilder.GetTypeInfo(), IsDerived = false
};
_typeBuildersDict.Add(moduleName, builderInfo);
_builderQueue.Enqueue(builderInfo);
return(typeBuilder);
}
internal static TypeBuilder CreateType(IEdmStructuredType targetType, ModuleBuilder moduleBuilder, string moduleName)
{
if (_typeBuildersDict.ContainsKey(moduleName))
{
return((TypeBuilder)_typeBuildersDict[moduleName].Builder);
}
if (targetType.BaseType != null)
{
TypeBuilder previouslyBuiltType = null;
if (!_typeBuildersDict.ContainsKey(moduleName))
{
previouslyBuiltType = CreateType(targetType.BaseType, moduleBuilder, targetType.BaseType.FullTypeName());
}
var typeBuilder = moduleBuilder.DefineType(moduleName, TypeAttributes.Class | TypeAttributes.Public, previouslyBuiltType);
var typeBuilderInfo = new TypeBuilderInfo()
{
Builder = typeBuilder, IsDerived = true
};
_typeBuildersDict.Add(moduleName, typeBuilderInfo);
_builderQueue.Enqueue(typeBuilderInfo);
return(typeBuilder);
}
else
{
var typeBuilder = moduleBuilder.DefineType(moduleName, TypeAttributes.Class | TypeAttributes.Public);
var builderInfo = new TypeBuilderInfo()
{
Builder = typeBuilder, IsDerived = false
};
_typeBuildersDict.Add(moduleName, builderInfo);
_builderQueue.Enqueue(builderInfo);
return(typeBuilder);
}
}
public static void BuildModules(IEdmModel model, ModuleBuilder moduleBuilder, string dbContextName)
{
//first create the basic types for the enums
foreach (var modelSchemaElement in model.SchemaElements)
{
var declaredType = model.FindDeclaredType(modelSchemaElement.FullName());
if (declaredType == null)
{
continue;
}
if (declaredType is IEdmEnumType)
{
CreateType((IEdmEnumType)declaredType, moduleBuilder, declaredType.FullName());
}
}
//next create the basic types for the types
foreach (var modelSchemaElement in model.SchemaElements)
{
var declaredType = model.FindDeclaredType(modelSchemaElement.FullName());
if (declaredType == null)
{
continue;
}
if (!(declaredType is IEdmEnumType))
{
CreateType((IEdmStructuredType)declaredType, moduleBuilder, declaredType.FullName());
}
else
{
Compile((IEdmEnumType)declaredType, moduleBuilder, declaredType.FullName());
}
}
//go through and add all elements and their properties but not nav properties
foreach (var modelSchemaElement in model.SchemaElements)
{
var one = model.FindDeclaredType(modelSchemaElement.FullName());
if (one != null && !(modelSchemaElement is IEdmEnumType))
{
Compile((IEdmStructuredType)one, moduleBuilder, one.FullName());
}
}
//finally add the nav properties
foreach (var modelSchemaElement in model.SchemaElements)
{
if ((modelSchemaElement is IEdmEnumType))
{
continue;
}
var one = model.FindDeclaredType(modelSchemaElement.FullName());
if (one != null)
{
Compile((IEdmStructuredType)one, moduleBuilder, one.FullName(), true);
}
}
//now go through the queue and create the types in dependency order
while (_builderQueue.Count != 0)
{
var typeBuilder = _builderQueue.Dequeue();
if ((object)typeBuilder.Builder is TypeBuilder)
{
((TypeBuilder)(object)typeBuilder.Builder).CreateTypeInfo();
}
if ((object)typeBuilder.Builder is EnumBuilder)
{
((EnumBuilder)(object)typeBuilder.Builder).CreateTypeInfo();
}
}
//generate the DbContext type
// TODO: this created an EfCore DbContext
//var entitiesBuilder = moduleBuilder.DefineType(dbContextName, TypeAttributes.Class | TypeAttributes.Public, typeof(DbContext));
//var dbContextType = typeof(DbContext);
////entitiesBuilder.CreateDefaultConstructor(dbContextType, $"name={dbContextName}");
////entitiesBuilder.CreateConnectionStringConstructor(dbContextType);
//entitiesBuilder.CreateContextOptionsConstructor(dbContextType);
var entitiesBuilder = moduleBuilder.DefineType(dbContextName, TypeAttributes.Class | TypeAttributes.Public, typeof(ListDataStore));
var dbContextType = typeof(ListDataStore);
foreach (var entitySet in model.EntityContainer.EntitySets())
{
TypeBuilderInfo entityType = _typeBuildersDict.FirstOrDefault(t => t.Key == entitySet.EntityType().FullName()).Value;
if (entityType != null)
{
//Type listOf = typeof(DbSet<>);
Type listOf = typeof(ListDataSet <>);
Type selfContained = listOf.MakeGenericType(entityType.Builder);
PropertyBuilderHelper.BuildProperty(entitiesBuilder, entitySet.Name, selfContained);
}
}
// // create the OnModelCreating method
// MethodBuilder methodbuilder = entitiesBuilder.DefineMethod("OnModelCreating", MethodAttributes.Public
// | MethodAttributes.HideBySig
// | MethodAttributes.CheckAccessOnOverride
// | MethodAttributes.Virtual,
// typeof(void), new Type[] { typeof(DbModelBuilder) });
// // generate the IL for the OnModelCreating method
// ILGenerator ilGenerator = methodbuilder.GetILGenerator();
////todo: insert code
// ilGenerator.Emit(OpCodes.Ret);
entitiesBuilder.CreateType();
}
