public void Compile(string outputPath, GenerationSet metaData, CodeGenerationSettings settings, string target) { var generationInfo = new CodeGenerationInfo(outputPath, metaData, settings); if (settings.Options.HasFlag(CodeGenerationOptions.OmitCode) == false && settings.Options.HasFlag(CodeGenerationOptions.OmitBaseCode) == false) { var filename = this.CompileAll(outputPath, generationInfo, target); this.PrintResult(filename); } else if (settings.Options.HasFlag(CodeGenerationOptions.OmitCode) == true) { var filename = this.CompileBase(outputPath, generationInfo, target); this.PrintResult(filename); } else if (settings.Options.HasFlag(CodeGenerationOptions.OmitBaseCode) == true) { var tempPath = PathUtility.GetTempPath(true); try { var readerPath = this.CompileBase(tempPath, generationInfo, target); var filename = this.Compile(outputPath, readerPath, generationInfo, target); this.PrintResult(filename); } finally { DirectoryUtility.Delete(tempPath); } } }
public static void Create(CodeNamespace codeNamespace, TableInfo tableInfo, CodeGenerationInfo generationInfo) { var classType = new CodeTypeDeclaration() { Attributes = MemberAttributes.Public, Name = tableInfo.GetRowClassName(), IsClass = true }; classType.TypeAttributes |= TypeAttributes.Sealed; classType.BaseTypes.Add(generationInfo.BaseNamespace, "CremaRow"); CreateChildStaticEmptyFields(classType, tableInfo, generationInfo); CreateConstructor(classType, tableInfo, generationInfo); CreateTableField(classType, tableInfo); CreateColumnFields(classType, tableInfo, generationInfo); CreateChildFields(classType, tableInfo, generationInfo); CreateSetChildsMethod(classType, tableInfo, generationInfo); CreateColumnProperties(classType, tableInfo, generationInfo); CreateChildProperties(classType, tableInfo, generationInfo); CreateTableProperty(classType, tableInfo); CreateParentProperty(classType, tableInfo); codeNamespace.Types.Add(classType); }
private static CodeTypeDeclaration CreateCore(TableInfo tableInfo, CodeGenerationInfo generationInfo) { var classType = new CodeTypeDeclaration() { Attributes = MemberAttributes.Public, Name = tableInfo.GetClassName(), IsClass = true }; classType.TypeAttributes |= TypeAttributes.Sealed; classType.BaseTypes.Add(generationInfo.BaseNamespace, "CremaTable", tableInfo.GetRowCodeType()); if (generationInfo.OmitComment == false) { classType.Comments.AddSummary(tableInfo.Comment); } if (generationInfo.OmitSignatureDate == false) { classType.Comments.Add(CremaSchema.Creator, tableInfo.CreationInfo.ID); classType.Comments.Add(CremaSchema.CreatedDateTime, tableInfo.CreationInfo.DateTime); classType.Comments.Add(CremaSchema.Modifier, tableInfo.ModificationInfo.ID); classType.Comments.Add(CremaSchema.ModifiedDateTime, tableInfo.ModificationInfo.DateTime); classType.Comments.Add(CremaSchema.ContentsModifier, tableInfo.ContentsInfo.ID); classType.Comments.Add(CremaSchema.ContentsModifiedDateTime, tableInfo.ContentsInfo.DateTime); } CreateChildFields(classType, tableInfo, generationInfo); CreateChildProperties(classType, tableInfo, generationInfo); CreateConstructor(classType, tableInfo, generationInfo); CreateConstructorFromTable(classType, tableInfo, generationInfo); CreateConstructorFromRows(classType, tableInfo); CreateFindMethod(classType, tableInfo, generationInfo); CreateCreateRowInstanceMethod(classType, tableInfo, generationInfo); return(classType); }
private static void CreateTagsField(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var cmf = new CodeMemberField(); cmf.Attributes = MemberAttributes.Private; cmf.Name = "_tags"; cmf.Type = new CodeTypeReference(typeof(string)); classType.Members.Add(cmf); }
private string GenerateBase(CodeGenerationInfo generationInfo) { var assembly = System.Reflection.Assembly.GetExecutingAssembly(); var resourceName = string.Join(".", this.GetType().Namespace, "Code", "CremaBase.cs"); var code = this.GetResourceString(resourceName); code = code.Replace("namespace Ntreev.Crema.Code", "namespace " + generationInfo.BaseNamespace); code = code.Replace("Ntreev.Crema.Reader", generationInfo.ReaderNamespace); return(code); }
private static void CreateTagsProperty(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var cmm = new CodeMemberProperty(); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final; cmm.Name = "Tags"; cmm.HasGet = true; cmm.Type = new CodeTypeReference(typeof(string)); cmm.GetStatements.AddMethodReturn(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "_tags")); classType.Members.Add(cmm); }
public static void Create(CodeNamespace codeNamespace, CodeGenerationInfo generationInfo) { foreach (var item in generationInfo.Tables) { if (item.TemplatedParent != string.Empty) { continue; } Create(codeNamespace, item, generationInfo); } }
private static void CreateTableFields(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { foreach (var item in generationInfo.GetTables(true)) { var cmf = new CodeMemberField() { Attributes = MemberAttributes.Private, Name = item.GetFieldName(), Type = item.GetCodeType() }; classType.Members.Add(cmf); } }
public static void Create(CodeNamespace codeNamespace, CodeGenerationInfo generationInfo) { codeNamespace.Comments.Add(new CodeCommentStatement($"------------------------------------------------------------------------------")); codeNamespace.Comments.Add(new CodeCommentStatement($"dataBase: {generationInfo.DataBaseName}")); codeNamespace.Comments.Add(new CodeCommentStatement($"revision: {generationInfo.Revision}")); codeNamespace.Comments.Add(new CodeCommentStatement($"requested revision: {generationInfo.RequestedRevision}")); codeNamespace.Comments.Add(new CodeCommentStatement($"devmode: {generationInfo.IsDevmode}")); codeNamespace.Comments.Add(new CodeCommentStatement($"hash value: {generationInfo.TypesHashValue}")); codeNamespace.Comments.Add(new CodeCommentStatement($"tags: {generationInfo.Tags}")); codeNamespace.Comments.Add(new CodeCommentStatement($"------------------------------------------------------------------------------")); foreach (var item in generationInfo.Types) { CreateType(codeNamespace, item, generationInfo); } }
public static void Create(CodeNamespace codeNamespace, CodeGenerationInfo generationInfo) { codeNamespace.Comments.Add(new CodeCommentStatement($"------------------------------------------------------------------------------")); codeNamespace.Comments.Add(new CodeCommentStatement($"dataBase: {generationInfo.DataBaseName}")); codeNamespace.Comments.Add(new CodeCommentStatement($"revision: {generationInfo.Revision}")); codeNamespace.Comments.Add(new CodeCommentStatement($"requested revision: {generationInfo.RequestedRevision}")); codeNamespace.Comments.Add(new CodeCommentStatement($"devmode: {generationInfo.IsDevmode}")); codeNamespace.Comments.Add(new CodeCommentStatement($"hash value: {generationInfo.TablesHashValue}")); codeNamespace.Comments.Add(new CodeCommentStatement($"tags: {generationInfo.Tags}")); codeNamespace.Comments.Add(new CodeCommentStatement($"------------------------------------------------------------------------------")); foreach (var item in generationInfo.GetTables()) { CremaTableClassCreator.Create(codeNamespace, item, generationInfo); } var classType = new CodeTypeDeclaration() { Attributes = MemberAttributes.Public, Name = generationInfo.ClassName, IsClass = true }; classType.TypeAttributes |= TypeAttributes.Sealed; classType.BaseTypes.Add(generationInfo.BaseNamespace, "CremaData"); CreateNameField(classType, generationInfo); CreateRevisionField(classType, generationInfo); CreateTypesHashValueField(classType, generationInfo); CreateTablesHashValueField(classType, generationInfo); CreateTagsField(classType, generationInfo); CreateNameProperty(classType, generationInfo); CreateRevisionProperty(classType, generationInfo); CreateTypesHashValueProperty(classType, generationInfo); CreateTablesHashValueProperty(classType, generationInfo); CreateTagsProperty(classType, generationInfo); CreateTableFields(classType, generationInfo); CreateConstructor(classType, generationInfo); CreateConstructorFromFile(classType, generationInfo); CreateConstructorFromStream(classType, generationInfo); CreateLoadFromFile(classType, generationInfo); CreateLoadStream(classType, generationInfo); CreateLoad(classType, generationInfo); CreateTableProperties(classType, generationInfo); codeNamespace.Types.Add(classType); }
private IDictionary <string, string> GenerateCodes(CodeGenerationInfo generationInfo) { var codes = new Dictionary <string, string>(); var cremaTypes = this.GenerateTypeCode(generationInfo); var cremaTables = this.GenerateTableCode(generationInfo); codes.Add($"{generationInfo.Prefix}Types{generationInfo.Postfix}.cs", cremaTypes); codes.Add($"{generationInfo.Prefix}Tables{generationInfo.Postfix}.cs", cremaTables); foreach (var item in codes.ToArray()) { codes[item.Key] = item.Value.Replace("Ntreev.Crema.Reader", generationInfo.ReaderNamespace); } return(codes); }
public static void Create(CodeNamespace codeNamespace, TableInfo tableInfo, CodeGenerationInfo generationInfo) { foreach (var item in generationInfo.GetChilds(tableInfo)) { if (item.TemplatedParent != string.Empty) { continue; } Create(codeNamespace, item, generationInfo); } CremaRowClassCreator.Create(codeNamespace, tableInfo, generationInfo); var classType = CreateCore(tableInfo, generationInfo); codeNamespace.Types.Add(classType); }
private static void CreateTableProperties(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { foreach (var item in generationInfo.GetTables(true)) { var cmp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final, Name = item.GetPropertyName(), Type = item.GetCodeType(), HasGet = true, HasSet = false }; cmp.Comments.AddSummary(item.Comment); cmp.GetStatements.AddMethodReturn(item.GetFieldExpression()); classType.Members.Add(cmp); } }
private string GenerateTypeCode(CodeGenerationInfo generationInfo) { var sb = new StringBuilder(); using (var sw = new StringWriter(sb)) { var codeDomProvider = new CSharpCodeProvider(); var codeGenerator = codeDomProvider.CreateGenerator(sw); var compileUnit = new CodeCompileUnit(); var codeNamespace = new CodeNamespace(generationInfo.Namespace); codeNamespace.Imports.Add(new CodeNamespaceImport(generationInfo.ReaderNamespace)); CremaTypeEnumCreator.Create(codeNamespace, generationInfo); compileUnit.Namespaces.Add(codeNamespace); codeGenerator.GenerateCodeFromCompileUnit(compileUnit, sw, this.options); } return(sb.ToString()); }
private string CompileAll(string outputPath, CodeGenerationInfo generationInfo, string target) { var sourceList = new List <string>(); sourceList.AddRange(this.GenerateCodes(generationInfo).Values); sourceList.AddRange(this.GenerateBaseCodes(generationInfo).Values); sourceList.Add(this.GenerateAssemblyInfo(generationInfo.Namespace)); var providerOptions = new Dictionary <string, string> { { "CompilerVersion", target == string.Empty ? "v3.5" : target } }; var codeDomProvider = new CSharpCodeProvider(providerOptions); var cp = new CompilerParameters() { OutputAssembly = Path.Combine(outputPath, generationInfo.Namespace + ".dll"), CompilerOptions = "/optimize", GenerateExecutable = false, GenerateInMemory = false }; cp.ReferencedAssemblies.Add("System.dll"); cp.ReferencedAssemblies.Add("System.Core.dll"); cp.ReferencedAssemblies.Add("System.Data.dll"); cp.ReferencedAssemblies.Add("System.Xml.dll"); FileUtility.Prepare(cp.OutputAssembly); var result = codeDomProvider.CompileAssemblyFromSource(cp, sourceList.ToArray()); if (result.Errors.HasErrors) { foreach (var item in result.Errors) { Trace.WriteLine(item); } throw new Exception("에러가 발생했습니다."); } return(cp.OutputAssembly); }
private static void CreateConstructor(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var cc = new CodeConstructor() { Attributes = MemberAttributes.Public }; cc.Parameters.Add("IDataSet", "dataSet"); cc.Parameters.Add(new CodeTypeReference(typeof(bool)), "verifyRevision"); //cc.BaseConstructorArgs.Add(new CodePrimitiveExpression(generationInfo.DataBaseName)); //cc.BaseConstructorArgs.Add(new CodePrimitiveExpression(generationInfo.Revision)); var methodInvokeExp = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Load", new CodeVariableReferenceExpression("dataSet"), new CodeVariableReferenceExpression("verifyRevision")); cc.Statements.Add(methodInvokeExp); classType.Members.Add(cc); }
private static void CreateConstructorFromFile(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var cc = new CodeConstructor() { Attributes = MemberAttributes.Public }; cc.Parameters.Add(typeof(string), "filename"); cc.Parameters.Add(new CodeTypeReference(typeof(bool)), "verifyRevision"); var readerRef = new CodeTypeReferenceExpression(string.Join(".", generationInfo.ReaderNamespace, "CremaReader")); var paramExp = new CodeVariableReferenceExpression("filename"); var methodInvokeExp = new CodeMethodInvokeExpression(readerRef, "Read", paramExp); cc.ChainedConstructorArgs.Add(methodInvokeExp); cc.ChainedConstructorArgs.Add(new CodeVariableReferenceExpression("verifyRevision")); classType.Members.Add(cc); }
private static void CreateLoadStream(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var cc = new CodeMemberMethod() { Attributes = MemberAttributes.Public | MemberAttributes.Final, Name = "Load", }; cc.Parameters.Add(typeof(Stream), "stream"); cc.Parameters.Add(typeof(bool), "verifyRevision"); var readerRef = new CodeTypeReferenceExpression(string.Join(".", generationInfo.ReaderNamespace, "CremaReader")); var paramExp = new CodeVariableReferenceExpression("stream"); var readExp = new CodeMethodInvokeExpression(readerRef, "Read", paramExp); var methodInvokeExp = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Load", readExp, new CodeVariableReferenceExpression("verifyRevision")); cc.Statements.Add(methodInvokeExp); classType.Members.Add(cc); }
private IDictionary <string, string> GenerateBaseCodes(CodeGenerationInfo generationInfo) { var codes = new Dictionary <string, string>(); var cremaBase = this.GenerateBase(generationInfo); codes.Add($"{generationInfo.RelativePath}CremaBase.cs", cremaBase); var assembly = System.Reflection.Assembly.GetExecutingAssembly(); var ns = string.Join(".", this.GetType().Namespace, "Reader"); var files = assembly.GetManifestResourceNames().Where(item => item.StartsWith(ns)); foreach (var item in files) { var value = this.GetResourceString(item); var key = Regex.Replace(item, "(^" + this.GetType().Namespace + @"[.])(\S+)[.]cs", "$2").Replace('.', Path.DirectorySeparatorChar); value = value.Replace("Ntreev.Crema.Reader", generationInfo.ReaderNamespace); codes.Add($"{generationInfo.RelativePath}{key}.cs", value); } return(codes); }
public void Generate(string outputPath, GenerationSet metaData, CodeGenerationSettings settings) { var generationInfo = new CodeGenerationInfo(outputPath, metaData, settings); if (settings.Options.HasFlag(CodeGenerationOptions.OmitCode) == false) { var codes = this.GenerateCodes(generationInfo); foreach (var item in codes) { var codePath = FileUtility.WriteAllText(item.Value, Encoding.UTF8, outputPath, item.Key); this.PrintResult(codePath); } } if (settings.Options.HasFlag(CodeGenerationOptions.OmitBaseCode) == false) { var codes = this.GenerateBaseCodes(generationInfo); foreach (var item in codes) { var codePath = FileUtility.WriteAllText(item.Value, Encoding.UTF8, outputPath, item.Key); this.PrintResult(codePath); } } }
private static void CreateConstructor(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo) { var cc = new CodeConstructor() { Attributes = MemberAttributes.Public }; cc.Parameters.Add(generationInfo.ReaderNamespace, "IRow", "row"); cc.Parameters.Add(tableInfo.GetCodeType(), "table"); cc.BaseConstructorArgs.Add("table.Columns"); cc.BaseConstructorArgs.Add("row"); // assign table field { var leftExp = tableInfo.GetFieldExpression(); var rightExp = new CodeVariableReferenceExpression("table"); cc.Statements.AddAssign(leftExp, rightExp); } // assign fields { var index = 0; foreach (var item in tableInfo.Columns) { var cas = new CodeAssignStatement() { Left = item.GetFieldExpression(), Right = item.GetGetValueMethodExpression(index, false) }; if (item.IsKey == false) { var ccs = new CodeConditionStatement(item.GetHasValueMethodExpression(index, false)); ccs.TrueStatements.Add(cas); cc.Statements.Add(ccs); } else { cc.Statements.Add(cas); } index++; } } classType.Members.Add(cc); }
private static void CreateChildProperties(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo) { foreach (var item in generationInfo.GetChilds(tableInfo)) { var cmp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final, Name = item.GetPropertyName(), Type = item.GetCodeType() }; if (generationInfo.OmitComment == false) { cmp.Comments.AddSummary(item.Comment); } if (generationInfo.OmitSignatureDate == false) { cmp.Comments.Add(CremaSchema.Creator, item.CreationInfo.ID); cmp.Comments.Add(CremaSchema.CreatedDateTime, item.CreationInfo.DateTime); cmp.Comments.Add(CremaSchema.Modifier, item.ModificationInfo.ID); cmp.Comments.Add(CremaSchema.ModifiedDateTime, item.ModificationInfo.DateTime); } cmp.HasGet = true; cmp.HasSet = false; { var state = new CodeConditionStatement(); var testExp = new CodeBinaryOperatorExpression(item.GetFieldExpression(), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)); state.Condition = testExp; var staticRefExp = new CodeTypeReferenceExpression(tableInfo.GetRowCodeType()); var fieldExp = new CodeFieldReferenceExpression(staticRefExp, item.GetFieldName() + "Empty"); state.TrueStatements.AddMethodReturn(fieldExp); cmp.GetStatements.Add(state); } { var fieldExp = item.GetFieldExpression(); cmp.GetStatements.AddMethodReturn(fieldExp); } classType.Members.Add(cmp); } }
private static void CreateColumnProperties(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo) { foreach (var item in tableInfo.Columns) { var cmp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final, Name = item.Name, Type = item.GetCodeType() }; if (generationInfo.OmitComment == false) { cmp.Comments.AddSummary(item.Comment); } if (generationInfo.OmitSignatureDate == false) { cmp.Comments.Add(CremaSchema.Creator, item.CreationInfo.ID); cmp.Comments.Add(CremaSchema.CreatedDateTime, item.CreationInfo.DateTime); cmp.Comments.Add(CremaSchema.Modifier, item.ModificationInfo.ID); cmp.Comments.Add(CremaSchema.ModifiedDateTime, item.ModificationInfo.DateTime); } cmp.HasGet = true; cmp.HasSet = false; cmp.GetStatements.AddMethodReturn(item.GetFieldExpression()); classType.Members.Add(cmp); } }
private static void CreateChildStaticEmptyFields(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo) { foreach (var item in generationInfo.GetChilds(tableInfo)) { var cmf = new CodeMemberField() { Attributes = MemberAttributes.Private | MemberAttributes.Static, Name = item.GetFieldName() + "Empty", Type = item.GetCodeType(), InitExpression = new CodeObjectCreateExpression(item.GetCodeType()) }; classType.Members.Add(cmf); } }
private static void CreateColumnFields(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo) { foreach (var item in tableInfo.Columns) { var cmf = new CodeMemberField() { Attributes = MemberAttributes.Private, Name = item.GetFieldName(), Type = item.GetCodeType() }; classType.Members.Add(cmf); } }
private static void CreateSetChildsMethod(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo) { foreach (var item in generationInfo.GetChilds(tableInfo)) { var cmm = new CodeMemberMethod() { Attributes = MemberAttributes.FamilyAndAssembly | MemberAttributes.Static, Name = "Set" + item.TableName }; cmm.Parameters.Add(tableInfo.GetRowCodeType(), "target"); cmm.Parameters.Add(typeof(string), "childName"); cmm.Parameters.Add(item.GetRowCodeType(), 1, "childs"); { var methodRefExp = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(tableInfo.GetRowCodeType()), "SetParent"); methodRefExp.TypeArguments.Add(tableInfo.GetRowCodeType()); methodRefExp.TypeArguments.Add(item.GetRowCodeType()); var methodInvokeExp = new CodeMethodInvokeExpression(methodRefExp, new CodeVariableReferenceExpression("target"), new CodeVariableReferenceExpression("childs")); cmm.Statements.AddExpression(methodInvokeExp); } { var target = new CodeVariableReferenceExpression("target"); var childName = new CodeVariableReferenceExpression("childName"); var childs = new CodeVariableReferenceExpression("childs"); var targetField = item.GetFieldExpression(target); var targetInstance = new CodeObjectCreateExpression(item.GetCodeType(), childName, childs); cmm.Statements.AddAssign(targetField, targetInstance); } classType.Members.Add(cmm); } }
private static void CreateConstructorFromTable(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo) { var cc = new CodeConstructor() { Attributes = MemberAttributes.Public }; cc.Parameters.Add(generationInfo.ReaderNamespace, "ITable", "table"); cc.BaseConstructorArgs.Add("table"); // verify revision { var css = CreateCompareTypeStatement(classType, tableInfo, generationInfo); var tst = CremaDataClassCreator.CreateTryCatchStatement(classType, css, generationInfo); cc.Statements.Add(tst); } // initialize childs { var table = new CodeVariableReferenceExpression("table"); var dataSet = new CodePropertyReferenceExpression(table, "DataSet"); var tables = new CodePropertyReferenceExpression(dataSet, "Tables"); foreach (var item in generationInfo.GetChilds(tableInfo)) { var tableName = new CodePropertyReferenceExpression(table, "Name"); var childName = new CodeBinaryOperatorExpression(tableName, CodeBinaryOperatorType.Add, new CodePrimitiveExpression("." + item.TableName)); var childTable = new CodeIndexerExpression(tables, childName); var childField = item.GetFieldExpression(); var instance = new CodeObjectCreateExpression(item.GetCodeType(), childTable); cc.Statements.AddAssign(childField, instance); } } // SetRelations { var table = new CodeVariableReferenceExpression("table"); foreach (var item in generationInfo.GetChilds(tableInfo)) { var setRelations = new CodeMethodReferenceExpression(thisRef, "SetRelations"); var rows = new CodePropertyReferenceExpression(item.GetFieldExpression(), "Rows"); var setChildAction = new CodePropertyReferenceExpression(tableInfo.GetRowCodeTypeExpression(), "Set" + item.TableName); var tableName = new CodePropertyReferenceExpression(table, "Name"); var childName = new CodeBinaryOperatorExpression(tableName, CodeBinaryOperatorType.Add, new CodePrimitiveExpression("." + item.TableName)); var setRelationsInvoke = new CodeMethodInvokeExpression(setRelations, childName, rows, setChildAction); cc.Statements.Add(setRelationsInvoke); } } classType.Members.Add(cc); }
private static CodeStatement CreateCompareTypeStatement(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo) { var table = new CodeVariableReferenceExpression("table"); var hashValue = new CodePropertyReferenceExpression(table, "HashValue"); var state = new CodeConditionStatement() { Condition = new CodeBinaryOperatorExpression(hashValue, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(tableInfo.HashValue)) }; var message = string.Format("{0} 테이블과 데이터의 형식이 맞지 않습니다.", tableInfo.Name); var exception = new CodeObjectCreateExpression(typeof(Exception), new CodePrimitiveExpression(message)); state.TrueStatements.Add(new CodeThrowExceptionStatement(exception)); return(state); }
private static void CreateCreateRowInstanceMethod(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo) { var cmm = new CodeMemberMethod() { Attributes = MemberAttributes.Family | MemberAttributes.Override, Name = "CreateRowInstance", ReturnType = tableInfo.GetRowCodeType() }; cmm.Parameters.Add(generationInfo.ReaderNamespace, "IRow", "row"); cmm.Parameters.Add(typeof(object), "table"); // statement { var row = new CodeVariableReferenceExpression("row"); var tablePtr = new CodeVariableReferenceExpression("table"); var table = new CodeCastExpression(tableInfo.GetCodeType(), tablePtr); var instance = new CodeObjectCreateExpression(tableInfo.GetRowCodeType(), row, table); cmm.Statements.AddMethodReturn(instance); } classType.Members.Add(cmm); }
private static void CreateFindMethod(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo) { var cmm = new CodeMemberMethod() { Attributes = MemberAttributes.Public | MemberAttributes.Final, Name = "Find", ReturnType = tableInfo.GetRowCodeType() }; cmm.Parameters.Add(tableInfo.Columns.Where(item => item.IsKey)); // invoke base.FindRow { var query = from item in tableInfo.Columns where item.IsKey select item.IsCustomType() ? new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(item.Name), "ToString"), new CodePrimitiveExpression("D")) : new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeVariableReferenceExpression(item.Name), "ToString")); var invokeGenerateHashCode = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("CremaUtility"), "GenerateHashCode"); invokeGenerateHashCode.Parameters.AddRange(query.ToArray()); var invokeFindRow = new CodeMethodInvokeExpression(baseRef, "FindRow", invokeGenerateHashCode); cmm.Statements.AddMethodReturn(invokeFindRow); } classType.Members.Add(cmm); }