/// <summary> /// Generate the code to access the model. Use to CodeDomProvider so we are language-agnostic /// </summary> /// <param name="directiveName"></param> /// <param name="codeBuffer"></param> /// <param name="languageProvider"></param> /// <param name="requiresArguments"></param> /// <param name="providesArguments"></param> protected override void GenerateTransformCode(string directiveName, StringBuilder codeBuffer, CodeDomProvider languageProvider, IDictionary <string, string> requiresArguments, IDictionary <string, string> providesArguments) { if ((StringComparer.InvariantCultureIgnoreCase.Compare(directiveName, "schemamodel") == 0)) { if (languageProvider != null) { // Create a field to store the model once it is loaded CodeMemberField schemamodel = new CodeMemberField(); schemamodel.Name = providesArguments["SchemaModel"].ToLower(CultureInfo.InvariantCulture) + "Value"; schemamodel.Type = new CodeTypeReference(typeof(ISpySoft.SFSchemaLanguage.DomainModel.SchemaModel)); schemamodel.Attributes = MemberAttributes.Private; // Create a property for the Model that delay-loads the model CodeMemberProperty schemamodelProperty = new CodeMemberProperty(); schemamodelProperty.Name = providesArguments["SchemaModel"]; schemamodelProperty.Type = new CodeTypeReference(typeof(ISpySoft.SFSchemaLanguage.DomainModel.SchemaModel)); schemamodelProperty.Attributes = MemberAttributes.Private; schemamodelProperty.HasSet = false; schemamodelProperty.HasGet = true; schemamodelProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), schemamodel.Name))); // Generate the actual code using the CodeDomProvider CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BlankLinesBetweenMembers = true; options.IndentString = " "; options.VerbatimOrder = true; options.BracingStyle = "C"; using (StringWriter writer = new StringWriter(codeBuffer, CultureInfo.InvariantCulture)) { languageProvider.GenerateCodeFromMember(schemamodel, writer, options); languageProvider.GenerateCodeFromMember(schemamodelProperty, writer, options); } } } }
/// <summary> /// Generates the code that will be added to the generated template. For /// each argument a private field is generated that will hold the argument /// value. Also a readonly public property is generated to access the argument /// value. When a convertor of editor is defined there is a attribute genereted /// for each of them. /// </summary> /// <returns>The fields and arguments</returns> public override string GetClassCodeForProcessingRun() { using (var writer = new StringWriter(CultureInfo.InvariantCulture)) { foreach (ArgumentInfo argument in _argumentInfos.Values) { //Create field var field = new CodeMemberField(argument.Type, argument.FieldName) { Attributes = MemberAttributes.Private }; _provider.GenerateCodeFromMember(field, writer, _options); //Create the property for each argument var property = new CodeMemberProperty { Name = argument.Name, Type = new CodeTypeReference(argument.Type), Attributes = MemberAttributes.Public, HasGet = true, HasSet = false }; property.GetStatements.Add( new CodeMethodReturnStatement(new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), argument.FieldName))); //Add editor attribute if (!string.IsNullOrEmpty(argument.EditorType)) { property.CustomAttributes.Add(new CodeAttributeDeclaration( new CodeTypeReference(typeof(EditorAttribute)), new CodeAttributeArgument( new CodeTypeOfExpression(argument.EditorType)), new CodeAttributeArgument( new CodeTypeOfExpression(typeof(UITypeEditor))))); } //Add convertor attribute if (!string.IsNullOrEmpty(argument.ConverterType)) { property.CustomAttributes.Add(new CodeAttributeDeclaration( new CodeTypeReference(typeof(TypeConverter)), new CodeAttributeArgument( new CodeTypeOfExpression(argument.ConverterType)))); } _provider.GenerateCodeFromMember(property, writer, _options); } return(writer.ToString()); } }
public override string GetClassCodeForProcessingRun() { CodeGeneratorOptions options = new CodeGeneratorOptions(); var langTool = new CodeMemberField() { Attributes = MemberAttributes.Public , Name = "languageTool" , Type = new CodeTypeReference(typeof(LanguageTool)) , InitExpression = new CodeObjectCreateExpression(typeof(LanguageTool)) }; languageProvider.GenerateCodeFromMember(langTool, fieldWriter, options); return(fieldWriter.GetStringBuilder().ToString()); }
/// <summary> /// Create the code added as members to the transform class. /// </summary> private void GenerateClassCode(string nameValue, string typeValue, out CodeMemberField field) { field = new CodeMemberField(typeValue, string.Format(CultureInfo.InvariantCulture, "_{0}Field", nameValue)); field.Attributes = MemberAttributes.Private; field.Type.Options = CodeTypeReferenceOptions.GlobalReference; CodeMemberProperty codeMemberProperty = new CodeMemberProperty(); codeMemberProperty.Name = nameValue; codeMemberProperty.Type = new CodeTypeReference(typeValue, CodeTypeReferenceOptions.GlobalReference); codeMemberProperty.GetStatements.Add(new CodeMethodReturnStatement(field.Ref())); codeMemberProperty.AddSummaryComment("Access the " + nameValue + " parameter of the template."); CodeGeneratorOptions standardOptions = StandardOptions; using (StringWriter writer = new StringWriter(codeBuffer, CultureInfo.InvariantCulture)) { languageCodeDomProvider.GenerateCodeFromMember(field, writer, standardOptions); languageCodeDomProvider.GenerateCodeFromMember(codeMemberProperty, writer, standardOptions); } }
public override string GetClassCodeForProcessingRun() { var options = new CodeGeneratorOptions(); using (var sw = new StringWriter()) { foreach (CodeTypeMember member in members) { languageProvider.GenerateCodeFromMember(member, sw, options); } return(Indent(sw.ToString(), " ")); } }
public override void ProcessDirective(string directiveName, IDictionary <string, string> arguments) { string name = arguments["name"]; string fieldName = string.Format("_{0}", arguments["name"]); string type = arguments["type"]; var field = new CodeMemberField(type, fieldName) { Attributes = MemberAttributes.Private }; _provider.GenerateCodeFromMember(field, _classCodeWriter, _options); var property = new CodeMemberProperty { Name = name, Type = new CodeTypeReference(type), Attributes = MemberAttributes.Public, HasGet = true, HasSet = false }; property.GetStatements.Add( new CodeMethodReturnStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), fieldName))); _provider.GenerateCodeFromMember(property, _classCodeWriter, _options); CodeAssignStatement assignment = new CodeAssignStatement( new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName), new CodeCastExpression( new CodeTypeReference(type), new CodeMethodInvokeExpression( new CodeTypeReferenceExpression(typeof(CallContext)), "LogicalGetData", new CodePrimitiveExpression(name)))); _provider.GenerateCodeFromStatement(assignment, _initializationCodeWriter, _options); }
private string GetCodeString(CodeDomProvider provider, CodeTypeMember typeMember) { StringBuilder sb = new StringBuilder(); StringWriter sw = new StringWriter(sb); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.IndentString = ""; options.BracingStyle = "C"; provider.GenerateCodeFromMember(typeMember, sw, options); return(sb.ToString()); }
/// <summary> /// Generates a notification partial method for the specified method, this is of the form /// OnCreated(args...) for the Created(args...) method. /// </summary> /// <param name="methodName">The name of the method to create a notification method for.</param> /// <param name="parameters">the method parameters, if any.</param> /// <returns>Code snippet for the notification partial method.</returns> private CodeSnippetTypeMember CreateNotificationPartialMethod(string methodName, CodeParameterDeclarationExpressionCollection parameters) { CodeMemberMethod method = new CodeMemberMethod(); method.Attributes = MemberAttributes.Public | MemberAttributes.Final; method.Name = "On" + methodName; method.Parameters.AddRange(parameters); if (this.proxyGenerator.ClientProxyCodeGenerationOptions.UseFullTypeNames) { foreach (CodeParameterDeclarationExpression paramExp in parameters.Cast <CodeParameterDeclarationExpression>()) { SetGlobalTypeReference(paramExp.Type); } } StringBuilder snippet = null; using (CodeDomProvider provider = CodeDomProvider.CreateProvider(this.isCSharp ? "CSharp" : "VisualBasic")) { using (StringWriter snippetWriter = new StringWriter(System.Globalization.CultureInfo.CurrentCulture)) { provider.GenerateCodeFromMember(method, snippetWriter, new CodeGeneratorOptions()); snippet = snippetWriter.GetStringBuilder(); } } // replace 'public' with 'partial' - partial methods cannot be public. // observe we replace 'ublic' only to get the proper language keyword capitalization. snippet.Replace("\r\n", string.Empty); snippet.Replace("ublic", "artial", 1, "ublic".Length); if (this.isCSharp) { int idx = snippet.ToString().LastIndexOf(')'); snippet.Remove(idx + 1, snippet.Length - idx - 1); snippet.Append(";"); } else // VB.net { snippet.Insert(0, "Private "); int idx = snippet.ToString().IndexOf("End Sub", StringComparison.Ordinal); snippet.Insert(idx, string.Concat("\r\n", this.indent)); } snippet.Insert(0, this.indent); return(new CodeSnippetTypeMember(snippet.ToString())); }
//<Snippet3> static void GenCodeFromMember(CodeDomProvider provider, CodeGeneratorOptions options) { options.BracingStyle = "C"; CodeMemberMethod method1 = new CodeMemberMethod(); method1.Name = "ReturnString"; method1.Attributes = MemberAttributes.Public; method1.ReturnType = new CodeTypeReference("System.String"); method1.Parameters.Add(new CodeParameterDeclarationExpression("System.String", "text")); method1.Statements.Add(new CodeMethodReturnStatement(new CodeArgumentReferenceExpression("text"))); StringWriter sw = new StringWriter(); provider.GenerateCodeFromMember(method1, sw, options); snippetMethod = new CodeSnippetTypeMember(sw.ToString()); }
static void GenerateAction(CodeTypeDeclaration type, string name, CodeTypeReference senderType, CodeDomProvider provider, CodeGeneratorOptions generatorOptions, ref StringWriter actionStubWriter) { if (provider is Microsoft.CSharp.CSharpCodeProvider) { type.Members.Add(new CodeSnippetTypeMember("[MonoTouch.Foundation.Export(\"" + name + "\")]")); type.Members.Add(new CodeSnippetTypeMember( String.Format("partial void {1} ({2} sender);\n", name, provider.CreateValidIdentifier(name.TrimEnd(':')), senderType.BaseType))); return; } else if (provider.FileExtension == "pas") { var m = new CodeMemberMethod(); m.Name = provider.CreateValidIdentifier(name.TrimEnd(':')); m.Parameters.Add(new CodeParameterDeclarationExpression(senderType.BaseType, "sender")); m.UserData ["OxygenePartial"] = "YES"; m.UserData ["OxygeneEmpty"] = "YES"; var a = new CodeAttributeDeclaration("MonoTouch.Foundation.Export"); a.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(name))); m.CustomAttributes.Add(a); type.Members.Add(m); return; } var meth = CreateEventMethod(name, senderType); bool actionStubWriterCreated = false; if (actionStubWriter == null) { actionStubWriterCreated = true; actionStubWriter = new StringWriter(); actionStubWriter.WriteLine("Action method stubs:"); actionStubWriter.WriteLine(); } try { provider.GenerateCodeFromMember(meth, actionStubWriter, generatorOptions); actionStubWriter.WriteLine(); } catch { //clear the header if generation failed if (actionStubWriterCreated) { actionStubWriter = null; } } }
public void ConvertContentDefinition(CodeMemberField field, TextWriter writer) { LoggingService.Info("Generate field declaration for: " + field.Name); CodeGeneratorOptions options = codeDOMGeneratorUtility.CreateCodeGeneratorOptions; options.IndentString = indentation; try { codeProvider.GenerateCodeFromMember(field, writer, options); } catch (Exception e) { codeProvider.GenerateCodeFromStatement(new CodeCommentStatement("TODO: Error while generating statement : " + e.Message), writer, options); LoggingService.Error(e); } }
void GenerateCodeFromMembers(StringWriter sw, CodeGeneratorOptions options) { if (!useMonoHack) { foreach (CodeTypeMember member in members) { provider.GenerateCodeFromMember(member, sw, options); } } var cgType = typeof(CodeGenerator); var cgInit = cgType.GetMethod("InitOutput", BindingFlags.NonPublic | BindingFlags.Instance); var cgFieldGen = cgType.GetMethod("GenerateField", BindingFlags.NonPublic | BindingFlags.Instance); var cgPropGen = cgType.GetMethod("GenerateProperty", BindingFlags.NonPublic | BindingFlags.Instance); #pragma warning disable 0618 var generator = (CodeGenerator)provider.CreateGenerator(); #pragma warning restore 0618 var dummy = new CodeTypeDeclaration("Foo"); foreach (CodeTypeMember member in members) { var f = member as CodeMemberField; if (f != null) { cgInit.Invoke(generator, new object[] { sw, options }); cgFieldGen.Invoke(generator, new object[] { f }); continue; } var p = member as CodeMemberProperty; if (p != null) { cgInit.Invoke(generator, new object[] { sw, options }); cgPropGen.Invoke(generator, new object[] { p, dummy }); continue; } } }
/// <summary> /// An implementation of CodeDomProvider.GenerateCodeFromMember that works on Mono. /// </summary> public static void GenerateCodeFromMembers(this CodeDomProvider provider, CodeGeneratorOptions options, StringWriter sw, IEnumerable <CodeTypeMember> members) { if (!useMonoHack) { foreach (CodeTypeMember member in members) { provider.GenerateCodeFromMember(member, sw, options); } return; } #pragma warning disable 0618 var generator = (CodeGenerator)provider.CreateGenerator(); #pragma warning restore 0618 var dummy = new CodeTypeDeclaration("Foo"); foreach (CodeTypeMember member in members) { if (member is CodeMemberField f) { initializeCodeGenerator(generator, sw, options); cgFieldGen.Invoke(generator, new object[] { f }); continue; } if (member is CodeMemberProperty p) { initializeCodeGenerator(generator, sw, options); cgPropGen.Invoke(generator, new object[] { p, dummy }); continue; } if (member is CodeMemberMethod m) { initializeCodeGenerator(generator, sw, options); cgMethGen.Invoke(generator, new object[] { m, dummy }); continue; } } }
private static string GetPropertyTextWithGetSetLevelDebuggerNonUserCodeAttribute(CodeDomProvider provider, CodeGeneratorOptions options, StringWriter sourceWriter, CodeMemberProperty property) { provider.GenerateCodeFromMember(property, sourceWriter, options); var code = sourceWriter.ToString(); sourceWriter.GetStringBuilder().Clear(); // Clear String Builder var lines = code.Split(new[] { Environment.NewLine }, StringSplitOptions.None).ToList(); lines.RemoveAt(0); lines.RemoveAt(lines.Count - 1); for (var i = lines.Count() - 1; i >= 0; i--) { var line = lines[i]; lines[i] = "\t\t" + line; if (line.TrimStart() == "get" || line.TrimStart() == "set") { //Insert attribute above lines.Insert(i, "\t\t\t[System.Diagnostics.DebuggerNonUserCode()]"); } } return(string.Join(Environment.NewLine, lines.ToArray())); }
/// <summary> /// Generates source code from given CodeTypeMemberCollection. /// </summary> public static string GenerateFromMember(CodeDomProvider codeProvider, CodeTypeMemberCollection memberCollection, bool blankLinesBetweenMembers) { StringBuilder result = new StringBuilder(); StringWriter writer = new StringWriter(result); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BlankLinesBetweenMembers = blankLinesBetweenMembers; options.ElseOnClosing = true; options.VerbatimOrder = true; options.BracingStyle = "C"; foreach (CodeTypeMember typeMember in memberCollection) { // generate the code: codeProvider.GenerateCodeFromMember(typeMember, writer, options); // send it to the StringBuilder object: writer.Flush(); } return(result.ToString()); }
private static string GenerateCode(CodeObject c, CodeDomProvider provider) { var sb = new StringBuilder(); var writer = new StringWriter(sb); var options = new CodeGeneratorOptions(); if (c is CodeStatement) { provider.GenerateCodeFromStatement((CodeStatement)c, writer, options); } else if (c is CodeCompileUnit) { provider.GenerateCodeFromCompileUnit((CodeCompileUnit)c, writer, options); } else if (c is CodeExpression) { provider.GenerateCodeFromExpression((CodeExpression)c, writer, options); } else if (c is CodeTypeMember) { provider.GenerateCodeFromMember((CodeTypeMember)c, writer, options); } else if (c is CodeTypeDeclaration) { provider.GenerateCodeFromType((CodeTypeDeclaration)c, writer, options); } else if (c is CodeNamespace) { provider.GenerateCodeFromNamespace((CodeNamespace)c, writer, options); } else { throw new ArgumentException($"Tests not set up for unexpected type: {c.GetType()}"); } return(sb.ToString()); }
private static string GenerateCode(CodeObject c, CodeDomProvider provider) { var sb = new StringBuilder(); var writer = new StringWriter(sb); var options = new CodeGeneratorOptions(); if (c is CodeStatement) { provider.GenerateCodeFromStatement((CodeStatement)c, writer, options); } else if (c is CodeCompileUnit) { provider.GenerateCodeFromCompileUnit((CodeCompileUnit)c, writer, options); } else if (c is CodeExpression) { provider.GenerateCodeFromExpression((CodeExpression)c, writer, options); } else if (c is CodeTypeMember) { provider.GenerateCodeFromMember((CodeTypeMember)c, writer, options); } else if (c is CodeTypeDeclaration) { provider.GenerateCodeFromType((CodeTypeDeclaration)c, writer, options); } else if (c is CodeNamespace) { provider.GenerateCodeFromNamespace((CodeNamespace)c, writer, options); } else { Assert.False(true, $"Unknown type: {c.GetType()}"); } return(sb.ToString()); }
public override void ProcessDirective(string directiveName, IDictionary <string, string> arguments) { //When the Solution first opens, templateFile is null. //I wonder if that is a Bug! if (Host.TemplateFile != null && string.Compare(directiveName, "XMLDirective", StringComparison.OrdinalIgnoreCase) == 0) { string fileName; //Arguments are passed with the Key in lowercase. if (!arguments.TryGetValue("filename", out fileName)) { throw new DirectiveProcessorException("Required argument ‘FileName’ not specified."); } if (string.IsNullOrEmpty(fileName)) { throw new DirectiveProcessorException("Argument ‘FileName’ is null or empty."); } //With a little extra work we can find the path of the XML data file. string fullPath = Path.Combine(Path.GetDirectoryName(Host.TemplateFile), fileName); //Now we add code to the generated transformation class. //This directive supports either Visual Basic or C#, //so we must use the //System.CodeDom to create the code. //If a directive supports only one language, you can //hard code the code. //—————————————————————– CodeMemberField documentField = new CodeMemberField(); documentField.Name = "document" + directiveCount + "Value"; documentField.Type = new CodeTypeReference(typeof(XmlDocument)); documentField.Attributes = MemberAttributes.Private; CodeMemberProperty documentProperty = new CodeMemberProperty(); documentProperty.Name = "Document" + directiveCount; documentProperty.Type = new CodeTypeReference(typeof(XmlDocument)); documentProperty.Attributes = MemberAttributes.Public; documentProperty.HasSet = false; documentProperty.HasGet = true; CodeExpression fieldName = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), documentField.Name); CodeExpression booleanTest = new CodeBinaryOperatorExpression (fieldName, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)); CodeExpression rightSide = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("XmlReaderHelper"), "ReadXml", new CodePrimitiveExpression(fullPath)); CodeStatement[] thenSteps = new CodeStatement[] { new CodeAssignStatement(fieldName, rightSide) }; CodeConditionStatement ifThen = new CodeConditionStatement(booleanTest, thenSteps); documentProperty.GetStatements.Add(ifThen); CodeStatement s = new CodeMethodReturnStatement(fieldName); documentProperty.GetStatements.Add(s); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BlankLinesBetweenMembers = true; options.IndentString = " "; options.VerbatimOrder = true; options.BracingStyle = "C"; using (StringWriter writer = new StringWriter(codeBuffer, CultureInfo.InvariantCulture)) { codeDomProvider.GenerateCodeFromMember(documentField, writer, options); codeDomProvider.GenerateCodeFromMember(documentProperty, writer, options); } } //end XMLDirective //Track how many times the processor has been called. //—————————————————————– directiveCount++; }
public override CodeTypeMember HandleProperty(IDLInterface idlIntf, IDLProperty idlProperty) { CodeMemberProperty property = (CodeMemberProperty)base.HandleProperty(idlIntf, idlProperty); if (property.HasGet || property.HasSet) { // Generate the property out of context. CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp"); CodeGeneratorOptions genOptions = CodeBuilderHelper.getCodeGeneratorOptions(); StringWriter temp = new StringWriter(); provider.GenerateCodeFromMember(property, temp, genOptions); string propertyText = temp.ToString(); propertyText = propertyText.TrimStart(); //Get ready to store all the output StringBuilder result = new StringBuilder(); // Figure out how much comments exist before doing the real work int posSkipStatements = 0; while (posSkipStatements + 1 < propertyText.Length && propertyText[posSkipStatements] == '/' && propertyText[posSkipStatements + 1] == '/') { posSkipStatements = propertyText.IndexOf(temp.NewLine, posSkipStatements); posSkipStatements += temp.NewLine.Length; } //Insert comments into output if (posSkipStatements > 0) { result.Append(propertyText.Substring(0, posSkipStatements)); propertyText = propertyText.Substring(posSkipStatements); } //Remove abstract modifiers const string abstractName = "abstract "; if (propertyText.StartsWith(abstractName)) { propertyText = propertyText.Substring(abstractName.Length); } // Hacky rewrite of the getter/setter for CSharp. if (property.HasGet) { propertyText = AddOperationContractToProperty(propertyText, "get;", temp.NewLine); } if (property.HasSet) { propertyText = AddOperationContractToProperty(propertyText, "set;", temp.NewLine); } // Add the altered text. result.Append(propertyText); // Mess around with padding. string resultText = result.ToString(); resultText = resultText.Replace(temp.NewLine, temp.NewLine + " "); resultText = " " + resultText; // Add the snippet. CodeSnippetTypeMember snipProperty = new CodeSnippetTypeMember(resultText); snipProperty.Name = property.Name; return(snipProperty); } else { return(property); } }
protected override void ProcessRecord() { if (CompileUnit != null && CompileUnit.Length > 0) { foreach (CodeCompileUnit compileUnit in CompileUnit) { if (compileUnit != null) { _provider.GenerateCodeFromCompileUnit(compileUnit, _indentedWriter, Options); } } } else if (Expression != null && Expression.Length > 0) { foreach (CodeExpression expr in Expression) { if (expr != null) { _provider.GenerateCodeFromExpression(expr, _indentedWriter, Options); } } } else if (Member != null && Member.Length > 0) { foreach (CodeTypeMember member in Member) { if (member != null) { _provider.GenerateCodeFromMember(member, _indentedWriter, Options); } } } else if (NS != null && NS.Length > 0) { foreach (CodeNamespace ns in NS) { if (ns != null) { _provider.GenerateCodeFromNamespace(ns, _indentedWriter, Options); } } } else if (Statement != null && Statement.Length > 0) { foreach (CodeStatement st in Statement) { if (st != null) { _provider.GenerateCodeFromStatement(st, _indentedWriter, Options); } } } else if (Type != null && Type.Length > 0) { foreach (CodeTypeDeclaration t in Type) { if (t != null) { _provider.GenerateCodeFromType(t, _indentedWriter, Options); } } } }
/// <summary> /// Generates the GetEntityState helper method that allows POCO types to retrieve their /// entity state from the contect. It is not available on the POCO types directly. /// </summary> /// <param name="codeGenContext">The context in which we are generating code.</param> /// <param name="businessLogicClass">The class we are generating.</param> /// <returns>The <see cref="CodeTypeMember"/> containing the helper method.</returns> private static CodeTypeMember GenerateGetEntityState(CodeGenContext codeGenContext, CodeTypeDeclaration businessLogicClass) { // Add an import for System.Data.Objects CodeNamespace codeNamespace = codeGenContext.GetNamespace(businessLogicClass); if (codeNamespace != null) { codeNamespace.Imports.Add(new CodeNamespaceImport("System.Data.Entity.Core.Objects")); } //private EntityState GetEntityState(object entity) //{ // ObjectStateEntry stateEntry = null; // if (!this.ObjectContext.ObjectStateManager.TryGetObjectStateEntry(entity, out stateEntry)) // { // return EntityState.Detached; // } // return stateEntry.State; //} // Declaration CodeMemberMethod method = new CodeMemberMethod(); method.Name = LinqToEntitiesContext.GetEntityStateHelperMethodName; method.ReturnType = new CodeTypeReference(typeof(EntityState).Name); method.Attributes = MemberAttributes.Private; method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "entity")); // ObjectStateEntry stateEntry = null; method.Statements.Add(new CodeVariableDeclarationStatement("ObjectStateEntry", "stateEntry", new CodePrimitiveExpression(null))); CodeArgumentReferenceExpression entityArgRef = new CodeArgumentReferenceExpression("entity"); CodeExpression contextRef = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "ObjectContext"); CodeFieldReferenceExpression detachedStateRef = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(EntityState).Name), Enum.GetName(typeof(EntityState), EntityState.Detached)); CodePropertyReferenceExpression objectStateMgrRef = new CodePropertyReferenceExpression(contextRef, "ObjectStateManager"); CodeVariableReferenceExpression entityStateRef = new CodeVariableReferenceExpression("stateEntry"); // The "_out_" prefix will be replaced below with the language-appropriate modifier to make an out param. // CodeDom does not support this, so we must do some string manipulation CodeVariableReferenceExpression outEntityStateRef = new CodeVariableReferenceExpression("_out_stateEntry"); // this.ObjectContext.ObjectStateManager.TryGetObjectStateEntry(entity, out stateEntry) CodeMethodInvokeExpression getObjectStateEntryCall = new CodeMethodInvokeExpression(objectStateMgrRef, "TryGetObjectStateEntry", entityArgRef, outEntityStateRef); // if (...TryGet()) CodeExpression tryGetTest = CodeGenUtilities.MakeEqual(typeof(bool), getObjectStateEntryCall, new CodePrimitiveExpression(false), codeGenContext.IsCSharp); // if (...TryGet..) { return EntityState.Detached; } CodeMethodReturnStatement returnDetached = new CodeMethodReturnStatement(detachedStateRef); CodeConditionStatement ifTryGet = new CodeConditionStatement(tryGetTest, returnDetached); method.Statements.Add(ifTryGet); // Return entityState.State; method.Statements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(entityStateRef, "State"))); // CodeDom does not support specifying 'out' parameters at the method call site. // So convert the entire method into a snippet of text StringBuilder snippet = null; CodeDomProvider provider = codeGenContext.Provider; using (StringWriter snippetWriter = new StringWriter(System.Globalization.CultureInfo.CurrentCulture)) { provider.GenerateCodeFromMember(method, snippetWriter, codeGenContext.CodeGeneratorOptions); snippet = snippetWriter.GetStringBuilder(); } // Our convention above is that "_out_" will be replaced by the language-appropriate "out" parameter modifier. // In the case of VB, it is the default snippet.Replace("_out_", codeGenContext.IsCSharp ? "out " : string.Empty); // We need to indent the entire snippet 2 levels string indent = codeGenContext.CodeGeneratorOptions.IndentString; indent += indent; string snippetText = indent + snippet.ToString().Replace(Environment.NewLine, Environment.NewLine + indent).TrimEnd(' '); CodeSnippetTypeMember methodAsText = new CodeSnippetTypeMember(snippetText); return(methodAsText); }