public CodeContextEntityWraperMember(WXMLCodeDomGeneratorSettings settings, EntityDefinition entity)
{
_settings = settings;
m_entity = entity;
string entityName = entity.Name;
if (entityName.EndsWith("s"))
{
entityName += "es";
}
else if (entityName.EndsWith("y"))
{
entityName += "ies";
}
else
{
entityName += "s";
}
Attributes = MemberAttributes.Public | MemberAttributes.Final;
Name = (entity.EntitySpecificNamespace ?? string.Empty) + entityName;
var entityTypeReference = new CodeTypeReference(new WXMLCodeDomGeneratorNameHelper(_settings).GetEntityClassName(Entity, true));
Type = new CodeTypeReference("Worm.Linq.QueryWrapperT", entityTypeReference);
SetStatements.Clear();
GetStatements.Add(
new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeThisReferenceExpression(), "CreateQueryWrapper", entityTypeReference)
)
)
);
}
public CodeEntityTypeDeclaration(WXMLCodeDomGeneratorSettings settings, EntityDefinition entity, WormCodeDomGenerator gen)
: this(settings, gen)
{
Entity = entity;
m_typeReference.BaseType = FullName;
entity.Items["TypeDeclaration"] = this;
}
public CodePropertiesAccessorTypeDeclaration(WXMLCodeDomGeneratorSettings settings, EntityDefinition entity, PropertyGroup group)
{
Entity = entity;
Group = group;
IsClass = true;
Name = group.Name + "Accessor";
PopulateMembers += OnPopulateMemebers;
_settings = settings;
}
public CodeEntityTypeDeclaration(WXMLCodeDomGeneratorSettings settings, WormCodeDomGenerator gen)
{
m_typeReference = new CodeTypeReference();
m_propertiesAccessor = new Dictionary <string, CodePropertiesAccessorTypeDeclaration>();
PopulateMembers += OnPopulateMembers;
//_useType = useType;
_settings = settings;
_gen = gen;
}
public Enumer(WXMLModel model, string ext)
{
_model = model;
//Create the CodeCompileUnit from the passed-in XML file
WXMLCodeDomGeneratorSettings settings = new WXMLCodeDomGeneratorSettings();
settings.EntitySchemaDefClassNameSuffix = "SchemaDef";
LinqToCodedom.CodeDomGenerator.Language language;
switch (ext)
{
case ".cs":
settings.LanguageSpecificHacks = LanguageSpecificHacks.CSharp;
language = LinqToCodedom.CodeDomGenerator.Language.CSharp;
break;
case ".vb":
settings.LanguageSpecificHacks = LanguageSpecificHacks.VisualBasic;
language = LinqToCodedom.CodeDomGenerator.Language.VB;
break;
default:
throw new NotSupportedException(ext);
//case ".js":
// settings.LanguageSpecificHacks = LanguageSpecificHacks.VisualBasic;
// break;
}
settings.PrivateMembersPrefix = "m_";
//settings.Split = false;
//ormObjectsDef.GenerateSchemaOnly
WormCodeDomGenerator generator = new WormCodeDomGenerator(model, settings);
if (model.GenerateSingleFile)
{
CodeCompileFileUnit compileUnit = generator.GetFullSingleUnit(language);
_units = new List <Pair>()
{
new Pair()
{
Unit = compileUnit
}
};
}
else
{
_units = new List <Pair>();
foreach (var entity in model.GetActiveEntities())
{
_units.Add(new Pair()
{
Unit = generator.GetEntityCompileUnits(entity.Identifier, language)[0]
});
}
}
}
public CodeEntityInterfaceDeclaration(WXMLCodeDomGeneratorSettings settings, CodeEntityTypeDeclaration entityTypeDeclaration, string prefix, string suffix)
: this(settings)
{
NamePrefix = prefix;
NameSuffix = suffix;
EntityTypeDeclaration = entityTypeDeclaration;
m_typeReference.BaseType = FullName;
}
public string GetTypeName(WXMLCodeDomGeneratorSettings settings)
{
if (IsClrType)
{
return(_clrType.FullName);
}
if (IsUserType)
{
return(_userType);
}
return(new WXMLCodeDomGeneratorNameHelper(settings).GetEntityClassName(_entity, true));
}
public CodeLinqContextDeclaration(WXMLCodeDomGeneratorSettings settings, LinqSettingsDescriptor linqSettings)
{
_settings = settings;
PopulateMembers += OnPopulateMembers;
PopulateBaseTypes += OnPopulateBaseTypes;
LinqSettings = linqSettings;
if (ContextClassBehaviour == ContextClassBehaviourType.PartialClass || ContextClassBehaviour == ContextClassBehaviourType.BasePartialClass)
{
IsPartial = true;
}
Name = !String.IsNullOrEmpty(LinqSettings.ContextName) ? LinqSettings.ContextName : "LinqContext";
}
public static void TestCSCodeInternal(Stream stream, WXMLCodeDomGeneratorSettings settings)
{
CodeDomProvider prov = new Microsoft.CSharp.CSharpCodeProvider();
settings.LanguageSpecificHacks = LanguageSpecificHacks.CSharp;
//settings.RemoveOldM2M = true;
//settings.Split = false;
CompileCode(prov, settings, XmlReader.Create(stream));
//stream.Position = 0;
//settings.Split = true;
//CompileCode(prov, settings, XmlReader.Create(stream));
}
public CodeEntityInterfaceDeclaration(WXMLCodeDomGeneratorSettings settings)
{
m_typeReference = new CodeTypeReference();
IsClass = false;
IsPartial = false;
IsInterface = true;
_settings = settings;
if ((settings.LanguageSpecificHacks & LanguageSpecificHacks.AllowPartialInterfaces) == LanguageSpecificHacks.AllowPartialInterfaces)
{
IsPartial = true;
}
}
public Assembly TestVBCodeInternal(WXMLModel model, WXMLCodeDomGeneratorSettings settings,
params CodeCompileUnit[] units)
{
//var providerOptions = new Dictionary<string, string> { { "CompilerVersion", "v3.5" } };
//var providerOptions = new Dictionary<string, string> { { "CompilerVersion", "v4.0" } };
CodeDomProvider prov = new Microsoft.VisualBasic.VBCodeProvider();
settings.LanguageSpecificHacks = LanguageSpecificHacks.VisualBasic;
//settings.RemoveOldM2M = true;
//settings.Split = false;
return(CompileCode(prov, true, settings, model, units));
//stream.Position = 0;
//settings.Split = true;
//CompileCode(prov, settings, XmlReader.Create(stream));
}
public CodeTypeReference ToCodeType(WXMLCodeDomGeneratorSettings settings)
{
if (_tr != null)
{
return(_tr);
}
TypeDefinition propertyTypeDesc = this;
var t = new CodeTypeReference(propertyTypeDesc.IsEntityType
? new WXMLCodeDomGeneratorNameHelper(settings).GetEntityClassName(propertyTypeDesc.Entity, true)
: propertyTypeDesc.GetTypeName(settings));
//if (IsUserType && (UserTypeHint & UserTypeHintFlags.Interface) == UserTypeHintFlags.Interface)
// t.Is
return(t);
}
private static Assembly CompileCode(CodeDomProvider prov, bool v35, WXMLCodeDomGeneratorSettings settings,
WXMLModel model, params CodeCompileUnit[] units)
{
WormCodeDomGenerator gen = new WormCodeDomGenerator(model, settings);
CompilerResults result;
CompilerParameters prms = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true,
IncludeDebugInformation = false,
TreatWarningsAsErrors = false/*,
* OutputAssembly = "testAssembly.dll"*/
};
prms.ReferencedAssemblies.Add("System.dll");
prms.ReferencedAssemblies.Add("System.Data.dll");
prms.ReferencedAssemblies.Add("System.XML.dll");
if (v35)
{
prms.ReferencedAssemblies.Add("System.Core.dll");
}
if ((settings.GenerateMode.HasValue ? settings.GenerateMode.Value : model.GenerateMode) != GenerateModeEnum.EntityOnly)
{
//prms.ReferencedAssemblies.Add("CoreFramework.dll");
prms.ReferencedAssemblies.Add("Worm.Orm.dll");
if (model.LinqSettings != null && model.LinqSettings.Enable)
{
prms.ReferencedAssemblies.Add("Worm.Linq.dll");
}
}
prms.TempFiles.KeepFiles = true;
CodeCompileUnit singleUnit = new CodeCompileUnit();
if (settings.SingleFile.HasValue ? settings.SingleFile.Value : model.GenerateSingleFile)
{
singleUnit = gen.GetFullSingleUnit(typeof(Microsoft.VisualBasic.VBCodeProvider).IsAssignableFrom(prov.GetType()) ? LinqToCodedom.CodeDomGenerator.Language.VB : LinqToCodedom.CodeDomGenerator.Language.CSharp);
singleUnit.Namespaces.Add(new CodeNamespace("System"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Data"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Data.Linq"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Linq"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Linq.Expressions"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Collections.Generic"));
var l = new List <CodeCompileUnit>();
l.Add(singleUnit);
if (units != null)
{
l.AddRange(units);
foreach (var item in units)
{
singleUnit.Namespaces.AddRange(item.Namespaces);
}
}
result = prov.CompileAssemblyFromDom(prms, l.ToArray());
}
else
{
Dictionary <string, CodeCompileFileUnit> dic =
gen.GetCompileUnits(typeof(Microsoft.VisualBasic.VBCodeProvider).IsAssignableFrom(prov.GetType()) ? LinqToCodedom.CodeDomGenerator.Language.VB : LinqToCodedom.CodeDomGenerator.Language.CSharp);
foreach (CodeCompileFileUnit unit in dic.Values)
{
singleUnit.Namespaces.AddRange(unit.Namespaces);
}
var l = new List <CodeCompileUnit>(dic.Values.OfType <CodeCompileUnit>());
if (units != null)
{
l.AddRange(units);
foreach (var item in units)
{
singleUnit.Namespaces.AddRange(item.Namespaces);
}
}
singleUnit.Namespaces.Add(new CodeNamespace("System"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Data"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Data.Linq"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Linq"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Linq.Expressions"));
singleUnit.Namespaces.Add(new CodeNamespace("System.Collections.Generic"));
result = prov.CompileAssemblyFromDom(prms, l.ToArray());
}
prov.GenerateCodeFromCompileUnit(singleUnit, Console.Out, new CodeGeneratorOptions());
if (result.Errors.HasErrors)
{
StringBuilder sb = new StringBuilder();
foreach (CompilerError str in result.Errors)
{
sb.AppendLine(str.ToString());
}
Assert.Fail(sb.ToString());
}
return(result.CompiledAssembly);
}
private static void CompileCode(CodeDomProvider prov, WXMLCodeDomGeneratorSettings settings,
XmlReader reader)
{
CompileCode(prov, true, settings, WXMLModel.LoadFromXml(reader, new TestXmlUrlResolver()));
}
static void Main(string[] args)
{
Console.WriteLine("Worm code generator utility.");
Console.WriteLine();
CommandLine.Utility.Arguments cmdLine = new CommandLine.Utility.Arguments(args);
string outputLanguage;
string outputFolder;
WXMLModel model;
string inputFilename;
CodeDomProvider codeDomProvider;
bool split, separateFolder;
string[] skipEntities;
string[] processEntities;
WXMLCodeDomGeneratorSettings settings = new WXMLCodeDomGeneratorSettings();
if (cmdLine["?"] != null || cmdLine["h"] != null || cmdLine["help"] != null || args == null || args.Length == 0)
{
Console.WriteLine("Command line parameters:");
Console.WriteLine(" -f\t- source xml file");
Console.WriteLine(" -v\t- validate input file against schema only");
Console.WriteLine(" -t\t- test run (generate files in memory)");
Console.WriteLine(" -l\t- code language [cs, vb] (\"cs\" by default)");
//Console.WriteLine(" -p\t- generate partial classes (\"false\" by default)");
Console.WriteLine(" -sp\t- split entity class and entity's schema definition\n\t\t class code by diffrent files (\"false\" by default)");
Console.WriteLine(" -sk\t- skip entities");
Console.WriteLine(" -e\t- entities to process");
//Console.WriteLine(" -cB\t- behaviour of class codegenerator\n\t\t [Objects, PartialObjects] (\"Objects\" by default)");
Console.WriteLine(" -sF\t- create folder for each entity.");
Console.WriteLine(" -o\t- output files folder.");
Console.WriteLine(" -pmp\t- private members prefix (\"_\" by default)");
Console.WriteLine(" -cnP\t- class name prefix (null by default)");
Console.WriteLine(" -cnS\t- class name suffix (null by default)");
Console.WriteLine(" -fnP\t- file name prefix (null by default)");
Console.WriteLine(" -fnS\t- file name suffix (null by default)");
Console.WriteLine(" -propsT\t- use type instead of entity name in props (false by default)");
//Console.WriteLine(" -rm\t- remove old m2m methods (false by default)");
Console.WriteLine(" -of\t- generate one file (false by default)");
//Console.WriteLine(" -so\t- generate entity schema only (false by default)");
return;
}
if (cmdLine["f"] != null)
{
inputFilename = cmdLine["f"];
}
else
{
Console.WriteLine("Please give 'f' parameter");
return;
}
bool validateOnly = (cmdLine["v"] != null);
bool testRun = (cmdLine["t"] != null);
if (cmdLine["l"] != null)
{
outputLanguage = cmdLine["l"];
}
else
{
outputLanguage = "CS";
}
if (cmdLine["sF"] != null)
{
separateFolder = true;
}
else
{
separateFolder = false;
}
LanguageSpecificHacks languageHacks = LanguageSpecificHacks.None;
if (outputLanguage.ToUpper() == "VB")
{
codeDomProvider = new VBCodeProvider();
languageHacks = LanguageSpecificHacks.VisualBasic;
}
else if (outputLanguage.ToUpper() == "CS")
{
codeDomProvider = new CSharpCodeProvider();
languageHacks = LanguageSpecificHacks.CSharp;
}
else
{
Console.WriteLine("Error: incorrect value in \"l\" parameter.");
return;
}
if (cmdLine["sp"] != null)
{
split = true;
}
else
{
split = false;
}
if (cmdLine["o"] != null)
{
outputFolder = cmdLine["o"];
}
else
{
outputFolder = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
if (string.IsNullOrEmpty(outputFolder))
{
outputFolder = Path.GetPathRoot(System.Reflection.Assembly.GetExecutingAssembly().Location);
}
}
if (cmdLine["sk"] != null)
{
skipEntities = cmdLine["sk"].Split(',');
}
else
{
skipEntities = new string[] { }
};
if (cmdLine["e"] != null)
{
processEntities = cmdLine["e"].Split(',');
}
else
{
processEntities = new string[] { }
};
if (cmdLine["pmp"] != null)
{
settings.PrivateMembersPrefix = cmdLine["pmp"];
}
if (cmdLine["fnP"] != null)
{
settings.FileNamePrefix = cmdLine["fnP"];
}
if (cmdLine["fnS"] != null)
{
settings.FileNameSuffix = cmdLine["fnS"];
}
if (cmdLine["cnP"] != null)
{
settings.ClassNamePrefix = cmdLine["cnP"];
}
if (cmdLine["cnS"] != null)
{
settings.ClassNameSuffix = cmdLine["cnS"];
}
if (cmdLine["propsT"] != null)
{
settings.UseTypeInProps = true;
}
//if (cmdLine["rm"] != null)
//{
// settings.RemoveOldM2M = true;
//}
//if (cmdLine["os"] != null)
//{
// settings.OnlySchema = true;
//}
bool oneFile = false;
if (cmdLine["of"] != null)
{
oneFile = true;
}
if (!File.Exists(inputFilename))
{
Console.WriteLine("Error: source file {0} not found.", inputFilename);
return;
}
//if (!System.IO.Directory.Exists(outputFolder))
//{
// Console.WriteLine("Error: output folder not found.");
// return;
//}
if (string.IsNullOrEmpty(Path.GetDirectoryName(outputFolder)))
{
outputFolder = Path.GetPathRoot(outputFolder + Path.DirectorySeparatorChar.ToString());
}
else
{
outputFolder = Path.GetDirectoryName(outputFolder + Path.DirectorySeparatorChar.ToString());
}
try
{
Console.Write("Parsing file '{0}'... ", inputFilename);
using (XmlReader rdr = XmlReader.Create(inputFilename))
{
model = WXMLModel.LoadFromXml(rdr, new XmlUrlResolver());
}
Console.WriteLine("done!");
if (validateOnly)
{
Console.WriteLine("Input file validation success.");
return;
}
}
catch (Exception exc)
{
Console.WriteLine("error: {0}", exc.Message);
Console.WriteLine("callstack: {0}", exc.StackTrace);
if (exc.InnerException != null)
{
Console.WriteLine("error: {0}", exc.InnerException.Message);
}
return;
}
if (!Directory.Exists(outputFolder))
{
try
{
Directory.CreateDirectory(outputFolder);
}
catch (Exception)
{
}
}
var gen = new WXMLToWorm.WormCodeDomGenerator(model, settings);
//settings.Split = split;
settings.LanguageSpecificHacks = languageHacks;
Console.WriteLine("Generation entities from file '{0}' using these settings:", inputFilename);
Console.WriteLine(" Output folder: {0}", System.IO.Path.GetFullPath(outputFolder));
Console.WriteLine(" Language: {0}", outputLanguage.ToLower());
Console.WriteLine(" Split files: {0}", split);
Console.WriteLine(" Skip entities: {0}", string.Join(" ", skipEntities));
Console.WriteLine(" Process entities: {0}", string.Join(" ", processEntities));
if (oneFile)
{
string privateFolder = outputFolder + Path.DirectorySeparatorChar.ToString();
CodeCompileUnit unit = gen.GetFullSingleUnit(typeof(VBCodeProvider).IsAssignableFrom(codeDomProvider.GetType()) ? LinqToCodedom.CodeDomGenerator.Language.VB : LinqToCodedom.CodeDomGenerator.Language.CSharp);
if (!Directory.Exists(privateFolder))
{
Directory.CreateDirectory(privateFolder);
}
string outputFileName = Path.GetFullPath(privateFolder + Path.DirectorySeparatorChar.ToString() +
Path.GetFileNameWithoutExtension(inputFilename));
GenerateCode(codeDomProvider, unit, outputFileName, testRun);
Console.WriteLine();
Console.WriteLine("Result:");
Console.WriteLine("\t{0} single generated.");
}
else
{
GenerateMultipleFilesOutput(outputFolder, model, codeDomProvider, separateFolder,
skipEntities, processEntities, testRun, gen);
}
}
public CodeEntityInterfaceDeclaration(WXMLCodeDomGeneratorSettings settings, CodeEntityTypeDeclaration entityTypeDeclaration)
: this(settings, entityTypeDeclaration, null, null)
{
}
public CodeEntityPropertyField(WXMLCodeDomGeneratorSettings settings, ScalarPropertyDefinition property)
{
Type = property.PropertyType.ToCodeType(settings);
Name = new WXMLCodeDomGeneratorNameHelper(settings).GetPrivateMemberName(property.Name);
Attributes = WXMLCodeDomGenerator.GetMemberAttribute(property.FieldAccessLevel);
}
private CodeCompileUnit GenerateModificationTracker(WXMLModel model, WXMLCodeDomGeneratorSettings setting)
{
var c = new CodeDomGenerator();
string mtName = "LinqModificationTracker";
var cls = c.AddNamespace(model.Namespace).AddClass(mtName);
_ctxName = model.Namespace + "." + model.LinqSettings.ContextName;
_mtName = model.Namespace + "." + mtName;
string conn = ConfigurationManager.ConnectionStrings["wms"].ConnectionString;
cls.Implements(typeof(IModificationTracker))
.AddEnum("ActionEnum")
.AddFields(
Define.StructField("Update"),
Define.StructField("Insert"),
Define.StructField("Delete")
);
cls.AddField("_changed", () => new List <object>());
cls.AddField("_deleted", () => new List <object>());
var tableType = new CodeTypeReference(typeof(System.Data.Linq.Table <>));
tableType.TypeArguments.Add(new CodeTypeReference("T"));
cls
.AddMethod(MemberAttributes.Public | MemberAttributes.Final, (ParamArray <object> entities) => "Add",
Emit.stmt((List <object> _changed, object[] entities) => _changed.AddRange(entities)))
.Implements(typeof(IModificationTracker))
.AddMethod(MemberAttributes.Public | MemberAttributes.Final, (ParamArray <object> entities) => "Delete",
Emit.stmt((List <object> _deleted, object[] entities) => _deleted.AddRange(entities)))
.Implements(typeof(IModificationTracker))
.AddMethod(MemberAttributes.Public | MemberAttributes.Final, () => "AcceptModifications",
Emit.@using(new CodeTypeReference(_ctxName), "ctx", () => CodeDom.@new(_ctxName, conn),
Emit.@foreach("entity", () => [email protected] <IEnumerable <object> >("_changed"),
Emit.stmt((object entity) => [email protected]("SyncEntity")(CodeDom.VarRef("ctx"), entity, false))
),
Emit.@foreach("entity", () => [email protected] <IEnumerable <object> >("_deleted"),
Emit.stmt((object entity) => [email protected]("SyncEntity")(CodeDom.VarRef("ctx"), entity, true))
),
Emit.stmt(() => CodeDom.VarRef("ctx").Call("SubmitChanges")),
Emit.@foreach("entity", () => [email protected] <IEnumerable <object> >("_changed"),
Emit.stmt((object entity) => [email protected]("AcceptChanges")(entity))
),
Emit.stmt(() => [email protected] <List <object> >("_changed").Clear()),
Emit.@foreach("entity", () => [email protected] <IEnumerable <object> >("_deleted"),
Emit.stmt((object entity) => [email protected]("AcceptChanges")(entity))
),
Emit.stmt(() => [email protected] <List <object> >("_deleted").Clear())
)
).Implements(typeof(IModificationTracker))
.AddMethod(MemberAttributes.Private, () => "Dispose").Implements(typeof(IDisposable))
.AddMethod(MemberAttributes.Private, (object entity) => "AcceptChanges",
Emit.declare("mi", (object entity) => entity.GetType().GetMethod("AcceptChanges")),
Emit.@if(() => CodeDom.VarRef("mi") != null,
Emit.stmt((MethodInfo mi, object entity) => mi.Invoke(entity, null))
)
)
.AddMethod(MemberAttributes.Private, (DynType ctx, object entity, bool delete) => "SyncEntity" + ctx.SetType(_ctxName),
Emit.@foreach("mi", () => [email protected] <Type>("GetType")().GetMethods(BindingFlags.NonPublic | BindingFlags.Static),
Emit.@if((bool delete, MethodInfo mi, object entity) =>
((delete && mi.Name == "_DelEntity") || (!delete && mi.Name == "_SyncEntity")) && mi.GetParameters().Count() == 2 && mi.GetParameters().Last().ParameterType == entity.GetType(),
Emit.stmt((MethodInfo mi, object entity) => mi.Invoke(null, BindingFlags.Static, null, new object[] { CodeDom.VarRef("ctx"), entity }, null)),
Emit.exitFor()
)
)
)
.AddMethod(MemberAttributes.Private | MemberAttributes.Static, (DynType p, DynType action, DynType table) => "SyncEntity" + p.SetType("T") + action.SetType("ActionEnum") + table.SetType(tableType),
Emit.ifelse(() => CodeDom.VarRef("action") == CodeDom.Field(new CodeTypeReference("ActionEnum"), "Insert"),
CodeDom.CombineStmts(Emit.stmt(() => CodeDom.VarRef("table").Call("InsertOnSubmit")(CodeDom.VarRef("p")))),
Emit.ifelse(() => CodeDom.VarRef("action") == CodeDom.Field(new CodeTypeReference("ActionEnum"), "Delete"),
CodeDom.CombineStmts(
Emit.stmt(() => CodeDom.VarRef("table").Call("Attach")(CodeDom.VarRef("p"))),
Emit.stmt(() => CodeDom.VarRef("table").Call("DeleteOnSubmit")(CodeDom.VarRef("p")))
),
Emit.stmt(() => CodeDom.VarRef("table").Call("Attach")(CodeDom.VarRef("p"), true))
)
)
).Generic("T", typeof(object))
;
WXMLCodeDomGeneratorNameHelper n = new WXMLCodeDomGeneratorNameHelper(setting);
foreach (var entity in model.GetActiveEntities())
{
if (entity.GetPkProperties().Count() == 1)
{
//string entityName = entity.Name;
string entityProp = WXMLCodeDomGeneratorNameHelper.GetMultipleForm(entity.Name);
string entityType = n.GetEntityClassName(entity, true);
string pkName = entity.GetPkProperties().Single().Name;
cls.AddMethod(MemberAttributes.Static | MemberAttributes.Private,
(DynType ctx, DynType p) => "_DelEntity" + ctx.SetType(_ctxName) + p.SetType(entityType),
Emit.stmt(() => CodeDom.Call(null, "SyncEntity", new CodeTypeReference(entityType))(
CodeDom.VarRef("p"),
CodeDom.Field(new CodeTypeReference("ActionEnum"), "Delete"),
CodeDom.VarRef("ctx").Property(entityProp))
)
)
.AddMethod(MemberAttributes.Static | MemberAttributes.Private,
(DynType ctx, DynType p) => "_SynEntity" + ctx.SetType(_ctxName) + p.SetType(entityType),
Emit.stmt(() => CodeDom.Call(null, "SyncEntity", new CodeTypeReference(entityType))(
CodeDom.VarRef("p"),
CodeDom.VarRef("p").Field <int>(pkName) == 0 ? CodeDom.Field(new CodeTypeReference("ActionEnum"), "Insert") : CodeDom.Field(new CodeTypeReference("ActionEnum"), "Update"),
CodeDom.VarRef("ctx").Property(entityProp))
)
)
;
}
}
string debug = c.GenerateCode(CodeDomGenerator.Language.CSharp);
return(c.GetCompileUnit(CodeDomGenerator.Language.CSharp));
}
