public void GenerateProperties() { List<CodeMemberMethod> methods = type.Members.OfType<CodeMemberMethod>().ToList(); this.GenerateProperties(methods, this.setters, false); this.GenerateProperties(methods, this.setMethods, true); foreach (CodeMemberMethod getter in from getter in this.getters where this.type.Members.Contains(getter) && !this.type.Members.OfType<CodeMemberMethod>().Any(m => m != getter && m.Name == getter.Name) select getter) { // Make it a read-only property if (this.type.IsInterface) { CodeSnippetTypeMember property = new CodeSnippetTypeMember(); property.Name = getter.Name; property.Text = string.Format(" {0} {1} {{ get; }}", getter.ReturnType.BaseType, getter.Name); property.Comments.AddRange(getter.Comments); this.type.Members.Add(property); this.type.Members.Remove(getter); } else { this.GenerateProperty(getter); } } }
/// <summary>生成成员代码块</summary> /// <param name="block"></param> /// <param name="generatorType"></param> /// <param name="lineNumbers"></param> /// <param name="provider"></param> /// <param name="options"></param> /// <param name="firstMemberFound"></param> /// <returns></returns> private static Boolean GenerateMemberForBlock(Block block, CodeTypeDeclaration generatorType, Boolean lineNumbers, CodeDomProvider provider, CodeGeneratorOptions options, Boolean firstMemberFound) { CodeSnippetTypeMember member = null; if (!firstMemberFound) { // 发现第一个<#!后,认为是类成员代码的开始,直到下一个<#!作为结束 if (block.Type == BlockType.Member) { firstMemberFound = true; if (!String.IsNullOrEmpty(block.Text)) { member = new CodeSnippetTypeMember(block.Text); } } } else { // 再次遇到<#!,此时,成员代码准备结束 if (block.Type == BlockType.Member) { firstMemberFound = false; if (!String.IsNullOrEmpty(block.Text)) { member = new CodeSnippetTypeMember(block.Text); } } else if (block.Type == BlockType.Text) { var expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Write", new CodeExpression[] { new CodePrimitiveExpression(block.Text) }); var statement = new CodeExpressionStatement(expression); using (var writer = new StringWriter()) { provider.GenerateCodeFromStatement(statement, writer, options); member = new CodeSnippetTypeMember(writer.ToString()); } } else if (block.Type == BlockType.Expression) { var expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Write", new CodeExpression[] { new CodeArgumentReferenceExpression(block.Text.Trim()) }); var statement = new CodeExpressionStatement(expression); using (var writer = new StringWriter()) { provider.GenerateCodeFromStatement(statement, writer, options); member = new CodeSnippetTypeMember(writer.ToString()); } } else if (block.Type == BlockType.Statement) { member = new CodeSnippetTypeMember(block.Text); } } if (member != null) { if (lineNumbers) { var flag = String.IsNullOrEmpty(block.Name); var lineNumber = (block.StartLine > 0) ? block.StartLine : 1; if (flag) { generatorType.Members.Add(new CodeSnippetTypeMember("#line " + lineNumber)); } else { member.LinePragma = new CodeLinePragma(block.Name, lineNumber); } generatorType.Members.Add(member); if (flag) { generatorType.Members.Add(new CodeSnippetTypeMember("#line default")); } } else { generatorType.Members.Add(member); } } return(firstMemberFound); }
public void RegionsSnippetsAndLinePragmas() { var cu = new CodeCompileUnit(); CodeNamespace ns = new CodeNamespace("Namespace1"); cu.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Compile Unit Region")); cu.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); cu.Namespaces.Add(ns); var cd = new CodeTypeDeclaration("Class1"); ns.Types.Add(cd); cd.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Outer Type Region")); cd.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); cd.Comments.Add(new CodeCommentStatement("Outer Type Comment")); CodeMemberField field1 = new CodeMemberField(typeof(String), "field1"); CodeMemberField field2 = new CodeMemberField(typeof(String), "field2"); field1.Comments.Add(new CodeCommentStatement("Field 1 Comment")); field2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Field Region")); field2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeMemberEvent evt1 = new CodeMemberEvent(); evt1.Name = "Event1"; evt1.Type = new CodeTypeReference(typeof(System.EventHandler)); evt1.Attributes = (evt1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; CodeMemberEvent evt2 = new CodeMemberEvent(); evt2.Name = "Event2"; evt2.Type = new CodeTypeReference(typeof(System.EventHandler)); evt2.Attributes = (evt2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; evt2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Event Region")); evt2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeMemberMethod method1 = new CodeMemberMethod(); method1.Name = "Method1"; method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; method1.Statements.Add( new CodeDelegateInvokeExpression( new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "Event1"), new CodeExpression[] { new CodeThisReferenceExpression(), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty") })); CodeMemberMethod method2 = new CodeMemberMethod(); method2.Name = "Method2"; method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; method2.Statements.Add( new CodeDelegateInvokeExpression( new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "Event2"), new CodeExpression[] { new CodeThisReferenceExpression(), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty") })); method2.LinePragma = new CodeLinePragma("MethodLinePragma.txt", 500); method2.Comments.Add(new CodeCommentStatement("Method 2 Comment")); method2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Method Region")); method2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeMemberProperty property1 = new CodeMemberProperty(); property1.Name = "Property1"; property1.Type = new CodeTypeReference(typeof(string)); property1.Attributes = (property1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; property1.GetStatements.Add( new CodeMethodReturnStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "field1"))); CodeMemberProperty property2 = new CodeMemberProperty(); property2.Name = "Property2"; property2.Type = new CodeTypeReference(typeof(string)); property2.Attributes = (property2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; property2.GetStatements.Add( new CodeMethodReturnStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "field2"))); property2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Property Region")); property2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeConstructor constructor1 = new CodeConstructor(); constructor1.Attributes = (constructor1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; CodeStatement conState1 = new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "field1"), new CodePrimitiveExpression("value1")); conState1.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Statements Region")); constructor1.Statements.Add(conState1); CodeStatement conState2 = new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "field2"), new CodePrimitiveExpression("value2")); conState2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); constructor1.Statements.Add(conState2); constructor1.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Constructor Region")); constructor1.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeConstructor constructor2 = new CodeConstructor(); constructor2.Attributes = (constructor2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; constructor2.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "value1")); constructor2.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "value2")); CodeTypeConstructor typeConstructor2 = new CodeTypeConstructor(); typeConstructor2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Type Constructor Region")); typeConstructor2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeEntryPointMethod methodMain = new CodeEntryPointMethod(); CodeTypeDeclaration nestedClass1 = new CodeTypeDeclaration("NestedClass1"); CodeTypeDeclaration nestedClass2 = new CodeTypeDeclaration("NestedClass2"); nestedClass2.LinePragma = new CodeLinePragma("NestedTypeLinePragma.txt", 400); nestedClass2.Comments.Add(new CodeCommentStatement("Nested Type Comment")); nestedClass2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Nested Type Region")); nestedClass2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeTypeDelegate delegate1 = new CodeTypeDelegate(); delegate1.Name = "nestedDelegate1"; delegate1.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"), "sender")); delegate1.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.EventArgs"), "e")); CodeTypeDelegate delegate2 = new CodeTypeDelegate(); delegate2.Name = "nestedDelegate2"; delegate2.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"), "sender")); delegate2.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.EventArgs"), "e")); delegate2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Delegate Region")); delegate2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); var snippet1 = new CodeSnippetTypeMember(); var snippet2 = new CodeSnippetTypeMember(); CodeRegionDirective regionStart = new CodeRegionDirective(CodeRegionMode.End, ""); regionStart.RegionText = "Snippet Region"; regionStart.RegionMode = CodeRegionMode.Start; snippet2.StartDirectives.Add(regionStart); snippet2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); cd.Members.Add(field1); cd.Members.Add(method1); cd.Members.Add(constructor1); cd.Members.Add(property1); cd.Members.Add(methodMain); cd.Members.Add(evt1); cd.Members.Add(nestedClass1); cd.Members.Add(delegate1); cd.Members.Add(snippet1); cd.Members.Add(field2); cd.Members.Add(method2); cd.Members.Add(constructor2); cd.Members.Add(property2); cd.Members.Add(typeConstructor2); cd.Members.Add(evt2); cd.Members.Add(nestedClass2); cd.Members.Add(delegate2); cd.Members.Add(snippet2); AssertEqual(cu, @"#region Compile Unit Region //------------------------------------------------------------------------------ // <auto-generated> // This code was generated by a tool. // Runtime Version:4.0.30319.42000 // // Changes to this file may cause incorrect behavior and will be lost if // the code is regenerated. // </auto-generated> //------------------------------------------------------------------------------ namespace Namespace1 { #region Outer Type Region // Outer Type Comment public class Class1 { // Field 1 Comment private string field1; #region Field Region private string field2; #endregion #region Snippet Region #endregion #region Type Constructor Region static Class1() { } #endregion #region Constructor Region public Class1() { #region Statements Region this.field1 = ""value1""; this.field2 = ""value2""; #endregion } #endregion public Class1(string value1, string value2) { } public string Property1 { get { return this.field1; } } #region Property Region public string Property2 { get { return this.field2; } } #endregion public event System.EventHandler Event1; #region Event Region public event System.EventHandler Event2; #endregion public void Method1() { this.Event1(this, System.EventArgs.Empty); } public static void Main() { } #region Method Region // Method 2 Comment #line 500 ""MethodLinePragma.txt"" public void Method2() { this.Event2(this, System.EventArgs.Empty); } #line default #line hidden #endregion public class NestedClass1 { } public delegate void nestedDelegate1(object sender, System.EventArgs e); #region Nested Type Region // Nested Type Comment #line 400 ""NestedTypeLinePragma.txt"" public class NestedClass2 { } #line default #line hidden #endregion #region Delegate Region public delegate void nestedDelegate2(object sender, System.EventArgs e); #endregion } #endregion } #endregion"); }
public void PostMembersHook(Smoke* smoke, Smoke.Class* klass, CodeTypeDeclaration type) { if (Util.IsQObject(klass)) { CodeMemberProperty emit = new CodeMemberProperty(); emit.Name = "Emit"; emit.Attributes = MemberAttributes.Family | MemberAttributes.New | MemberAttributes.Final; emit.HasGet = true; emit.HasSet = false; string signalsIfaceName = "I" + type.Name + "Signals"; CodeTypeReference returnType = new CodeTypeReference(signalsIfaceName); emit.Type = returnType; emit.GetStatements.Add(new CodeMethodReturnStatement(new CodeCastExpression( returnType, new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Q_EMIT") ))); type.Members.Add(emit); string className = ByteArrayManager.GetString(klass->className); int colon = className.LastIndexOf("::", StringComparison.Ordinal); string prefix = (colon != -1) ? className.Substring(0, colon) : string.Empty; IList typeCollection = Data.GetTypeCollection(prefix); CodeTypeDeclaration ifaceDecl = new CodeTypeDeclaration(signalsIfaceName); ifaceDecl.IsInterface = true; if (className != "QObject") { string parentClassName = ByteArrayManager.GetString(smoke->classes[smoke->inheritanceList[klass->parents]].className); colon = parentClassName.LastIndexOf("::", StringComparison.Ordinal); prefix = (colon != -1) ? parentClassName.Substring(0, colon) : string.Empty; if (colon != -1) { parentClassName = parentClassName.Substring(colon + 2); } string parentInterface = (prefix != string.Empty) ? prefix.Replace("::", ".") + "." : string.Empty; parentInterface += "I" + parentClassName + "Signals"; ifaceDecl.BaseTypes.Add(new CodeTypeReference(parentInterface)); } Dictionary<CodeSnippetTypeMember, CodeMemberMethod> signalEvents = new Dictionary<CodeSnippetTypeMember, CodeMemberMethod>(); GetSignals(smoke, klass, delegate(string signature, string name, string typeName, IntPtr metaMethod) { CodeMemberMethod signal = new CodeMemberMethod(); signal.Attributes = MemberAttributes.Abstract; // capitalize the first letter StringBuilder builder = new StringBuilder(name); builder[0] = char.ToUpper(builder[0]); string tmp = builder.ToString(); signal.Name = tmp; bool isRef; try { if (typeName == string.Empty) signal.ReturnType = new CodeTypeReference(typeof(void)); else signal.ReturnType = Translator.CppToCSharp(typeName, out isRef); } catch (NotSupportedException) { Debug.Print(" |--Won't wrap signal {0}::{1}", className, signature); return; } CodeAttributeDeclaration attr = new CodeAttributeDeclaration("Q_SIGNAL", new CodeAttributeArgument(new CodePrimitiveExpression(signature))); signal.CustomAttributes.Add(attr); int argNum = 1; StringBuilder fullNameBuilder = new StringBuilder("Slot"); GetMetaMethodParameters(metaMethod, delegate(string paramType, string paramName) { if (paramName == string.Empty) { paramName = "arg" + argNum.ToString(); } argNum++; CodeParameterDeclarationExpression param; try { short id = smoke->IDType(paramType); CodeTypeReference paramTypeRef; if (id > 0) { paramTypeRef = Translator.CppToCSharp(smoke->types + id, out isRef); } else { if (!paramType.Contains("::")) { id = smoke->IDType(className + "::" + paramType); if (id > 0) { paramTypeRef = Translator.CppToCSharp(smoke->types + id, out isRef); } else { paramTypeRef = Translator.CppToCSharp(paramType, out isRef); } } else { paramTypeRef = Translator.CppToCSharp(paramType, out isRef); } } param = new CodeParameterDeclarationExpression(paramTypeRef, paramName); } catch (NotSupportedException) { Debug.Print(" |--Won't wrap signal {0}::{1}", className, signature); return; } if (isRef) { param.Direction = FieldDirection.Ref; } signal.Parameters.Add(param); if (argNum == 2) { fullNameBuilder.Append('<'); } fullNameBuilder.Append(param.Type.BaseType); fullNameBuilder.Append(','); }); if (fullNameBuilder[fullNameBuilder.Length - 1] == ',') { fullNameBuilder[fullNameBuilder.Length - 1] = '>'; } ifaceDecl.Members.Add(signal); CodeSnippetTypeMember signalEvent = new CodeSnippetTypeMember(); signalEvent.Name = signal.Name; CodeSnippetTypeMember existing = signalEvents.Keys.FirstOrDefault(m => m.Name == signal.Name); if (existing != null) { CodeSnippetTypeMember signalEventToUse; CodeMemberMethod signalToUse; if (signal.Parameters.Count == 0) { signalEventToUse = existing; signalToUse = signalEvents[existing]; } else { signalEventToUse = signalEvent; signalToUse = signal; } string suffix = signalToUse.Parameters.Cast<CodeParameterDeclarationExpression>().Last().Name; if (suffix.StartsWith("arg") && suffix.Length > 3 && char.IsDigit(suffix[3])) { string lastType = signalToUse.Parameters.Cast<CodeParameterDeclarationExpression>().Last().Type.BaseType; suffix = lastType.Substring(lastType.LastIndexOf('.') + 1); } else { StringBuilder lastParamBuilder = new StringBuilder(suffix); lastParamBuilder[0] = char.ToUpper(lastParamBuilder[0]); suffix = lastParamBuilder.ToString(); } signalEventToUse.Text = signalEventToUse.Text.Replace(signalEventToUse.Name, signalEventToUse.Name += suffix); } signalEvent.Text = string.Format(@" public event {0} {1} {{ add {{ QObject.Connect(this, Qt.SIGNAL(""{2}""), (QObject) value.Target, Qt.SLOT(value.Method.Name + ""{3}"")); }} remove {{ QObject.Disconnect(this, Qt.SIGNAL(""{2}""), (QObject) value.Target, Qt.SLOT(value.Method.Name + ""{3}"")); }} }}", fullNameBuilder, signalEvent.Name, signature, signature.Substring(signature.IndexOf('('))); signalEvents.Add(signalEvent, signal); }); typeCollection.Add(ifaceDecl); foreach (KeyValuePair<CodeSnippetTypeMember, CodeMemberMethod> signalEvent in signalEvents) { CodeSnippetTypeMember implementation = signalEvent.Key; CodeCommentStatementCollection comments = new CodeCommentStatementCollection(); foreach (CodeTypeMember current in from CodeTypeMember member in type.Members where member.Name == implementation.Name select member) { if (comments.Count == 0) { comments.AddRange(current.Comments); } current.Name = "On" + current.Name; } signalEvent.Value.Comments.AddRange(comments); signalEvent.Key.Comments.AddRange(comments); type.Members.Add(signalEvent.Key); } } }
public void RegionsSnippetsAndLinePragmas() { CodeCompileUnit cu = new CodeCompileUnit(); CodeNamespace ns = new CodeNamespace("Namespace1"); cu.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Compile Unit Region")); cu.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); cu.Namespaces.Add(ns); CodeTypeDeclaration cd = new CodeTypeDeclaration("Class1"); ns.Types.Add(cd); cd.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Outer Type Region")); cd.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); cd.Comments.Add(new CodeCommentStatement("Outer Type Comment")); CodeMemberField field1 = new CodeMemberField(typeof(String), "field1"); CodeMemberField field2 = new CodeMemberField(typeof(String), "field2"); field1.Comments.Add(new CodeCommentStatement("Field 1 Comment")); field2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Field Region")); field2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeMemberEvent evt1 = new CodeMemberEvent(); evt1.Name = "Event1"; evt1.Type = new CodeTypeReference(typeof(System.EventHandler)); evt1.Attributes = (evt1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; CodeMemberEvent evt2 = new CodeMemberEvent(); evt2.Name = "Event2"; evt2.Type = new CodeTypeReference(typeof(System.EventHandler)); evt2.Attributes = (evt2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; evt2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Event Region")); evt2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeMemberMethod method1 = new CodeMemberMethod(); method1.Name = "Method1"; method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; method1.Statements.Add( new CodeDelegateInvokeExpression( new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "Event1"), new CodeExpression[] { new CodeThisReferenceExpression(), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty") })); CodeMemberMethod method2 = new CodeMemberMethod(); method2.Name = "Method2"; method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; method2.Statements.Add( new CodeDelegateInvokeExpression( new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "Event2"), new CodeExpression[] { new CodeThisReferenceExpression(), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty") })); method2.LinePragma = new CodeLinePragma("MethodLinePragma.txt", 500); method2.Comments.Add(new CodeCommentStatement("Method 2 Comment")); method2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Method Region")); method2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeMemberProperty property1 = new CodeMemberProperty(); property1.Name = "Property1"; property1.Type = new CodeTypeReference(typeof(string)); property1.Attributes = (property1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; property1.GetStatements.Add( new CodeMethodReturnStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "field1"))); CodeMemberProperty property2 = new CodeMemberProperty(); property2.Name = "Property2"; property2.Type = new CodeTypeReference(typeof(string)); property2.Attributes = (property2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; property2.GetStatements.Add( new CodeMethodReturnStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "field2"))); property2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Property Region")); property2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeConstructor constructor1 = new CodeConstructor(); constructor1.Attributes = (constructor1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; CodeStatement conState1 = new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "field1"), new CodePrimitiveExpression("value1")); conState1.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Statements Region")); constructor1.Statements.Add(conState1); CodeStatement conState2 = new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "field2"), new CodePrimitiveExpression("value2")); conState2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); constructor1.Statements.Add(conState2); constructor1.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Constructor Region")); constructor1.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeConstructor constructor2 = new CodeConstructor(); constructor2.Attributes = (constructor2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; constructor2.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "value1")); constructor2.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "value2")); CodeTypeConstructor typeConstructor2 = new CodeTypeConstructor(); typeConstructor2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Type Constructor Region")); typeConstructor2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeEntryPointMethod methodMain = new CodeEntryPointMethod(); CodeTypeDeclaration nestedClass1 = new CodeTypeDeclaration("NestedClass1"); CodeTypeDeclaration nestedClass2 = new CodeTypeDeclaration("NestedClass2"); nestedClass2.LinePragma = new CodeLinePragma("NestedTypeLinePragma.txt", 400); nestedClass2.Comments.Add(new CodeCommentStatement("Nested Type Comment")); nestedClass2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Nested Type Region")); nestedClass2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); CodeTypeDelegate delegate1 = new CodeTypeDelegate(); delegate1.Name = "nestedDelegate1"; delegate1.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"), "sender")); delegate1.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.EventArgs"), "e")); CodeTypeDelegate delegate2 = new CodeTypeDelegate(); delegate2.Name = "nestedDelegate2"; delegate2.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"), "sender")); delegate2.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.EventArgs"), "e")); delegate2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Delegate Region")); delegate2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); var snippet1 = new CodeSnippetTypeMember(); var snippet2 = new CodeSnippetTypeMember(); CodeRegionDirective regionStart = new CodeRegionDirective(CodeRegionMode.End, ""); regionStart.RegionText = "Snippet Region"; regionStart.RegionMode = CodeRegionMode.Start; snippet2.StartDirectives.Add(regionStart); snippet2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); cd.Members.Add(field1); cd.Members.Add(method1); cd.Members.Add(constructor1); cd.Members.Add(property1); cd.Members.Add(methodMain); cd.Members.Add(evt1); cd.Members.Add(nestedClass1); cd.Members.Add(delegate1); cd.Members.Add(snippet1); cd.Members.Add(field2); cd.Members.Add(method2); cd.Members.Add(constructor2); cd.Members.Add(property2); cd.Members.Add(typeConstructor2); cd.Members.Add(evt2); cd.Members.Add(nestedClass2); cd.Members.Add(delegate2); cd.Members.Add(snippet2); AssertEqual(cu, @"#Region ""Compile Unit Region"" '------------------------------------------------------------------------------ ' <auto-generated> ' This code was generated by a tool. ' Runtime Version:4.0.30319.42000 ' ' Changes to this file may cause incorrect behavior and will be lost if ' the code is regenerated. ' </auto-generated> '------------------------------------------------------------------------------ Option Strict Off Option Explicit On Namespace Namespace1 #Region ""Outer Type Region"" 'Outer Type Comment Public Class Class1 'Field 1 Comment Private field1 As String #Region ""Field Region"" Private field2 As String #End Region #Region ""Snippet Region"" #End Region #Region ""Type Constructor Region"" Shared Sub New() End Sub #End Region #Region ""Constructor Region"" Public Sub New() MyBase.New Me.field1 = ""value1"" Me.field2 = ""value2"" End Sub #End Region Public Sub New(ByVal value1 As String, ByVal value2 As String) MyBase.New End Sub Public ReadOnly Property Property1() As String Get Return Me.field1 End Get End Property #Region ""Property Region"" Public ReadOnly Property Property2() As String Get Return Me.field2 End Get End Property #End Region Public Event Event1 As System.EventHandler #Region ""Event Region"" Public Event Event2 As System.EventHandler #End Region Public Sub Method1() RaiseEvent Event1(Me, System.EventArgs.Empty) End Sub Public Shared Sub Main() End Sub #Region ""Method Region"" 'Method 2 Comment #ExternalSource(""MethodLinePragma.txt"",500) Public Sub Method2() RaiseEvent Event2(Me, System.EventArgs.Empty) End Sub #End ExternalSource #End Region Public Class NestedClass1 End Class Public Delegate Sub nestedDelegate1(ByVal sender As Object, ByVal e As System.EventArgs) #Region ""Nested Type Region"" 'Nested Type Comment #ExternalSource(""NestedTypeLinePragma.txt"",400) Public Class NestedClass2 End Class #End ExternalSource #End Region #Region ""Delegate Region"" Public Delegate Sub nestedDelegate2(ByVal sender As Object, ByVal e As System.EventArgs) #End Region End Class #End Region End Namespace #End Region"); }
private void GenerateProperties(ICollection<CodeMemberMethod> methods, IEnumerable<CodeMemberMethod> settersToUse, bool readOnly) { foreach (CodeMemberMethod setter in settersToUse) { if (!this.type.Members.Contains(setter)) { continue; } string afterSet = setter.Name.Substring(3); for (int i = this.nonSetters.Count - 1; i >= 0; i--) { CodeMemberMethod getter = this.nonSetters[i]; if (!this.type.Members.Contains(getter)) { continue; } if (string.Compare(getter.Name, afterSet, StringComparison.OrdinalIgnoreCase) == 0 && getter.ReturnType.BaseType == setter.Parameters[0].Type.BaseType && !methods.Any(m => m != getter && string.Compare(getter.Name, m.Name, StringComparison.OrdinalIgnoreCase) == 0)) { methods.Remove(getter); if (this.type.IsInterface) { CodeSnippetTypeMember property = new CodeSnippetTypeMember(); property.Name = getter.Name; string template = readOnly ? " {0} {1} {{ get; }}" : " {0} {1} {{ get; set; }}"; property.Text = string.Format(template, getter.ReturnType.BaseType, getter.Name); CodeCommentStatementCollection comments = new CodeCommentStatementCollection(getter.Comments); if (!readOnly) { comments.AddRange(setter.Comments); } AddComments(property, comments, readOnly); this.type.Members.Add(property); this.type.Members.Remove(getter); if (!readOnly) { this.type.Members.Remove(setter); } } else { this.GenerateProperty(getter, readOnly ? null : setter); } goto next; } } CodeTypeMember baseVirtualProperty = this.GetBaseVirtualProperty(this.type, afterSet); if (!this.type.IsInterface && baseVirtualProperty != null) { CodeMemberMethod getter = new CodeMemberMethod { Name = baseVirtualProperty.Name }; getter.ReturnType = setter.Parameters[0].Type; getter.Statements.Add(new CodeSnippetStatement(string.Format(" return base.{0};", afterSet))); this.GenerateProperty(getter, readOnly ? null : setter); } next: ; } foreach (CodeMemberMethod nonSetter in this.nonSetters) { CodeTypeMember baseVirtualProperty = this.GetBaseVirtualProperty(this.type, nonSetter.Name); if (!this.type.IsInterface && baseVirtualProperty != null) { bool isReadOnly = (baseVirtualProperty is CodeMemberProperty && !((CodeMemberProperty) baseVirtualProperty).HasSet) || !regexPropertySetter.IsMatch(((CodeSnippetTypeMember) baseVirtualProperty).Text); if (readOnly == isReadOnly) { CodeMemberMethod setter = new CodeMemberMethod { Name = baseVirtualProperty.Name }; setter.Statements.Add(new CodeSnippetStatement(string.Format(" base.{0} = value;", nonSetter.Name))); this.GenerateProperty(nonSetter, readOnly ? null : setter); } } } }
protected override void GenerateSnippetMember (CodeSnippetTypeMember e) { Output.Write(e.Text); }
public static CodeTypeDeclaration AddMethod(this CodeTypeDeclaration classCode, CodeSnippetTypeMember methodBody) { classCode.Members.Add(methodBody); return(classCode); }
protected override void GenerateSnippetMember(CodeSnippetTypeMember e) { }
/// <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(ICodeGenContext 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.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); }
internal static void ProcessDefTag(WorkflowMarkupSerializationManager serializationManager, XmlReader reader, Activity activity, bool newSegment, string fileName) { ResourceManager manager = new ResourceManager("System.Workflow.ComponentModel.StringResources", typeof(ActivityBind).Assembly); if (reader.NodeType == XmlNodeType.Attribute) { string str; if (((str = reader.LocalName) != null) && (str == "Class")) { activity.SetValue(WorkflowMarkupSerializer.XClassProperty, reader.Value); } else { serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, manager.GetString("UnknownDefinitionTag"), new object[] { "x", reader.LocalName, "http://schemas.microsoft.com/winfx/2006/xaml" }), (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1)); } } else { bool flag = false; bool isEmptyElement = reader.IsEmptyElement; int depth = reader.Depth; do { switch (reader.NodeType) { case XmlNodeType.Element: { string localName = reader.LocalName; if (localName != null) { if (localName == "Code") { if (isEmptyElement) { flag = true; } break; } bool flag1 = localName == "Constructor"; } serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, manager.GetString("UnknownDefinitionTag"), new object[] { "x", reader.LocalName, "http://schemas.microsoft.com/winfx/2006/xaml" }), (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1)); return; } case XmlNodeType.Text: case XmlNodeType.CDATA: { int num2 = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1; int num3 = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1; CodeSnippetTypeMember member = new CodeSnippetTypeMember(reader.Value) { LinePragma = new CodeLinePragma(fileName, Math.Max(num2 - 1, 1)) }; member.UserData[UserDataKeys.CodeSegment_New] = newSegment; member.UserData[UserDataKeys.CodeSegment_ColumnNumber] = (num3 + reader.Name.Length) - 1; CodeTypeMemberCollection members = activity.GetValue(WorkflowMarkupSerializer.XCodeProperty) as CodeTypeMemberCollection; if (members == null) { members = new CodeTypeMemberCollection(); activity.SetValue(WorkflowMarkupSerializer.XCodeProperty, members); } members.Add(member); break; } case XmlNodeType.EndElement: if (reader.Depth == depth) { flag = true; } break; } }while (!flag && reader.Read()); } }
/// <summary> /// Generates the binding path. /// </summary> /// <param name="propertyPath">The property path.</param> /// <param name="mode">The mode.</param> /// <returns></returns> /// <exception cref="System.ArgumentNullException">Namespace is empty.</exception> public bool GenerateBindingPath(PropertyPath propertyPath, GeneratedBindingsMode mode) { if (ActiveDataType == null || !IsEnabled) { return(false); } if (ns == null) { throw new ArgumentNullException("Namespace is empty."); } Type dataType = ActiveDataType; if (dataType.IsPrimitive) { return(false); } string path = propertyPath.Path; string[] pathParts = path.Split(partSeparator, StringSplitOptions.RemoveEmptyEntries); bool isCollectionProperty = false; for (int i = 0; i < pathParts.Length; i++) { string propertyName = pathParts[i]; int indexStart = propertyName.IndexOfAny(indexStartChars); if (indexStart != -1) { propertyName = propertyName.Substring(0, indexStart); } PropertyInfo propertyInfo = dataType.GetRuntimeProperty(propertyName); int paramStart = propertyName.IndexOfAny(paramStartChars); if (paramStart != -1) { int paramEnd = propertyName.IndexOfAny(paramEndChars); string paramIndexString = propertyName.Substring(paramStart + 1, paramEnd - paramStart - 1).Trim(); int paramIndex = Convert.ToInt32(paramIndexString); propertyInfo = propertyPath.PathParameters[paramIndex] as PropertyInfo; if (propertyInfo != null) { propertyName = propertyInfo.Name; dataType = propertyInfo.ReflectedType; } } string className = string.Format("{0}_{1}_PropertyInfo", dataType.Name, propertyName); className = Regex.Replace(className, "[`|<|>]", ""); CodeTypeDeclaration classType = CreateClass(className); if (propertyInfo == null) { // if mixed mode return with false (binding was not generated) but don't generate error so reflection can be used if (mode == GeneratedBindingsMode.Mixed) { return(false); } CodeSnippetTypeMember error = new CodeSnippetTypeMember(string.Format("#error {0} type does not have property {1}", dataType, propertyName)); classType.Members.Add(error); ns.Types.Add(classType); return(false); } isCollectionProperty = propertyInfo.PropertyType.IsArray || (typeof(IEnumerable).IsAssignableFrom(propertyInfo.PropertyType) && propertyInfo.PropertyType != typeof(string)); Type elementType = propertyInfo.PropertyType.GetElementType(); if (elementType == null && propertyInfo.PropertyType.IsGenericType) { elementType = propertyInfo.PropertyType.GetGenericArguments()[0]; } int key = propertyName.GetHashCode() ^ dataType.GetHashCode(); if (!generated.Contains(key)) { generated.Add(key); ns.Types.Add(classType); GenerateProperties(classType, propertyInfo); GenerateMethods(dataType, isCollectionProperty, propertyName, classType, propertyInfo, elementType); propertyInfos.Add(new Tuple <Type, string, string>(dataType, propertyName, ns.Name + "." + className)); } if (isCollectionProperty) { dataType = elementType; } else { dataType = propertyInfo.PropertyType; } } return(true); }
/// <summary> /// Create the code as codedom structure. /// </summary> private CodeCompileUnit CreateCompileUnit(string packageName, string generatedCodeNamespace) { if (string.IsNullOrEmpty(generatedCodeNamespace)) generatedCodeNamespace = packageName; var compileUnit = new CodeCompileUnit(); var pkgNamespace = new CodeNamespace(generatedCodeNamespace); compileUnit.Namespaces.Add(pkgNamespace); pkgNamespace.Imports.Add(new CodeNamespaceImport("System")); var rType = new CodeTypeDeclaration("R"); rType.IsClass = true; rType.TypeAttributes = TypeAttributes.AnsiClass | TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.Public; pkgNamespace.Types.Add(rType); if (resourceTable != null) { foreach (var typeSpec in resourceTable.Packages[0].TypeSpecs) { if (typeSpec.EntryCount == 0) continue; var typeDef = new CodeTypeDeclaration(CreateTypeSpecName(typeSpec)); typeDef.IsClass = true; typeDef.TypeAttributes = TypeAttributes.AnsiClass | TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.NestedPublic; rType.Members.Add(typeDef); var index = 0; foreach (var entry in typeSpec.Entries) { // Skip code generation for system ID's if (!SystemIdConstants.Ids.Contains(entry.Key)) { var resId = 0x7F000000 | ((typeSpec.Id) << 16) | index; var field = new CodeMemberField(typeof (int), MakeValueNetIdentifier(UnfixResourceName(entry.Key))); field.Attributes = MemberAttributes.Public | MemberAttributes.Const; field.InitExpression = new CodeSnippetExpression(string.Format("0x{0:x8}", resId)); typeDef.Members.Add(field); } index++; } } if (styleableDeclarations.Any()) { var styleableTypeDef = new CodeTypeDeclaration("Styleables"); styleableTypeDef.IsClass = true; styleableTypeDef.TypeAttributes = TypeAttributes.AnsiClass | TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.NestedPublic; rType.Members.Add(styleableTypeDef); foreach (var declaration in styleableDeclarations) { // Type var typeDef = new CodeTypeDeclaration(declaration.Name); typeDef.IsClass = true; typeDef.TypeAttributes = TypeAttributes.AnsiClass | TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.NestedPublic; styleableTypeDef.Members.Add(typeDef); // Array var list = string.Join(", ", declaration.AttributeNames.Select(x => FormatAttributeName(x, null))); var arrayField = new CodeSnippetTypeMember("public static readonly int[] AllIds = new[] { " + list + " };"); typeDef.Members.Add(arrayField); foreach (var attr in declaration.AttributeNames) { var field = new CodeMemberField(typeof(int), UnfixResourceName(attr)); field.Attributes = MemberAttributes.Public | MemberAttributes.Const; field.InitExpression = new CodeSnippetExpression(FormatAttributeName(attr, 0xFFFF)); typeDef.Members.Add(field); } } } } return compileUnit; }
/// <summary> /// Generates the automatic properties. /// </summary> /// <param name="type">Represents a type declaration for a class, structure, interface, or enumeration.</param> private void GenerateAutomaticProperties(CodeTypeDeclaration type) { if (Equals(GeneratorContext.GeneratorParams.Language, GenerationLanguage.CSharp)) { // If databinding is disable, use automatic property if (GeneratorContext.GeneratorParams.PropertyParams.AutomaticProperties) { foreach (var item in this.autoPropertyListField) { var cm = new CodeSnippetTypeMember(); bool transformToAutomaticproperty = true; var attributesString = new List <string>(); foreach (var attribute in item.CustomAttributes) { var attrib = attribute as CodeAttributeDeclaration; if (attrib != null) { // Don't transform property with default value. if (attrib.Name == "System.ComponentModel.DefaultValueAttribute") { transformToAutomaticproperty = false; } else { string attributesArguments = string.Empty; foreach (var arg in attrib.Arguments) { var argument = arg as CodeAttributeArgument; if (argument != null) { attributesArguments += AttributeArgumentToString(argument) + ","; } } // Remove last "," if (attributesArguments.Length > 0) { attributesArguments = attributesArguments.Remove(attributesArguments.Length - 1); } attributesString.Add(string.Format("[{0}({1})]", attrib.Name, attributesArguments)); } } } if (transformToAutomaticproperty) { foreach (var attribute in attributesString) { cm.Text += " " + attribute + "\n"; } var ct = new CodeTypeReferenceExpression(item.Type); var prop = ExpressionToString(ct); var text = string.Format(" public {0} {1} ", prop, item.Name); cm.Text += string.Concat(text, "{get; set;}\n"); cm.Comments.AddRange(item.Comments); type.Members.Add(cm); type.Members.Remove(item); } } // Now remove all private fileds foreach (var item in this.fieldListToRemoveField) { if (item.Name == "mailClassField" && type.Name == "uspsSummaryType") { ; } type.Members.Remove(item); } } } }
private static CodeSnippetTypeMember AddAttributes(CodeTypeMember getter, CodeTypeMember setter, CodeMemberProperty property) { CodeSnippetTypeMember propertySnippet = new CodeSnippetTypeMember(); AddAttributes(getter, property, propertySnippet, @"{(\s*)get", @"{{$1{0}$1get"); if (setter != null) { AddAttributes(setter, property, propertySnippet, @"}(\s*)set", @"}}$1{0}$1set"); } propertySnippet.UserData["interface"] = property.PrivateImplementationType; return propertySnippet; }
/// <summary> /// Create the body of the task's code by simply using the taskCode as a snippet for the CodeDom /// </summary> private static void CreateTaskBody(CodeTypeDeclaration codeTypeDeclaration, string taskCode) { CodeSnippetTypeMember snippet = new CodeSnippetTypeMember(taskCode); codeTypeDeclaration.Members.Add(snippet); }
private static void AddAttributes(CodeTypeMember method, CodeTypeMember property, CodeSnippetTypeMember propertySnippet, string findRegex, string replaceRegex) { if (method.CustomAttributes.Count > 0) { using (StringWriter writer = new StringWriter()) { string propertyCode = string.IsNullOrEmpty(propertySnippet.Name) ? GetMemberCode(property, writer) : propertySnippet.Text; writer.GetStringBuilder().Length = 0; for (int i = method.CustomAttributes.Count - 1; i >= 0; i--) { CodeAttributeDeclaration attributeDeclaration = method.CustomAttributes[i]; if (attributeDeclaration.AttributeType.BaseType != "SmokeMethod") { propertySnippet.CustomAttributes.Insert(0, attributeDeclaration); method.CustomAttributes.RemoveAt(i); } } string getterCode = GetMemberCode(method, writer); string attribute = string.Format(replaceRegex, regexAttribute.Match(getterCode).Groups[1].Value); string propertyWithAttribute = Regex.Replace(propertyCode, findRegex, attribute); propertySnippet.Name = property.Name; propertySnippet.Attributes = property.Attributes; propertySnippet.Text = propertyWithAttribute; } } }
/// <summary> /// Main driving routine for building a class /// </summary> public static void BuildClass(string expression) { // need a string to put the code into _source = new StringBuilder(); StringWriter sw = new StringWriter(_source); //Declare your provider and generator CSharpCodeProvider codeProvider = new CSharpCodeProvider(); ICodeGenerator generator = codeProvider.CreateGenerator(sw); CodeGeneratorOptions codeOpts = new CodeGeneratorOptions(); CodeNamespace myNamespace = new CodeNamespace("ExpressionEvaluator"); myNamespace.Imports.Add(new CodeNamespaceImport("System")); //myNamespace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms")); //myNamespace.Imports.Add(new CodeNamespaceImport("MissionPlanner.Utilities")); //myNamespace.Imports.Add(new CodeNamespaceImport("MissionPlanner")); //Build the class declaration and member variables CodeTypeDeclaration classDeclaration = new CodeTypeDeclaration(); classDeclaration.IsClass = true; classDeclaration.Name = "Calculator"; classDeclaration.Attributes = MemberAttributes.Public; classDeclaration.Members.Add(FieldVariable("answer", typeof(object), MemberAttributes.Private)); //default constructor CodeConstructor defaultConstructor = new CodeConstructor(); defaultConstructor.Attributes = MemberAttributes.Public; defaultConstructor.Comments.Add(new CodeCommentStatement("Default Constructor for class", true)); defaultConstructor.Statements.Add(new CodeSnippetStatement("//TODO: implement default constructor")); classDeclaration.Members.Add(defaultConstructor); //property classDeclaration.Members.Add(MakeProperty("Answer", "answer", typeof(object))); //Our Calculate Method /* * CodeMemberMethod myMethod = new CodeMemberMethod(); * myMethod.Name = "Calculate"; * myMethod.ReturnType = new CodeTypeReference(typeof(object)); * myMethod.Comments.Add(new CodeCommentStatement("Calculate an expression", true)); * myMethod.Attributes = MemberAttributes.Public; * myMethod.Statements.Add(new CodeAssignStatement(new CodeSnippetExpression("Object obj"), new CodeSnippetExpression(expression))); * //myMethod.Statements.Add(new CodeAssignStatement(new CodeSnippetExpression("Answer"), new CodeSnippetExpression("obj.ToString()"))); * myMethod.Statements.Add( * new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Answer"))); * classDeclaration.Members.Add(myMethod); */ classDeclaration.Members.Add(FieldVariable("customforusenumber", typeof(double), MemberAttributes.Public)); classDeclaration.Members.Add(FieldVariable("customforuseobject", typeof(object), MemberAttributes.Public)); CodeSnippetTypeMember myMethod = new CodeSnippetTypeMember(); myMethod.Text = expression; classDeclaration.Members.Add(myMethod); //write code myNamespace.Types.Add(classDeclaration); generator.GenerateCodeFromNamespace(myNamespace, sw, codeOpts); sw.Flush(); sw.Close(); Console.Write(sw.ToString()); }
/* * Adds complementing operators if necessary. */ private void AddMissingOperators() { for (short i = 1; i <= this.data.Smoke->numClasses; i++) { Smoke.Class* klass = this.data.Smoke->classes + i; // skip external classes and namespaces if (klass->external || klass->size == 0) continue; CodeTypeDeclaration typeDecl = this.data.SmokeTypeMap[(IntPtr) klass]; var lessThanOperators = new List<CodeMemberMethod>(); var greaterThanOperators = new List<CodeMemberMethod>(); var lessThanOrEqualOperators = new List<CodeMemberMethod>(); var greaterThanOrEqualOperators = new List<CodeMemberMethod>(); var equalOperators = new List<CodeMemberMethod>(); var inequalOperators = new List<CodeMemberMethod>(); foreach (CodeMemberMethod method in typeDecl.Members.OfType<CodeMemberMethod>()) { switch (method.Name) { case "operator<": lessThanOperators.Add(method); break; case "operator>": greaterThanOperators.Add(method); break; case "operator<=": lessThanOrEqualOperators.Add(method); break; case "operator>=": greaterThanOrEqualOperators.Add(method); break; case "operator==": equalOperators.Add(method); break; case "operator!=": inequalOperators.Add(method); break; } } AddComplementingOperatorsFn checkAndAdd = delegate(IList<CodeMemberMethod> ops, IList<CodeMemberMethod> otherOps, string opName, string expr) { foreach (CodeMemberMethod op in ops) { if (otherOps.Any(otherOp => op.ParametersEqual(otherOp))) continue; CodeMemberMethod complement = new CodeMemberMethod(); complement.Name = opName; complement.Attributes = op.Attributes; complement.ReturnType = op.ReturnType; complement.Parameters.AddRange(op.Parameters); complement.Statements.Add(new CodeMethodReturnStatement(new CodeSnippetExpression(expr))); typeDecl.Members.Add(complement); } }; checkAndAdd(lessThanOperators, greaterThanOperators, "operator>", "!(arg1 < arg2) && arg1 != arg2"); checkAndAdd(greaterThanOperators, lessThanOperators, "operator<", "!(arg1 > arg2) && arg1 != arg2"); checkAndAdd(lessThanOrEqualOperators, greaterThanOrEqualOperators, "operator>=", "!(arg1 < arg2)"); checkAndAdd(greaterThanOrEqualOperators, lessThanOrEqualOperators, "operator<=", "!(arg1 > arg2)"); checkAndAdd(equalOperators, inequalOperators, "operator!=", "!(arg1 == arg2)"); checkAndAdd(inequalOperators, equalOperators, "operator==", "!(arg1 != arg2)"); if (equalOperators.Count == 0 && inequalOperators.Count == 0) continue; // then we're done // add Equals(object) and GetHashCode() overrides CodeSnippetTypeMember equals = new CodeSnippetTypeMember(string.Format(EqualsCode, typeDecl.Name)); typeDecl.Members.Add(equals); typeDecl.Members.Add(getHashCode); } }
private static void Json2Class(string fileName, string json, List <object> statements) { string structName = ""; structName = Path.GetFileName(fileName).ToLower().Replace(".xlsx", ""); //首字母大写 structName = structName.Substring(0, 1).ToUpper() + structName.Substring(1); //输出目录控制 string outputFile = Path.Combine(Application.dataPath, "Code/Game@hotfix/Table"); if (Directory.Exists(outputFile) == false) { Directory.CreateDirectory(outputFile); } //输出目录 outputFile = Path.Combine(outputFile, Path.GetFileName(fileName).Replace(".xlsx", ".cs")); //生成类服务 CodeCompileUnit compunit = new CodeCompileUnit(); CodeNamespace sample = new CodeNamespace("Game.Data"); compunit.Namespaces.Add(sample); //引用命名空间 sample.Imports.Add(new CodeNamespaceImport("System")); sample.Imports.Add(new CodeNamespaceImport("System.Collections.Generic")); sample.Imports.Add(new CodeNamespaceImport("Game.Data")); sample.Imports.Add(new CodeNamespaceImport("SQLite4Unity3d")); //在命名空间下添加一个类 CodeTypeDeclaration wrapProxyClass = new CodeTypeDeclaration(structName); wrapProxyClass.IsClass = true; wrapProxyClass.IsEnum = false; wrapProxyClass.IsInterface = false; wrapProxyClass.IsPartial = false; wrapProxyClass.IsStruct = false; //把这个类添加到命名空间 sample.Types.Add(wrapProxyClass); CodeAttributeDeclaration attr = new CodeAttributeDeclaration("Serializable"); wrapProxyClass.CustomAttributes.Add(attr); // var jsonData = JsonMapper.ToObject(json)[0]; int i = 0; foreach (var key in jsonData.Keys) { //字段 string memberContent = @" public [type] [Name] {get;set;}"; CodeSnippetTypeMember member = new CodeSnippetTypeMember(); if (key.ToLower() == "id" && key != "Id") { Debug.LogErrorFormat("<color=yellow>表格{0}字段必须为Id[大小写],请修改后生成</color>", structName); break; } else if (key == "Id") { //增加一个sqlite主键 //member.CustomAttributes.Add(new CodeAttributeDeclaration("PrimaryKey")); memberContent = @" [PrimaryKey] public [type] [Name] {get;set;}"; } var value = jsonData[key]; string type = null; if (value.IsArray) { var str = value.ToJson(); if (str.IndexOf("\"") > 0) { type = "List<string>"; } else { type = "List<double>"; } } else if (value.IsInt) { type = "int"; } else if (value.IsDouble || value.IsLong) { type = "double"; } else if (value.IsBoolean) { type = "bool"; } else if (value.IsString) { type = "string"; } //注释 member.Comments.Add(new CodeCommentStatement(statements[i].ToString())); member.Text = memberContent.Replace("[type]", type).Replace("[Name]", key); wrapProxyClass.Members.Add(member); i++; } //生成代码 CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp"); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; options.BlankLinesBetweenMembers = true; using (System.IO.StreamWriter sw = new System.IO.StreamWriter(outputFile)) { provider.GenerateCodeFromCompileUnit(compunit, sw, options); } }
private void GenerateEvent(CodeMemberMethod cmm, string name, CodeTypeDeclaration type, bool isVirtual) { if (!name.EndsWith("Event") || (type.Name == "QCoreApplication" && (name == "PostEvent" || name == "SendEvent"))) { return; } string paramType; // TODO: add support for IQGraphicsItem if (cmm.Parameters.Count == 1 && (paramType = cmm.Parameters[0].Type.BaseType).EndsWith("Event") && (cmm.Attributes & MemberAttributes.Override) == 0 && !new[] { "QGraphicsItem", "QGraphicsObject", "QGraphicsTextItem", "QGraphicsProxyWidget", "QGraphicsWidget", "QGraphicsLayout", "QGraphicsScene" }.Contains(type.Name)) { if (!this.HasField(type, "eventFilters")) { CodeSnippetTypeMember eventFilters = new CodeSnippetTypeMember(); eventFilters.Name = "eventFilters"; eventFilters.Text = "protected readonly List<QEventHandler> eventFilters = new List<QEventHandler>();"; type.Members.Add(eventFilters); } CodeSnippetTypeMember codeMemberEvent = new CodeSnippetTypeMember(); codeMemberEvent.Name = name; codeMemberEvent.Text = string.Format( @" public {0} event EventHandler<QEventArgs<{1}>> {2} {{ add {{ QEventArgs<{1}> qEventArgs = new QEventArgs<{1}>({3}); QEventHandler<{1}> qEventHandler = new QEventHandler<{1}>(this{4}, qEventArgs, value); foreach (QEventHandler eventFilter in eventFilters) {{ this{4}.RemoveEventFilter(eventFilter); }} eventFilters.Add(qEventHandler); for (int i = eventFilters.Count - 1; i >= 0; i--) {{ this{4}.InstallEventFilter(eventFilters[i]); }} }} remove {{ for (int i = eventFilters.Count - 1; i >= 0; i--) {{ QEventHandler eventFilter = eventFilters[i]; if (eventFilter.Handler == value) {{ this{4}.RemoveEventFilter(eventFilter); eventFilters.RemoveAt(i); break; }} }} }} }} ", isVirtual ? "virtual" : "override", paramType, codeMemberEvent.Name, GetEventTypes(name), isVirtual ? string.Empty : ".Viewport"); codeMemberEvent.Attributes = (codeMemberEvent.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; codeMemberEvent.Comments.AddRange(cmm.Comments); type.Members.Add(codeMemberEvent); if (isVirtual && InheritsQWidget(type)) { eventMethods[cmm.Name] = cmm; } } if (isVirtual && !cmm.Name.StartsWith("~")) { cmm.Name = "On" + cmm.Name; } }
private void ValidateSnippetMember(CodeSnippetTypeMember e) { }
protected abstract void GenerateSnippetMember(CodeSnippetTypeMember e);
private void GenerateSnippetMember(CodeSnippetTypeMember e) { Output.Write(e.Text); }
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) { #if WHIDBEY if (!(provider is JScriptCodeProvider)) { // GENERATES (C#): // // #region Compile Unit Region // // namespace Namespace1 { // // // #region Outer Type Region // // Outer Type Comment // public class Class1 { // // // Field 1 Comment // private string field1; // // public void Method1() { // this.Event1(this, System.EventArgs.Empty); // } // // #region Constructor Region // public Class1() { // #region Statements Region // this.field1 = "value1"; // this.field2 = "value2"; // #endregion // } // #endregion // // public string Property1 { // get { // return this.field1; // } // } // // public static void Main() { // } // // public event System.EventHandler Event1; // // public class NestedClass1 { // } // // public delegate void nestedDelegate1(object sender, System.EventArgs e); // // // // #region Field Region // private string field2; // #endregion // // #region Method Region // // Method 2 Comment // // #line 500 "MethodLinePragma.txt" // public void Method2() { // this.Event2(this, System.EventArgs.Empty); // } // // #line default // #line hidden // #endregion // // public Class1(string value1, string value2) { // } // // #region Property Region // public string Property2 { // get { // return this.field2; // } // } // #endregion // // #region Type Constructor Region // static Class1() { // } // #endregion // // #region Event Region // public event System.EventHandler Event2; // #endregion // // #region Nested Type Region // // Nested Type Comment // // #line 400 "NestedTypeLinePragma.txt" // public class NestedClass2 { // } // // #line default // #line hidden // #endregion // // #region Delegate Region // public delegate void nestedDelegate2(object sender, System.EventArgs e); // #endregion // // #region Snippet Region // // #endregion // } // #endregion // } // #endregion CodeNamespace ns = new CodeNamespace ("Namespace1"); cu.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Compile Unit Region")); cu.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty)); cu.Namespaces.Add (ns); CodeTypeDeclaration cd = new CodeTypeDeclaration ("Class1"); ns.Types.Add (cd); cd.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Outer Type Region")); cd.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty)); cd.Comments.Add (new CodeCommentStatement ("Outer Type Comment")); CodeMemberField field1 = new CodeMemberField (typeof (String), "field1"); CodeMemberField field2 = new CodeMemberField (typeof (String), "field2"); field1.Comments.Add (new CodeCommentStatement ("Field 1 Comment")); field2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Field Region")); field2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty)); CodeMemberEvent evt1 = new CodeMemberEvent (); evt1.Name = "Event1"; evt1.Type = new CodeTypeReference (typeof (System.EventHandler)); evt1.Attributes = (evt1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; CodeMemberEvent evt2 = new CodeMemberEvent (); evt2.Name = "Event2"; evt2.Type = new CodeTypeReference (typeof (System.EventHandler)); evt2.Attributes = (evt2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; evt2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Event Region")); evt2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty)); CodeMemberMethod method1 = new CodeMemberMethod (); method1.Name = "Method1"; method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; if (provider.Supports (GeneratorSupport.DeclareEvents)) { method1.Statements.Add ( new CodeDelegateInvokeExpression ( new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "Event1"), new CodeExpression[] { new CodeThisReferenceExpression(), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty") })); } CodeMemberMethod method2 = new CodeMemberMethod (); method2.Name = "Method2"; method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; if (provider.Supports (GeneratorSupport.DeclareEvents)) { method2.Statements.Add ( new CodeDelegateInvokeExpression ( new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "Event2"), new CodeExpression[] { new CodeThisReferenceExpression(), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty") })); } method2.LinePragma = new CodeLinePragma ("MethodLinePragma.txt", 500); method2.Comments.Add (new CodeCommentStatement ("Method 2 Comment")); method2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Method Region")); method2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty)); CodeMemberProperty property1 = new CodeMemberProperty (); property1.Name = "Property1"; property1.Type = new CodeTypeReference (typeof (string)); property1.Attributes = (property1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; property1.GetStatements.Add ( new CodeMethodReturnStatement ( new CodeFieldReferenceExpression ( new CodeThisReferenceExpression (), "field1"))); CodeMemberProperty property2 = new CodeMemberProperty (); property2.Name = "Property2"; property2.Type = new CodeTypeReference (typeof (string)); property2.Attributes = (property2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; property2.GetStatements.Add ( new CodeMethodReturnStatement ( new CodeFieldReferenceExpression ( new CodeThisReferenceExpression (), "field2"))); property2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Property Region")); property2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty)); CodeConstructor constructor1 = new CodeConstructor (); constructor1.Attributes = (constructor1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; CodeStatement conState1 = new CodeAssignStatement ( new CodeFieldReferenceExpression ( new CodeThisReferenceExpression (), "field1"), new CodePrimitiveExpression ("value1")); conState1.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Statements Region")); constructor1.Statements.Add (conState1); CodeStatement conState2 = new CodeAssignStatement ( new CodeFieldReferenceExpression ( new CodeThisReferenceExpression (), "field2"), new CodePrimitiveExpression ("value2")); conState2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty)); constructor1.Statements.Add (conState2); constructor1.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Constructor Region")); constructor1.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty)); CodeConstructor constructor2 = new CodeConstructor (); constructor2.Attributes = (constructor2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; constructor2.Parameters.Add (new CodeParameterDeclarationExpression (typeof (string), "value1")); constructor2.Parameters.Add (new CodeParameterDeclarationExpression (typeof (string), "value2")); CodeTypeConstructor typeConstructor2 = new CodeTypeConstructor (); typeConstructor2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Type Constructor Region")); typeConstructor2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty)); CodeEntryPointMethod methodMain = new CodeEntryPointMethod (); CodeTypeDeclaration nestedClass1 = new CodeTypeDeclaration ("NestedClass1"); CodeTypeDeclaration nestedClass2 = new CodeTypeDeclaration ("NestedClass2"); nestedClass2.LinePragma = new CodeLinePragma ("NestedTypeLinePragma.txt", 400); nestedClass2.Comments.Add (new CodeCommentStatement ("Nested Type Comment")); nestedClass2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Nested Type Region")); nestedClass2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty)); CodeTypeDelegate delegate1 = new CodeTypeDelegate (); delegate1.Name = "nestedDelegate1"; delegate1.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.Object"), "sender")); delegate1.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.EventArgs"), "e")); CodeTypeDelegate delegate2 = new CodeTypeDelegate (); delegate2.Name = "nestedDelegate2"; delegate2.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.Object"), "sender")); delegate2.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.EventArgs"), "e")); delegate2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Delegate Region")); delegate2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty)); CodeSnippetTypeMember snippet1 = new CodeSnippetTypeMember (); CodeSnippetTypeMember snippet2 = new CodeSnippetTypeMember (); CodeRegionDirective regionStart = new CodeRegionDirective (CodeRegionMode.End, ""); regionStart.RegionText = "Snippet Region"; regionStart.RegionMode = CodeRegionMode.Start; snippet2.StartDirectives.Add (regionStart); snippet2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty)); cd.Members.Add (field1); cd.Members.Add (method1); cd.Members.Add (constructor1); cd.Members.Add (property1); cd.Members.Add (methodMain); if (Supports (provider, GeneratorSupport.DeclareEvents)) { cd.Members.Add (evt1); } if (Supports (provider, GeneratorSupport.NestedTypes)) { cd.Members.Add (nestedClass1); if (Supports (provider, GeneratorSupport.DeclareDelegates)) { cd.Members.Add (delegate1); } } cd.Members.Add (snippet1); cd.Members.Add (field2); cd.Members.Add (method2); cd.Members.Add (constructor2); cd.Members.Add (property2); if (Supports (provider, GeneratorSupport.StaticConstructors)) { cd.Members.Add (typeConstructor2); } if (Supports (provider, GeneratorSupport.DeclareEvents)) { cd.Members.Add (evt2); } if (Supports (provider, GeneratorSupport.NestedTypes)) { cd.Members.Add (nestedClass2); if (Supports (provider, GeneratorSupport.DeclareDelegates)) { cd.Members.Add (delegate2); } } cd.Members.Add (snippet2); } #endif }
//construct, given the code provider being used. public CompileDirectives(CodeDomProvider codeProvider) { this.codeProvider = codeProvider; if (codeProvider.FileExtension == "cs") { readonlySnip = new CodeSnippetTypeMember("readonly "); isCSharp = true; } if (codeProvider.FileExtension == "vb") { readonlySnip = new CodeSnippetTypeMember("ReadOnly "); } //try and load the directives from the user config. try { //GenericType string defaultDiretive = Properties.Settings.Default.DefaultCompilerDirectives.Trim(); if (defaultDiretive.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).Length == 3) { directives = defaultDiretive.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); } System.Reflection.PropertyInfo[] properties = Properties.Settings.Default.GetType().GetProperties(); foreach (System.Reflection.PropertyInfo property in properties) { if (property.PropertyType == typeof(string) && property.Name.EndsWith("CompilerDirectives", StringComparison.InvariantCultureIgnoreCase)) { string directive = property.GetValue(Properties.Settings.Default, null) as string; if (directive != null) { string[] lines = directive.Trim().Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); if (lines.Length == 4) { if (("*." + codeProvider.FileExtension).Equals(lines[0].Trim(), StringComparison.InvariantCultureIgnoreCase)) { for (int i = 0; i < 3; i++) { directives[i] = lines[i + 1]; } } } } } } for (int i = 0; i < directives.Length; i++) { directives[i] = directives[i].Trim(); } if (directives[0].Contains("{0}") == false) { throw new Exception("Could not find {0} in directive 0"); } } catch (Exception e) { throw new Exception("Error in user.config file", e); } }