public ItemProperty(string inName) { property = new CodeMemberProperty(); property.HasGet = false; property.HasSet = false; property.Name = Stringer.FirstLetterLower(inName); }
public CodeMemberProperty GenerateProperty(Generator g) { var p = new CodeMemberProperty () { Name = Name, Attributes = MemberAttributes.Public|MemberAttributes.Final }; p.Type = g.CppTypeToCodeDomType (Type); if (GetMethod != null) { p.GetStatements.Add (new CodeMethodReturnStatement (new CodeMethodInvokeExpression (new CodeMethodReferenceExpression (new CodeFieldReferenceExpression (null, "impl"), GetMethod.Name), new CodeExpression [] { new CodeFieldReferenceExpression (null, "Native") }))); } if (SetMethod != null) { p.SetStatements.Add (new CodeMethodInvokeExpression (new CodeMethodReferenceExpression (new CodeFieldReferenceExpression (null, "impl"), SetMethod.Name), new CodeExpression [] { new CodeFieldReferenceExpression (null, "Native"), new CodeArgumentReferenceExpression ("value") })); } return p; }
public List<CodeMemberProperty> GenerateBasicAttributeDefinitions() { List<CodeMemberProperty> ret = new List<CodeMemberProperty>(); foreach (KeyValuePair<string, Attribute> pair in attributes) { Attribute attr = pair.Value; CodeMemberProperty prop = new CodeMemberProperty(); prop.Name = pair.Key; try { bool isRef; prop.Type = translator.CppToCSharp(attr.Smoke->types + attr.GetMethod->ret, out isRef); } catch (NotSupportedException) { string className = ByteArrayManager.GetString(attr.Smoke->classes[attr.GetMethod->classId].className); Debug.Print(" |--Won't wrap Attribute {0}::{1}", className, prop.Name); continue; } prop.HasGet = true; prop.HasSet = attr.SetMethod != (Smoke.Method*) 0; if ((attr.GetMethod->flags & (uint) Smoke.MethodFlags.mf_protected) > 0) { prop.Attributes = MemberAttributes.Family | MemberAttributes.New | MemberAttributes.Final; } else { prop.Attributes = MemberAttributes.Public | MemberAttributes.New | MemberAttributes.Final; } if ((attr.GetMethod->flags & (uint) Smoke.MethodFlags.mf_static) > 0) prop.Attributes |= MemberAttributes.Static; ret.Add(prop); if (PostAttributeProperty != null) { PostAttributeProperty(prop, type); } } return ret; }
public void ProviderSupports() { CodeDomProvider provider = GetProvider(); CodeCompileUnit cu = new CodeCompileUnit(); CodeNamespace nspace = new CodeNamespace("NSPC"); nspace.Imports.Add(new CodeNamespaceImport("System")); nspace.Imports.Add(new CodeNamespaceImport("System.Drawing")); nspace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms")); nspace.Imports.Add(new CodeNamespaceImport("System.ComponentModel")); cu.Namespaces.Add(nspace); CodeTypeDeclaration cd = new CodeTypeDeclaration("TEST"); cd.IsClass = true; nspace.Types.Add(cd); // Arrays of Arrays CodeMemberMethod cmm = new CodeMemberMethod(); cmm.Name = "ArraysOfArrays"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public; if (provider.Supports(GeneratorSupport.ArraysOfArrays)) { cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int[][])), "arrayOfArrays", new CodeArrayCreateExpression(typeof(int[][]), new CodeArrayCreateExpression(typeof(int[]), new CodePrimitiveExpression(3), new CodePrimitiveExpression(4)), new CodeArrayCreateExpression(typeof(int[]), new CodeExpression[] { new CodePrimitiveExpression(1) })))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeArrayIndexerExpression( new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("arrayOfArrays"), new CodePrimitiveExpression(0)) , new CodePrimitiveExpression(1)))); } else { throw new Exception("not supported"); } cd.Members.Add(cmm); // assembly attributes if (provider.Supports(GeneratorSupport.AssemblyAttributes)) { CodeAttributeDeclarationCollection attrs = cu.AssemblyCustomAttributes; attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyTitle", new CodeAttributeArgument(new CodePrimitiveExpression("MyAssembly")))); attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyVersion", new CodeAttributeArgument(new CodePrimitiveExpression("1.0.6.2")))); } CodeTypeDeclaration class1 = new CodeTypeDeclaration(); if (provider.Supports(GeneratorSupport.ChainedConstructorArguments)) { class1.Name = "Test2"; class1.IsClass = true; nspace.Types.Add(class1); class1.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(String)), "stringField")); CodeMemberProperty prop = new CodeMemberProperty(); prop.Name = "accessStringField"; prop.Attributes = MemberAttributes.Public | MemberAttributes.Final; prop.Type = new CodeTypeReference(typeof(String)); prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "stringField"))); prop.SetStatements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "stringField"), new CodePropertySetValueReferenceExpression())); class1.Members.Add(prop); CodeConstructor cctor = new CodeConstructor(); cctor.Attributes = MemberAttributes.Public; cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression("testingString")); cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression(null)); cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression(null)); class1.Members.Add(cctor); CodeConstructor cc = new CodeConstructor(); cc.Attributes = MemberAttributes.Public | MemberAttributes.Overloaded; cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p1")); cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p2")); cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p3")); cc.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression() , "stringField"), new CodeVariableReferenceExpression("p1"))); class1.Members.Add(cc); // verify chained constructors work cmm = new CodeMemberMethod(); cmm.Name = "ChainedConstructorUse"; cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; cmm.ReturnType = new CodeTypeReference(typeof(String)); // utilize constructor cmm.Statements.Add(new CodeVariableDeclarationStatement("Test2", "t", new CodeObjectCreateExpression("Test2"))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodReferenceExpression( new CodeVariableReferenceExpression("t"), "accessStringField"))); cd.Members.Add(cmm); } // complex expressions if (provider.Supports(GeneratorSupport.ComplexExpressions)) { cmm = new CodeMemberMethod(); cmm.Name = "ComplexExpressions"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public; cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i")); cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("i"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Multiply, new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(3))))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("i"))); cd.Members.Add(cmm); } if (provider.Supports(GeneratorSupport.DeclareEnums)) { CodeTypeDeclaration ce = new CodeTypeDeclaration("DecimalEnum"); ce.IsEnum = true; nspace.Types.Add(ce); // things to enumerate for (int k = 0; k < 5; k++) { CodeMemberField Field = new CodeMemberField("System.Int32", "Num" + (k).ToString()); Field.InitExpression = new CodePrimitiveExpression(k); ce.Members.Add(Field); } cmm = new CodeMemberMethod(); cmm.Name = "OutputDecimalEnumVal"; cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i"); cmm.Parameters.Add(param); CodeBinaryOperatorExpression eq = new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(3)); CodeMethodReturnStatement truestmt = new CodeMethodReturnStatement( new CodeCastExpression(typeof(int), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num3"))); CodeConditionStatement condstmt = new CodeConditionStatement(eq, truestmt); cmm.Statements.Add(condstmt); eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(4)); truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num4"))); condstmt = new CodeConditionStatement(eq, truestmt); cmm.Statements.Add(condstmt); eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(2)); truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num2"))); condstmt = new CodeConditionStatement(eq, truestmt); cmm.Statements.Add(condstmt); eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(1)); truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num1"))); condstmt = new CodeConditionStatement(eq, truestmt); cmm.Statements.Add(condstmt); eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(0)); truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num0"))); condstmt = new CodeConditionStatement(eq, truestmt); cmm.Statements.Add(condstmt); cmm.ReturnType = new CodeTypeReference("System.int32"); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(10)))); cd.Members.Add(cmm); } if (provider.Supports(GeneratorSupport.DeclareInterfaces)) { cmm = new CodeMemberMethod(); cmm.Name = "TestSingleInterface"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i")); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; cmm.Statements.Add(new CodeVariableDeclarationStatement("TestSingleInterfaceImp", "t", new CodeObjectCreateExpression("TestSingleInterfaceImp"))); CodeMethodInvokeExpression methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t") , "InterfaceMethod"); methodinvoke.Parameters.Add(new CodeVariableReferenceExpression("i")); cmm.Statements.Add(new CodeMethodReturnStatement(methodinvoke)); cd.Members.Add(cmm); class1 = new CodeTypeDeclaration("InterfaceA"); class1.IsInterface = true; nspace.Types.Add(class1); cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public; cmm.Name = "InterfaceMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a")); class1.Members.Add(cmm); if (provider.Supports(GeneratorSupport.MultipleInterfaceMembers)) { CodeTypeDeclaration classDecl = new CodeTypeDeclaration("InterfaceB"); classDecl.IsInterface = true; nspace.Types.Add(classDecl); cmm = new CodeMemberMethod(); cmm.Name = "InterfaceMethod"; cmm.Attributes = MemberAttributes.Public; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a")); classDecl.Members.Add(cmm); CodeTypeDeclaration class2 = new CodeTypeDeclaration("TestMultipleInterfaceImp"); class2.BaseTypes.Add(new CodeTypeReference("System.Object")); class2.BaseTypes.Add(new CodeTypeReference("InterfaceB")); class2.BaseTypes.Add(new CodeTypeReference("InterfaceA")); class2.IsClass = true; nspace.Types.Add(class2); cmm = new CodeMemberMethod(); cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceA")); cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceB")); cmm.Name = "InterfaceMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a")); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final; cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a"))); class2.Members.Add(cmm); cmm = new CodeMemberMethod(); cmm.Name = "TestMultipleInterfaces"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i")); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; cmm.Statements.Add(new CodeVariableDeclarationStatement("TestMultipleInterfaceImp", "t", new CodeObjectCreateExpression("TestMultipleInterfaceImp"))); cmm.Statements.Add(new CodeVariableDeclarationStatement("InterfaceA", "interfaceAobject", new CodeCastExpression("InterfaceA", new CodeVariableReferenceExpression("t")))); cmm.Statements.Add(new CodeVariableDeclarationStatement("InterfaceB", "interfaceBobject", new CodeCastExpression("InterfaceB", new CodeVariableReferenceExpression("t")))); methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("interfaceAobject") , "InterfaceMethod"); methodinvoke.Parameters.Add(new CodeVariableReferenceExpression("i")); CodeMethodInvokeExpression methodinvoke2 = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("interfaceBobject") , "InterfaceMethod"); methodinvoke2.Parameters.Add(new CodeVariableReferenceExpression("i")); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression( methodinvoke, CodeBinaryOperatorType.Subtract, methodinvoke2))); cd.Members.Add(cmm); } class1 = new CodeTypeDeclaration("TestSingleInterfaceImp"); class1.BaseTypes.Add(new CodeTypeReference("System.Object")); class1.BaseTypes.Add(new CodeTypeReference("InterfaceA")); class1.IsClass = true; nspace.Types.Add(class1); cmm = new CodeMemberMethod(); cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceA")); cmm.Name = "InterfaceMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a")); cmm.Attributes = MemberAttributes.Public; cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a"))); class1.Members.Add(cmm); } if (provider.Supports(GeneratorSupport.DeclareValueTypes)) { CodeTypeDeclaration structA = new CodeTypeDeclaration("structA"); structA.IsStruct = true; CodeTypeDeclaration structB = new CodeTypeDeclaration("structB"); structB.Attributes = MemberAttributes.Public; structB.IsStruct = true; CodeMemberField firstInt = new CodeMemberField(typeof(int), "int1"); firstInt.Attributes = MemberAttributes.Public; structB.Members.Add(firstInt); CodeMemberField innerStruct = new CodeMemberField("structB", "innerStruct"); innerStruct.Attributes = MemberAttributes.Public; structA.Members.Add(structB); structA.Members.Add(innerStruct); nspace.Types.Add(structA); CodeMemberMethod nestedStructMethod = new CodeMemberMethod(); nestedStructMethod.Name = "NestedStructMethod"; nestedStructMethod.ReturnType = new CodeTypeReference(typeof(int)); nestedStructMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static; CodeVariableDeclarationStatement varStructA = new CodeVariableDeclarationStatement("structA", "varStructA"); nestedStructMethod.Statements.Add(varStructA); nestedStructMethod.Statements.Add ( new CodeAssignStatement ( /* Expression1 */ new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("varStructA"), "innerStruct"), "int1"), /* Expression1 */ new CodePrimitiveExpression(3) ) ); nestedStructMethod.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("varStructA"), "innerStruct"), "int1"))); cd.Members.Add(nestedStructMethod); } if (provider.Supports(GeneratorSupport.EntryPointMethod)) { CodeEntryPointMethod cep = new CodeEntryPointMethod(); cd.Members.Add(cep); } // goto statements if (provider.Supports(GeneratorSupport.GotoStatements)) { cmm = new CodeMemberMethod(); cmm.Name = "GoToMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final; CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i"); cmm.Parameters.Add(param); CodeConditionStatement condstmt = new CodeConditionStatement(new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(1)), new CodeGotoStatement("comehere")); cmm.Statements.Add(condstmt); cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(6))); cmm.Statements.Add(new CodeLabeledStatement("comehere", new CodeMethodReturnStatement(new CodePrimitiveExpression(7)))); cd.Members.Add(cmm); } if (provider.Supports(GeneratorSupport.NestedTypes)) { cmm = new CodeMemberMethod(); cmm.Name = "CallingPublicNestedScenario"; cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i")); cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference ("PublicNestedClassA+PublicNestedClassB2+PublicNestedClassC"), "t", new CodeObjectCreateExpression(new CodeTypeReference ("PublicNestedClassA+PublicNestedClassB2+PublicNestedClassC")))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t"), "publicNestedClassesMethod", new CodeVariableReferenceExpression("i")))); cd.Members.Add(cmm); class1 = new CodeTypeDeclaration("PublicNestedClassA"); class1.IsClass = true; nspace.Types.Add(class1); CodeTypeDeclaration nestedClass = new CodeTypeDeclaration("PublicNestedClassB1"); nestedClass.IsClass = true; nestedClass.TypeAttributes = TypeAttributes.NestedPublic; class1.Members.Add(nestedClass); nestedClass = new CodeTypeDeclaration("PublicNestedClassB2"); nestedClass.TypeAttributes = TypeAttributes.NestedPublic; nestedClass.IsClass = true; class1.Members.Add(nestedClass); CodeTypeDeclaration innerNestedClass = new CodeTypeDeclaration("PublicNestedClassC"); innerNestedClass.TypeAttributes = TypeAttributes.NestedPublic; innerNestedClass.IsClass = true; nestedClass.Members.Add(innerNestedClass); cmm = new CodeMemberMethod(); cmm.Name = "publicNestedClassesMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a")); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final; cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a"))); innerNestedClass.Members.Add(cmm); } // Parameter Attributes if (provider.Supports(GeneratorSupport.ParameterAttributes)) { CodeMemberMethod method1 = new CodeMemberMethod(); method1.Name = "MyMethod"; method1.Attributes = MemberAttributes.Public | MemberAttributes.Final; CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(string), "blah"); param1.CustomAttributes.Add( new CodeAttributeDeclaration( "System.Xml.Serialization.XmlElementAttribute", new CodeAttributeArgument( "Form", new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.Xml.Schema.XmlSchemaForm"), "Unqualified")), new CodeAttributeArgument( "IsNullable", new CodePrimitiveExpression(false)))); method1.Parameters.Add(param1); cd.Members.Add(method1); } // public static members if (provider.Supports(GeneratorSupport.PublicStaticMembers)) { cmm = new CodeMemberMethod(); cmm.Name = "PublicStaticMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(16))); cd.Members.Add(cmm); } // reference parameters if (provider.Supports(GeneratorSupport.ReferenceParameters)) { cmm = new CodeMemberMethod(); cmm.Name = "Work"; cmm.ReturnType = new CodeTypeReference("System.void"); cmm.Attributes = MemberAttributes.Static; // add parameter with ref direction CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i"); param.Direction = FieldDirection.Ref; cmm.Parameters.Add(param); // add parameter with out direction param = new CodeParameterDeclarationExpression(typeof(int), "j"); param.Direction = FieldDirection.Out; cmm.Parameters.Add(param); cmm.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("i"), new CodeBinaryOperatorExpression(new CodeArgumentReferenceExpression("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(4)))); cmm.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("j"), new CodePrimitiveExpression(5))); cd.Members.Add(cmm); cmm = new CodeMemberMethod(); cmm.Name = "CallingWork"; cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; CodeParameterDeclarationExpression parames = new CodeParameterDeclarationExpression(typeof(int), "a"); cmm.Parameters.Add(parames); cmm.ReturnType = new CodeTypeReference("System.int32"); cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"), new CodePrimitiveExpression(10))); cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "b")); // invoke the method called "work" CodeMethodInvokeExpression methodinvoked = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression (new CodeTypeReferenceExpression("TEST"), "Work")); // add parameter with ref direction CodeDirectionExpression parameter = new CodeDirectionExpression(FieldDirection.Ref, new CodeVariableReferenceExpression("a")); methodinvoked.Parameters.Add(parameter); // add parameter with out direction parameter = new CodeDirectionExpression(FieldDirection.Out, new CodeVariableReferenceExpression("b")); methodinvoked.Parameters.Add(parameter); cmm.Statements.Add(methodinvoked); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression (new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression("b")))); cd.Members.Add(cmm); } if (provider.Supports(GeneratorSupport.ReturnTypeAttributes)) { CodeMemberMethod function1 = new CodeMemberMethod(); function1.Name = "MyFunction"; function1.ReturnType = new CodeTypeReference(typeof(string)); function1.Attributes = MemberAttributes.Public | MemberAttributes.Final; function1.ReturnTypeCustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlIgnoreAttribute")); function1.ReturnTypeCustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlRootAttribute", new CodeAttributeArgument("Namespace", new CodePrimitiveExpression("Namespace Value")), new CodeAttributeArgument("ElementName", new CodePrimitiveExpression("Root, hehehe")))); function1.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression("Return"))); cd.Members.Add(function1); } if (provider.Supports(GeneratorSupport.StaticConstructors)) { cmm = new CodeMemberMethod(); cmm.Name = "TestStaticConstructor"; cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; cmm.ReturnType = new CodeTypeReference(typeof(int)); CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a"); cmm.Parameters.Add(param); // utilize constructor cmm.Statements.Add(new CodeVariableDeclarationStatement("Test4", "t", new CodeObjectCreateExpression("Test4"))); // set then get number cmm.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("t"), "i") , new CodeVariableReferenceExpression("a"))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodReferenceExpression( new CodeVariableReferenceExpression("t"), "i"))); cd.Members.Add(cmm); class1 = new CodeTypeDeclaration(); class1.Name = "Test4"; class1.IsClass = true; nspace.Types.Add(class1); class1.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(int)), "number")); CodeMemberProperty prop = new CodeMemberProperty(); prop.Name = "i"; prop.Attributes = MemberAttributes.Public | MemberAttributes.Final; prop.Type = new CodeTypeReference(typeof(int)); prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("number"))); prop.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("number"), new CodePropertySetValueReferenceExpression())); class1.Members.Add(prop); CodeTypeConstructor ctc = new CodeTypeConstructor(); class1.Members.Add(ctc); } if (provider.Supports(GeneratorSupport.TryCatchStatements)) { cmm = new CodeMemberMethod(); cmm.Name = "TryCatchMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a"); cmm.Parameters.Add(param); CodeTryCatchFinallyStatement tcfstmt = new CodeTryCatchFinallyStatement(); tcfstmt.FinallyStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(5)))); cmm.Statements.Add(tcfstmt); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a"))); cd.Members.Add(cmm); } if (provider.Supports(GeneratorSupport.DeclareEvents)) { CodeNamespace ns = new CodeNamespace(); ns.Name = "MyNamespace"; ns.Imports.Add(new CodeNamespaceImport("System")); ns.Imports.Add(new CodeNamespaceImport("System.Drawing")); ns.Imports.Add(new CodeNamespaceImport("System.Windows.Forms")); ns.Imports.Add(new CodeNamespaceImport("System.ComponentModel")); cu.Namespaces.Add(ns); class1 = new CodeTypeDeclaration("Test"); class1.IsClass = true; class1.BaseTypes.Add(new CodeTypeReference("Form")); ns.Types.Add(class1); CodeMemberField mfield = new CodeMemberField(new CodeTypeReference("Button"), "b"); mfield.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference("Button")); class1.Members.Add(mfield); CodeConstructor ctor = new CodeConstructor(); ctor.Attributes = MemberAttributes.Public; ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Size"), new CodeObjectCreateExpression(new CodeTypeReference("Size"), new CodePrimitiveExpression(600), new CodePrimitiveExpression(600)))); ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"), "Text"), new CodePrimitiveExpression("Test"))); ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"), "TabIndex"), new CodePrimitiveExpression(0))); ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"), "Location"), new CodeObjectCreateExpression(new CodeTypeReference("Point"), new CodePrimitiveExpression(400), new CodePrimitiveExpression(525)))); ctor.Statements.Add(new CodeAttachEventStatement(new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "MyEvent"), new CodeDelegateCreateExpression(new CodeTypeReference("EventHandler") , new CodeThisReferenceExpression(), "b_Click"))); class1.Members.Add(ctor); CodeMemberEvent evt = new CodeMemberEvent(); evt.Name = "MyEvent"; evt.Type = new CodeTypeReference("System.EventHandler"); evt.Attributes = MemberAttributes.Public; class1.Members.Add(evt); cmm = new CodeMemberMethod(); cmm.Name = "b_Click"; cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender")); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(EventArgs), "e")); class1.Members.Add(cmm); } AssertEqual(cu, @"'------------------------------------------------------------------------------ ' <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 Imports System Imports System.ComponentModel Imports System.Drawing Imports System.Windows.Forms <Assembly: System.Reflection.AssemblyTitle(""MyAssembly""), _ Assembly: System.Reflection.AssemblyVersion(""1.0.6.2"")> Namespace NSPC Public Class TEST Public Function ArraysOfArrays() As Integer Dim arrayOfArrays()() As Integer = New Integer()() {New Integer() {3, 4}, New Integer() {1}} Return arrayOfArrays(0)(1) End Function Public Shared Function ChainedConstructorUse() As String Dim t As Test2 = New Test2() Return t.accessStringField End Function Public Function ComplexExpressions(ByVal i As Integer) As Integer i = (i _ * (i + 3)) Return i End Function Public Shared Function OutputDecimalEnumVal(ByVal i As Integer) As Integer If (i = 3) Then Return CType(DecimalEnum.Num3,Integer) End If If (i = 4) Then Return CType(DecimalEnum.Num4,Integer) End If If (i = 2) Then Return CType(DecimalEnum.Num2,Integer) End If If (i = 1) Then Return CType(DecimalEnum.Num1,Integer) End If If (i = 0) Then Return CType(DecimalEnum.Num0,Integer) End If Return (i + 10) End Function Public Shared Function TestSingleInterface(ByVal i As Integer) As Integer Dim t As TestSingleInterfaceImp = New TestSingleInterfaceImp() Return t.InterfaceMethod(i) End Function Public Shared Function TestMultipleInterfaces(ByVal i As Integer) As Integer Dim t As TestMultipleInterfaceImp = New TestMultipleInterfaceImp() Dim interfaceAobject As InterfaceA = CType(t,InterfaceA) Dim interfaceBobject As InterfaceB = CType(t,InterfaceB) Return (interfaceAobject.InterfaceMethod(i) - interfaceBobject.InterfaceMethod(i)) End Function Public Shared Function NestedStructMethod() As Integer Dim varStructA As structA varStructA.innerStruct.int1 = 3 Return varStructA.innerStruct.int1 End Function Public Shared Sub Main() End Sub Public Function GoToMethod(ByVal i As Integer) As Integer If (i < 1) Then goto comehere End If Return 6 comehere: Return 7 End Function Public Shared Function CallingPublicNestedScenario(ByVal i As Integer) As Integer Dim t As PublicNestedClassA.PublicNestedClassB2.PublicNestedClassC = New PublicNestedClassA.PublicNestedClassB2.PublicNestedClassC() Return t.publicNestedClassesMethod(i) End Function Public Sub MyMethod(<System.Xml.Serialization.XmlElementAttribute(Form:=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable:=false)> ByVal blah As String) End Sub Public Shared Function PublicStaticMethod() As Integer Return 16 End Function Shared Sub Work(ByRef i As Integer, ByRef j As Integer) i = (i + 4) j = 5 End Sub Public Shared Function CallingWork(ByVal a As Integer) As Integer a = 10 Dim b As Integer TEST.Work(a, b) Return (a + b) End Function Public Function MyFunction() As <System.Xml.Serialization.XmlIgnoreAttribute(), System.Xml.Serialization.XmlRootAttribute([Namespace]:=""Namespace Value"", ElementName:=""Root, hehehe"")> String Return ""Return"" End Function Public Shared Function TestStaticConstructor(ByVal a As Integer) As Integer Dim t As Test4 = New Test4() t.i = a Return t.i End Function Public Shared Function TryCatchMethod(ByVal a As Integer) As Integer Try Finally a = (a + 5) End Try Return a End Function End Class Public Class Test2 Private stringField As String Public Sub New() Me.New(""testingString"", Nothing, Nothing) End Sub Public Sub New(ByVal p1 As String, ByVal p2 As String, ByVal p3 As String) MyBase.New Me.stringField = p1 End Sub Public Property accessStringField() As String Get Return Me.stringField End Get Set Me.stringField = value End Set End Property End Class Public Enum DecimalEnum Num0 = 0 Num1 = 1 Num2 = 2 Num3 = 3 Num4 = 4 End Enum Public Interface InterfaceA Function InterfaceMethod(ByVal a As Integer) As Integer End Interface Public Interface InterfaceB Function InterfaceMethod(ByVal a As Integer) As Integer End Interface Public Class TestMultipleInterfaceImp Inherits Object Implements InterfaceB, InterfaceA Public Function InterfaceMethod(ByVal a As Integer) As Integer Implements InterfaceA.InterfaceMethod , InterfaceB.InterfaceMethod Return a End Function End Class Public Class TestSingleInterfaceImp Inherits Object Implements InterfaceA Public Overridable Function InterfaceMethod(ByVal a As Integer) As Integer Implements InterfaceA.InterfaceMethod Return a End Function End Class Public Structure structA Public innerStruct As structB Public Structure structB Public int1 As Integer End Structure End Structure Public Class PublicNestedClassA Public Class PublicNestedClassB1 End Class Public Class PublicNestedClassB2 Public Class PublicNestedClassC Public Function publicNestedClassesMethod(ByVal a As Integer) As Integer Return a End Function End Class End Class End Class Public Class Test4 Private number As Integer Shared Sub New() End Sub Public Property i() As Integer Get Return number End Get Set number = value End Set End Property End Class End Namespace Namespace MyNamespace Public Class Test Inherits Form Private b As Button = New Button() Public Sub New() MyBase.New Me.Size = New Size(600, 600) b.Text = ""Test"" b.TabIndex = 0 b.Location = New Point(400, 525) AddHandler MyEvent, AddressOf Me.b_Click End Sub Public Event MyEvent As System.EventHandler Private Sub b_Click(ByVal sender As Object, ByVal e As System.EventArgs) End Sub End Class End Namespace"); }
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"); }
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) { // GENERATES (C#): // [assembly: System.Reflection.AssemblyTitle("MyAssembly")] // [assembly: System.Reflection.AssemblyVersion("1.0.6.2")] // [assembly: System.CLSCompliantAttribute(false)] // // namespace MyNamespace { // using System; // using System.Drawing; // using System.Windows.Forms; // using System.ComponentModel; // CodeNamespace ns = new CodeNamespace (); ns.Name = "MyNamespace"; ns.Imports.Add (new CodeNamespaceImport ("System")); ns.Imports.Add (new CodeNamespaceImport ("System.Drawing")); ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Forms")); ns.Imports.Add (new CodeNamespaceImport ("System.ComponentModel")); cu.Namespaces.Add (ns); cu.ReferencedAssemblies.Add ("System.Xml.dll"); cu.ReferencedAssemblies.Add ("System.Drawing.dll"); cu.ReferencedAssemblies.Add ("System.Windows.Forms.dll"); // Assembly Attributes if (Supports (provider, GeneratorSupport.AssemblyAttributes)) { AddScenario ("CheckAssemblyAttributes", "Check that assembly attributes get generated properly."); CodeAttributeDeclarationCollection attrs = cu.AssemblyCustomAttributes; attrs.Add (new CodeAttributeDeclaration ("System.Reflection.AssemblyTitle", new CodeAttributeArgument (new CodePrimitiveExpression ("MyAssembly")))); attrs.Add (new CodeAttributeDeclaration ("System.Reflection.AssemblyVersion", new CodeAttributeArgument (new CodePrimitiveExpression ("1.0.6.2")))); attrs.Add (new CodeAttributeDeclaration ("System.CLSCompliantAttribute", new CodeAttributeArgument (new CodePrimitiveExpression (false)))); } // GENERATES (C#): // [System.Serializable()] // [System.Obsolete("Don\'t use this Class")] // [System.Windows.Forms.AxHost.ClsidAttribute("Class.ID")] // public class MyClass { // #if !WHIDBEY if (!(provider is CSharpCodeProvider) && !(provider is VBCodeProvider) && !(provider is JScriptCodeProvider)) AddScenario ("CheckClassAttributes", "Check that class attributes get generated properly."); #else AddScenario ("CheckClassAttributes", "Check that class attributes get generated properly."); #endif CodeTypeDeclaration class1 = new CodeTypeDeclaration (); class1.Name = "MyClass"; class1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Serializable")); class1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Class")))); class1.CustomAttributes.Add (new CodeAttributeDeclaration (typeof (System.Windows.Forms.AxHost.ClsidAttribute).FullName, new CodeAttributeArgument (new CodePrimitiveExpression ("Class.ID")))); ns.Types.Add (class1); // GENERATES (C#): // [System.Obsolete("Don\'t use this Method")] // [System.ComponentModel.Editor("This", "That")] // public void MyMethod(string blah, int[] arrayit) { // } AddScenario ("CheckMyMethodAttributes", "Check that attributes are generated properly on MyMethod()."); CodeMemberMethod method1 = new CodeMemberMethod (); method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; method1.Name = "MyMethod"; method1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Method")))); method1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.ComponentModel.Editor", new CodeAttributeArgument (new CodePrimitiveExpression ("This")), new CodeAttributeArgument (new CodePrimitiveExpression ("That")))); CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression (typeof (string), "blah"); method1.Parameters.Add (param1); CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression (typeof (int[]), "arrayit"); method1.Parameters.Add (param2); class1.Members.Add (method1); // GENERATES (C#): // [System.Xml.Serialization.XmlElementAttribute()] // private string myField = "hi!"; // AddScenario ("CheckMyFieldAttributes", "Check that attributes are generated properly on MyField."); CodeMemberField field1 = new CodeMemberField (); field1.Name = "myField"; field1.Attributes = MemberAttributes.Public; field1.Type = new CodeTypeReference (typeof (string)); field1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Xml.Serialization.XmlElementAttribute")); field1.InitExpression = new CodePrimitiveExpression ("hi!"); class1.Members.Add (field1); // GENERATES (C#): // [System.Obsolete("Don\'t use this Property")] // public string MyProperty { // get { // return this.myField; // } // } AddScenario ("CheckMyPropertyAttributes", "Check that attributes are generated properly on MyProperty."); CodeMemberProperty prop1 = new CodeMemberProperty (); prop1.Attributes = MemberAttributes.Public; prop1.Name = "MyProperty"; prop1.Type = new CodeTypeReference (typeof (string)); prop1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Property")))); prop1.GetStatements.Add (new CodeMethodReturnStatement (new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), "myField"))); class1.Members.Add (prop1); // GENERATES (C#): // [System.Obsolete("Don\'t use this Constructor")] // public MyClass() { // } // } if (!(provider is JScriptCodeProvider)) AddScenario ("CheckConstructorAttributes", "Check that attributes are generated properly on the constructor."); CodeConstructor const1 = new CodeConstructor (); const1.Attributes = MemberAttributes.Public; const1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Constructor")))); class1.Members.Add (const1); if (Supports (provider, GeneratorSupport.DeclareEvents)) { // GENERATES (C#): // public class Test : Form { // // private Button b = new Button(); // // AddScenario ("CheckEventAttributes", "test attributes on an event"); class1 = new CodeTypeDeclaration ("Test"); class1.IsClass = true; class1.BaseTypes.Add (new CodeTypeReference ("Form")); ns.Types.Add (class1); CodeMemberField mfield = new CodeMemberField (new CodeTypeReference ("Button"), "b"); mfield.InitExpression = new CodeObjectCreateExpression (new CodeTypeReference ("Button")); class1.Members.Add (mfield); // GENERATES (C#): // public Test() { // this.Size = new Size(600, 600); // b.Text = "Test"; // b.TabIndex = 0; // b.Location = new Point(400, 525); // this.MyEvent += new EventHandler(this.b_Click); // } // CodeConstructor ctor = new CodeConstructor (); ctor.Attributes = MemberAttributes.Public; ctor.Statements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), "Size"), new CodeObjectCreateExpression (new CodeTypeReference ("Size"), new CodePrimitiveExpression (600), new CodePrimitiveExpression (600)))); ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"), "Text"), new CodePrimitiveExpression ("Test"))); ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"), "TabIndex"), new CodePrimitiveExpression (0))); ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"), "Location"), new CodeObjectCreateExpression (new CodeTypeReference ("Point"), new CodePrimitiveExpression (400), new CodePrimitiveExpression (525)))); ctor.Statements.Add (new CodeAttachEventStatement (new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "MyEvent"), new CodeDelegateCreateExpression (new CodeTypeReference ("EventHandler") , new CodeThisReferenceExpression (), "b_Click"))); class1.Members.Add (ctor); // GENERATES (C#): // [System.CLSCompliantAttribute(false)] // public event System.EventHandler MyEvent; CodeMemberEvent evt = new CodeMemberEvent (); evt.Name = "MyEvent"; evt.Type = new CodeTypeReference ("System.EventHandler"); evt.Attributes = MemberAttributes.Public; evt.CustomAttributes.Add (new CodeAttributeDeclaration ("System.CLSCompliantAttribute", new CodeAttributeArgument (new CodePrimitiveExpression (false)))); class1.Members.Add (evt); // GENERATES (C#): // private void b_Click(object sender, System.EventArgs e) { // } // } // } // CodeMemberMethod cmm = new CodeMemberMethod (); cmm.Name = "b_Click"; cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object), "sender")); cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (EventArgs), "e")); class1.Members.Add (cmm); } }
protected virtual void processInterface(Protocol protocol) { // Create abstract class string protocolNameMangled = CodeGenUtil.Instance.Mangle(protocol.Name); var ctd = new CodeTypeDeclaration(protocolNameMangled); ctd.TypeAttributes = TypeAttributes.Abstract | TypeAttributes.Public; ctd.IsClass = true; ctd.BaseTypes.Add("Avro.Specific.ISpecificProtocol"); AddProtocolDocumentation(protocol, ctd); // Add static protocol field. var protocolField = new CodeMemberField(); protocolField.Attributes = MemberAttributes.Private | MemberAttributes.Static | MemberAttributes.Final; protocolField.Name = "protocol"; protocolField.Type = new CodeTypeReference("readonly Avro.Protocol"); var cpe = new CodePrimitiveExpression(protocol.ToString()); var cmie = new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(Protocol)), "Parse"), new CodeExpression[] { cpe }); protocolField.InitExpression = cmie; ctd.Members.Add(protocolField); // Add overridden Protocol method. var property = new CodeMemberProperty(); property.Attributes = MemberAttributes.Public | MemberAttributes.Final; property.Name = "Protocol"; property.Type = new CodeTypeReference("Avro.Protocol"); property.HasGet = true; property.GetStatements.Add(new CodeTypeReferenceExpression("return protocol")); ctd.Members.Add(property); //var requestMethod = CreateRequestMethod(); //ctd.Members.Add(requestMethod); var requestMethod = CreateRequestMethod(); //requestMethod.Attributes |= MemberAttributes.Override; var builder = new StringBuilder(); if (protocol.Messages.Count > 0) { builder.Append("switch(messageName)\n\t\t\t{"); foreach (var a in protocol.Messages) { builder.Append("\n\t\t\t\tcase \"").Append(a.Key).Append("\":\n"); bool unused = false; string type = getType(a.Value.Response, false, ref unused); builder.Append("\t\t\t\trequestor.Request<") .Append(type) .Append(">(messageName, args, callback);\n"); builder.Append("\t\t\t\tbreak;\n"); } builder.Append("\t\t\t}"); } var cseGet = new CodeSnippetExpression(builder.ToString()); requestMethod.Statements.Add(cseGet); ctd.Members.Add(requestMethod); AddMethods(protocol, false, ctd); string nspace = protocol.Namespace; if (string.IsNullOrEmpty(nspace)) { throw new CodeGenException("Namespace required for enum schema " + nspace); } CodeNamespace codens = addNamespace(nspace); codens.Types.Add(ctd); // Create callback abstract class ctd = new CodeTypeDeclaration(protocolNameMangled + "Callback"); ctd.TypeAttributes = TypeAttributes.Abstract | TypeAttributes.Public; ctd.IsClass = true; ctd.BaseTypes.Add(protocolNameMangled); // Need to override AddProtocolDocumentation(protocol, ctd); AddMethods(protocol, true, ctd); codens.Types.Add(ctd); }
public override void ProcessDirective(string directiveName, IDictionary <string, string> arguments) { var name = arguments["name"]; var type = arguments["type"]; if (string.IsNullOrEmpty(name)) { throw new DirectiveProcessorException("Parameter directive has no name argument"); } if (string.IsNullOrEmpty(type)) { throw new DirectiveProcessorException("Parameter directive has no type argument"); } var fieldName = "_" + name + "Field"; var typeRef = new CodeTypeReference(type); var thisRef = new CodeThisReferenceExpression(); var fieldRef = new CodeFieldReferenceExpression(thisRef, fieldName); var property = new CodeMemberProperty() { Name = name, Attributes = MemberAttributes.Public | MemberAttributes.Final, HasGet = true, HasSet = false, Type = typeRef }; property.GetStatements.Add(new CodeMethodReturnStatement(fieldRef)); this.members.Add(new CodeMemberField(typeRef, fieldName)); this.members.Add(property); var acquiredName = "_" + name + "Acquired"; var valRef = new CodeVariableReferenceExpression("data"); var namePrimitive = new CodePrimitiveExpression(name); var sessionRef = new CodePropertyReferenceExpression(thisRef, "Session"); var callContextTypeRefExpr = new CodeTypeReferenceExpression("System.Runtime.Remoting.Messaging.CallContext"); var nullPrim = new CodePrimitiveExpression(null); var acquiredVariable = new CodeVariableDeclarationStatement(typeof(bool), acquiredName, new CodePrimitiveExpression(false)); var acquiredVariableRef = new CodeVariableReferenceExpression(acquiredVariable.Name); this.postStatements.Add(acquiredVariable); //checks the local called "data" can be cast and assigned to the field, and if successful, sets acquiredVariable to true var checkCastThenAssignVal = new CodeConditionStatement( new CodeMethodInvokeExpression( new CodeTypeOfExpression(typeRef), "IsAssignableFrom", new CodeMethodInvokeExpression(valRef, "GetType")), new CodeStatement[] { new CodeAssignStatement(fieldRef, new CodeCastExpression(typeRef, valRef)), new CodeAssignStatement(acquiredVariableRef, new CodePrimitiveExpression(true)), }, new CodeStatement[] { new CodeExpressionStatement(new CodeMethodInvokeExpression(thisRef, "Error", new CodePrimitiveExpression("The type '" + type + "' of the parameter '" + name + "' did not match the type passed to the template"))), }); //tries to gets the value from the session var checkSession = new CodeConditionStatement( new CodeBinaryOperatorExpression(NotNull(sessionRef), CodeBinaryOperatorType.BooleanAnd, new CodeMethodInvokeExpression(sessionRef, "ContainsKey", namePrimitive)), new CodeVariableDeclarationStatement(typeof(object), "data", new CodeIndexerExpression(sessionRef, namePrimitive)), checkCastThenAssignVal); this.postStatements.Add(checkSession); //if acquiredVariable is false, tries to gets the value from the host if (this.hostSpecific) { var hostRef = new CodePropertyReferenceExpression(thisRef, "Host"); var checkHost = new CodeConditionStatement( BooleanAnd(IsFalse(acquiredVariableRef), NotNull(hostRef)), new CodeVariableDeclarationStatement(typeof(string), "data", new CodeMethodInvokeExpression(hostRef, "ResolveParameterValue", nullPrim, nullPrim, namePrimitive)), new CodeConditionStatement(NotNull(valRef), checkCastThenAssignVal)); this.postStatements.Add(checkHost); } //if acquiredVariable is false, tries to gets the value from the call context var checkCallContext = new CodeConditionStatement( IsFalse(acquiredVariableRef), new CodeVariableDeclarationStatement(typeof(object), "data", new CodeMethodInvokeExpression(callContextTypeRefExpr, "LogicalGetData", namePrimitive)), new CodeConditionStatement(NotNull(valRef), checkCastThenAssignVal)); this.postStatements.Add(checkCallContext); }
public static CodeFieldReferenceExpression GetBackingField(this CodeMemberProperty property) { return(property.GetOrCreateUserItem <CodeFieldReferenceExpression>(BackingFieldRefKey)); }
private void GenerateProperty(CodeMemberMethod getter, CodeMemberMethod setter = null) { CodeCommentStatementCollection comments = new CodeCommentStatementCollection(); comments.AddRange(getter.Comments); getter.Comments.Clear(); if (setter != null) { comments.AddRange(setter.Comments); setter.Comments.Clear(); } if (this.type.Members.OfType<CodeSnippetTypeMember>().All( p => string.Compare(getter.Name, p.Name, StringComparison.OrdinalIgnoreCase) != 0 || p.UserData["interface"] != getter.PrivateImplementationType) && this.type.Members.OfType<CodeMemberProperty>().All( p => string.Compare(getter.Name, p.Name, StringComparison.OrdinalIgnoreCase) != 0 || p.PrivateImplementationType != getter.PrivateImplementationType)) { CodeMemberProperty property = new CodeMemberProperty(); property.Name = getter.Name; property.Type = getter.ReturnType; property.Attributes = MemberAttributes.Public; if ((getter.Attributes & MemberAttributes.Static) == MemberAttributes.Static) { property.Attributes |= MemberAttributes.Static; } if ((getter.Attributes & MemberAttributes.Final) == MemberAttributes.Final && (setter == null || (setter.Attributes & MemberAttributes.Final) == MemberAttributes.Final)) { property.Attributes |= MemberAttributes.Final; } if ((getter.Attributes & MemberAttributes.Override) == MemberAttributes.Override || (setter != null && (setter.Attributes & MemberAttributes.Override) == MemberAttributes.Override)) { property.Attributes |= MemberAttributes.Override; } property.GetStatements.AddRange(getter.Statements); if (setter != null) { CodeVariableDeclarationStatement variableStatement = setter.Statements.OfType<CodeVariableDeclarationStatement>().First(); CodeArrayCreateExpression arrayExpression = (CodeArrayCreateExpression) variableStatement.InitExpression; CodeArgumentReferenceExpression argExpression = arrayExpression.Initializers.OfType<CodeArgumentReferenceExpression>().First(); argExpression.ParameterName = "value"; property.SetStatements.AddRange(setter.Statements); } property.PrivateImplementationType = getter.PrivateImplementationType; if (property.PrivateImplementationType == null && setter != null) { property.PrivateImplementationType = setter.PrivateImplementationType; } CodeSnippetTypeMember completeProperty = AddAttributes(getter, setter, property); AddComments(completeProperty, comments, setter == null); type.Members.Add(completeProperty); if (type.Members.Contains(getter)) { type.Members.Remove(getter); } if (setter != null && this.type.Members.Contains(setter)) { type.Members.Remove(setter); } } }
public void MetadataAttributes() { var cu = new CodeCompileUnit(); var ns = new CodeNamespace(); ns.Name = "MyNamespace"; ns.Imports.Add(new CodeNamespaceImport("System")); ns.Imports.Add(new CodeNamespaceImport("System.Drawing")); ns.Imports.Add(new CodeNamespaceImport("System.Windows.Forms")); ns.Imports.Add(new CodeNamespaceImport("System.ComponentModel")); cu.Namespaces.Add(ns); var attrs = cu.AssemblyCustomAttributes; attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyTitle", new CodeAttributeArgument(new CodePrimitiveExpression("MyAssembly")))); attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyVersion", new CodeAttributeArgument(new CodePrimitiveExpression("1.0.6.2")))); attrs.Add(new CodeAttributeDeclaration("System.CLSCompliantAttribute", new CodeAttributeArgument(new CodePrimitiveExpression(false)))); var class1 = new CodeTypeDeclaration() { Name = "MyClass" }; class1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Serializable")); class1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Obsolete", new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Class")))); ns.Types.Add(class1); var nestedClass = new CodeTypeDeclaration("NestedClass") { IsClass = true, TypeAttributes = TypeAttributes.NestedPublic }; nestedClass.CustomAttributes.Add(new CodeAttributeDeclaration("System.Serializable")); class1.Members.Add(nestedClass); var method1 = new CodeMemberMethod() { Name = "MyMethod" }; method1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Obsolete", new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Method")))); method1.CustomAttributes.Add(new CodeAttributeDeclaration("System.ComponentModel.Editor", new CodeAttributeArgument(new CodePrimitiveExpression("This")), new CodeAttributeArgument(new CodePrimitiveExpression("That")))); var param1 = new CodeParameterDeclarationExpression(typeof(string), "blah"); param1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlElementAttribute", new CodeAttributeArgument("Form", new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.Xml.Schema.XmlSchemaForm"), "Unqualified")), new CodeAttributeArgument("IsNullable", new CodePrimitiveExpression(false)))); method1.Parameters.Add(param1); var param2 = new CodeParameterDeclarationExpression(typeof(int[]), "arrayit"); param2.CustomAttributes.Add( new CodeAttributeDeclaration("System.Xml.Serialization.XmlElementAttribute", new CodeAttributeArgument("Form", new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.Xml.Schema.XmlSchemaForm"), "Unqualified")), new CodeAttributeArgument("IsNullable", new CodePrimitiveExpression(false)))); method1.Parameters.Add(param2); class1.Members.Add(method1); var function1 = new CodeMemberMethod(); function1.Name = "MyFunction"; function1.ReturnType = new CodeTypeReference(typeof(string)); function1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Obsolete", new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Function")))); function1.ReturnTypeCustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlIgnoreAttribute")); function1.ReturnTypeCustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlRootAttribute", new CodeAttributeArgument("Namespace", new CodePrimitiveExpression("Namespace Value")), new CodeAttributeArgument("ElementName", new CodePrimitiveExpression("Root, hehehe")))); function1.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression("Return"))); class1.Members.Add(function1); CodeMemberMethod function2 = new CodeMemberMethod(); function2.Name = "GlobalKeywordFunction"; function2.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(ObsoleteAttribute), CodeTypeReferenceOptions.GlobalReference), new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Function")))); CodeTypeReference typeRef = new CodeTypeReference("System.Xml.Serialization.XmlIgnoreAttribute", CodeTypeReferenceOptions.GlobalReference); CodeAttributeDeclaration codeAttrib = new CodeAttributeDeclaration(typeRef); function2.ReturnTypeCustomAttributes.Add(codeAttrib); class1.Members.Add(function2); CodeMemberField field1 = new CodeMemberField(); field1.Name = "myField"; field1.Type = new CodeTypeReference(typeof(string)); field1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlElementAttribute")); field1.InitExpression = new CodePrimitiveExpression("hi!"); class1.Members.Add(field1); CodeMemberProperty prop1 = new CodeMemberProperty(); prop1.Name = "MyProperty"; prop1.Type = new CodeTypeReference(typeof(string)); prop1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Obsolete", new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Property")))); prop1.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "myField"))); class1.Members.Add(prop1); CodeConstructor const1 = new CodeConstructor(); const1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Obsolete", new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Constructor")))); class1.Members.Add(const1); class1 = new CodeTypeDeclaration("Test"); class1.IsClass = true; class1.BaseTypes.Add(new CodeTypeReference("Form")); ns.Types.Add(class1); CodeMemberField mfield = new CodeMemberField(new CodeTypeReference("Button"), "b"); mfield.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference("Button")); class1.Members.Add(mfield); CodeConstructor ctor = new CodeConstructor(); ctor.Attributes = MemberAttributes.Public; ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Size"), new CodeObjectCreateExpression(new CodeTypeReference("Size"), new CodePrimitiveExpression(600), new CodePrimitiveExpression(600)))); ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"), "Text"), new CodePrimitiveExpression("Test"))); ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"), "TabIndex"), new CodePrimitiveExpression(0))); ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"), "Location"), new CodeObjectCreateExpression(new CodeTypeReference("Point"), new CodePrimitiveExpression(400), new CodePrimitiveExpression(525)))); ctor.Statements.Add(new CodeAttachEventStatement(new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "MyEvent"), new CodeDelegateCreateExpression(new CodeTypeReference("EventHandler") , new CodeThisReferenceExpression(), "b_Click"))); class1.Members.Add(ctor); CodeMemberEvent evt = new CodeMemberEvent(); evt.Name = "MyEvent"; evt.Type = new CodeTypeReference("System.EventHandler"); evt.Attributes = MemberAttributes.Public; evt.CustomAttributes.Add(new CodeAttributeDeclaration("System.CLSCompliantAttribute", new CodeAttributeArgument(new CodePrimitiveExpression(false)))); class1.Members.Add(evt); var cmm = new CodeMemberMethod(); cmm.Name = "b_Click"; cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender")); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(EventArgs), "e")); class1.Members.Add(cmm); AssertEqual(cu, @"//------------------------------------------------------------------------------ // <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> //------------------------------------------------------------------------------ [assembly: System.Reflection.AssemblyTitle(""MyAssembly"")] [assembly: System.Reflection.AssemblyVersion(""1.0.6.2"")] [assembly: System.CLSCompliantAttribute(false)] namespace MyNamespace { using System; using System.Drawing; using System.Windows.Forms; using System.ComponentModel; [System.Serializable()] [System.Obsolete(""Don\'t use this Class"")] public class MyClass { [System.Xml.Serialization.XmlElementAttribute()] private string myField = ""hi!""; [System.Obsolete(""Don\'t use this Constructor"")] private MyClass() { } [System.Obsolete(""Don\'t use this Property"")] private string MyProperty { get { return this.myField; } } [System.Obsolete(""Don\'t use this Method"")] [System.ComponentModel.Editor(""This"", ""That"")] private void MyMethod([System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable=false)] string blah, [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable=false)] int[] arrayit) { } [System.Obsolete(""Don\'t use this Function"")] [return: System.Xml.Serialization.XmlIgnoreAttribute()] [return: System.Xml.Serialization.XmlRootAttribute(Namespace=""Namespace Value"", ElementName=""Root, hehehe"")] private string MyFunction() { return ""Return""; } [global::System.ObsoleteAttribute(""Don\'t use this Function"")] [return: global::System.Xml.Serialization.XmlIgnoreAttribute()] private void GlobalKeywordFunction() { } [System.Serializable()] public class NestedClass { } } public class Test : Form { private Button b = new Button(); public Test() { this.Size = new Size(600, 600); b.Text = ""Test""; b.TabIndex = 0; b.Location = new Point(400, 525); this.MyEvent += new EventHandler(this.b_Click); } [System.CLSCompliantAttribute(false)] public event System.EventHandler MyEvent; private void b_Click(object sender, System.EventArgs e) { } } }"); }
public void ProviderSupports() { CodeDomProvider provider = GetProvider(); var cu = new CodeCompileUnit(); var nspace = new CodeNamespace("NSPC"); nspace.Imports.Add(new CodeNamespaceImport("System")); nspace.Imports.Add(new CodeNamespaceImport("System.Drawing")); nspace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms")); nspace.Imports.Add(new CodeNamespaceImport("System.ComponentModel")); cu.Namespaces.Add(nspace); var cd = new CodeTypeDeclaration("TEST"); cd.IsClass = true; nspace.Types.Add(cd); // Arrays of Arrays var cmm = new CodeMemberMethod(); cmm.Name = "ArraysOfArrays"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public; if (provider.Supports(GeneratorSupport.ArraysOfArrays)) { cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int[][])), "arrayOfArrays", new CodeArrayCreateExpression(typeof(int[][]), new CodeArrayCreateExpression(typeof(int[]), new CodePrimitiveExpression(3), new CodePrimitiveExpression(4)), new CodeArrayCreateExpression(typeof(int[]), new CodeExpression[] { new CodePrimitiveExpression(1) })))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeArrayIndexerExpression( new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("arrayOfArrays"), new CodePrimitiveExpression(0)) , new CodePrimitiveExpression(1)))); } else { cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(0))); } cd.Members.Add(cmm); // assembly attributes if (provider.Supports(GeneratorSupport.AssemblyAttributes)) { CodeAttributeDeclarationCollection attrs = cu.AssemblyCustomAttributes; attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyTitle", new CodeAttributeArgument(new CodePrimitiveExpression("MyAssembly")))); attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyVersion", new CodeAttributeArgument(new CodePrimitiveExpression("1.0.6.2")))); } CodeTypeDeclaration class1 = new CodeTypeDeclaration(); if (provider.Supports(GeneratorSupport.ChainedConstructorArguments)) { class1.Name = "Test2"; class1.IsClass = true; nspace.Types.Add(class1); class1.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(String)), "stringField")); CodeMemberProperty prop = new CodeMemberProperty(); prop.Name = "accessStringField"; prop.Attributes = MemberAttributes.Public | MemberAttributes.Final; prop.Type = new CodeTypeReference(typeof(String)); prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "stringField"))); prop.SetStatements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "stringField"), new CodePropertySetValueReferenceExpression())); class1.Members.Add(prop); CodeConstructor cctor = new CodeConstructor(); cctor.Attributes = MemberAttributes.Public; cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression("testingString")); cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression(null)); cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression(null)); class1.Members.Add(cctor); CodeConstructor cc = new CodeConstructor(); cc.Attributes = MemberAttributes.Public | MemberAttributes.Overloaded; cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p1")); cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p2")); cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p3")); cc.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression() , "stringField"), new CodeVariableReferenceExpression("p1"))); class1.Members.Add(cc); // verify chained constructors work cmm = new CodeMemberMethod(); cmm.Name = "ChainedConstructorUse"; cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; cmm.ReturnType = new CodeTypeReference(typeof(String)); // utilize constructor cmm.Statements.Add(new CodeVariableDeclarationStatement("Test2", "t", new CodeObjectCreateExpression("Test2"))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodReferenceExpression( new CodeVariableReferenceExpression("t"), "accessStringField"))); cd.Members.Add(cmm); } // complex expressions if (provider.Supports(GeneratorSupport.ComplexExpressions)) { cmm = new CodeMemberMethod(); cmm.Name = "ComplexExpressions"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public; cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i")); cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("i"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Multiply, new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(3))))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("i"))); cd.Members.Add(cmm); } if (provider.Supports(GeneratorSupport.DeclareEnums)) { CodeTypeDeclaration ce = new CodeTypeDeclaration("DecimalEnum"); ce.IsEnum = true; nspace.Types.Add(ce); // things to enumerate for (int k = 0; k < 5; k++) { CodeMemberField Field = new CodeMemberField("System.Int32", "Num" + (k).ToString()); Field.InitExpression = new CodePrimitiveExpression(k); ce.Members.Add(Field); } cmm = new CodeMemberMethod(); cmm.Name = "OutputDecimalEnumVal"; cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i"); cmm.Parameters.Add(param); CodeBinaryOperatorExpression eq = new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(3)); CodeMethodReturnStatement truestmt = new CodeMethodReturnStatement( new CodeCastExpression(typeof(int), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num3"))); CodeConditionStatement condstmt = new CodeConditionStatement(eq, truestmt); cmm.Statements.Add(condstmt); eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(4)); truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num4"))); condstmt = new CodeConditionStatement(eq, truestmt); cmm.Statements.Add(condstmt); eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(2)); truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num2"))); condstmt = new CodeConditionStatement(eq, truestmt); cmm.Statements.Add(condstmt); eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(1)); truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num1"))); condstmt = new CodeConditionStatement(eq, truestmt); cmm.Statements.Add(condstmt); eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(0)); truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num0"))); condstmt = new CodeConditionStatement(eq, truestmt); cmm.Statements.Add(condstmt); cmm.ReturnType = new CodeTypeReference("System.int32"); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(10)))); cd.Members.Add(cmm); } if (provider.Supports(GeneratorSupport.DeclareInterfaces)) { cmm = new CodeMemberMethod(); cmm.Name = "TestSingleInterface"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i")); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; cmm.Statements.Add(new CodeVariableDeclarationStatement("TestSingleInterfaceImp", "t", new CodeObjectCreateExpression("TestSingleInterfaceImp"))); CodeMethodInvokeExpression methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t") , "InterfaceMethod"); methodinvoke.Parameters.Add(new CodeVariableReferenceExpression("i")); cmm.Statements.Add(new CodeMethodReturnStatement(methodinvoke)); cd.Members.Add(cmm); class1 = new CodeTypeDeclaration("InterfaceA"); class1.IsInterface = true; nspace.Types.Add(class1); cmm = new CodeMemberMethod(); cmm.Attributes = MemberAttributes.Public; cmm.Name = "InterfaceMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a")); class1.Members.Add(cmm); if (provider.Supports(GeneratorSupport.MultipleInterfaceMembers)) { CodeTypeDeclaration classDecl = new CodeTypeDeclaration("InterfaceB"); classDecl.IsInterface = true; nspace.Types.Add(classDecl); cmm = new CodeMemberMethod(); cmm.Name = "InterfaceMethod"; cmm.Attributes = MemberAttributes.Public; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a")); classDecl.Members.Add(cmm); CodeTypeDeclaration class2 = new CodeTypeDeclaration("TestMultipleInterfaceImp"); class2.BaseTypes.Add(new CodeTypeReference("System.Object")); class2.BaseTypes.Add(new CodeTypeReference("InterfaceB")); class2.BaseTypes.Add(new CodeTypeReference("InterfaceA")); class2.IsClass = true; nspace.Types.Add(class2); cmm = new CodeMemberMethod(); cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceA")); cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceB")); cmm.Name = "InterfaceMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a")); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final; cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a"))); class2.Members.Add(cmm); cmm = new CodeMemberMethod(); cmm.Name = "TestMultipleInterfaces"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i")); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; cmm.Statements.Add(new CodeVariableDeclarationStatement("TestMultipleInterfaceImp", "t", new CodeObjectCreateExpression("TestMultipleInterfaceImp"))); cmm.Statements.Add(new CodeVariableDeclarationStatement("InterfaceA", "interfaceAobject", new CodeCastExpression("InterfaceA", new CodeVariableReferenceExpression("t")))); cmm.Statements.Add(new CodeVariableDeclarationStatement("InterfaceB", "interfaceBobject", new CodeCastExpression("InterfaceB", new CodeVariableReferenceExpression("t")))); methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("interfaceAobject") , "InterfaceMethod"); methodinvoke.Parameters.Add(new CodeVariableReferenceExpression("i")); CodeMethodInvokeExpression methodinvoke2 = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("interfaceBobject") , "InterfaceMethod"); methodinvoke2.Parameters.Add(new CodeVariableReferenceExpression("i")); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression( methodinvoke, CodeBinaryOperatorType.Subtract, methodinvoke2))); cd.Members.Add(cmm); } class1 = new CodeTypeDeclaration("TestSingleInterfaceImp"); class1.BaseTypes.Add(new CodeTypeReference("System.Object")); class1.BaseTypes.Add(new CodeTypeReference("InterfaceA")); class1.IsClass = true; nspace.Types.Add(class1); cmm = new CodeMemberMethod(); cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceA")); cmm.Name = "InterfaceMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a")); cmm.Attributes = MemberAttributes.Public; cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a"))); class1.Members.Add(cmm); } if (provider.Supports(GeneratorSupport.DeclareValueTypes)) { CodeTypeDeclaration structA = new CodeTypeDeclaration("structA"); structA.IsStruct = true; CodeTypeDeclaration structB = new CodeTypeDeclaration("structB"); structB.Attributes = MemberAttributes.Public; structB.IsStruct = true; CodeMemberField firstInt = new CodeMemberField(typeof(int), "int1"); firstInt.Attributes = MemberAttributes.Public; structB.Members.Add(firstInt); CodeMemberField innerStruct = new CodeMemberField("structB", "innerStruct"); innerStruct.Attributes = MemberAttributes.Public; structA.Members.Add(structB); structA.Members.Add(innerStruct); nspace.Types.Add(structA); CodeMemberMethod nestedStructMethod = new CodeMemberMethod(); nestedStructMethod.Name = "NestedStructMethod"; nestedStructMethod.ReturnType = new CodeTypeReference(typeof(int)); nestedStructMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static; CodeVariableDeclarationStatement varStructA = new CodeVariableDeclarationStatement("structA", "varStructA"); nestedStructMethod.Statements.Add(varStructA); nestedStructMethod.Statements.Add ( new CodeAssignStatement ( /* Expression1 */ new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("varStructA"), "innerStruct"), "int1"), /* Expression1 */ new CodePrimitiveExpression(3) ) ); nestedStructMethod.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("varStructA"), "innerStruct"), "int1"))); cd.Members.Add(nestedStructMethod); } if (provider.Supports(GeneratorSupport.EntryPointMethod)) { CodeEntryPointMethod cep = new CodeEntryPointMethod(); cd.Members.Add(cep); } // goto statements if (provider.Supports(GeneratorSupport.GotoStatements)) { cmm = new CodeMemberMethod(); cmm.Name = "GoToMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final; CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i"); cmm.Parameters.Add(param); CodeConditionStatement condstmt = new CodeConditionStatement(new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(1)), new CodeGotoStatement("comehere")); cmm.Statements.Add(condstmt); cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(6))); cmm.Statements.Add(new CodeLabeledStatement("comehere", new CodeMethodReturnStatement(new CodePrimitiveExpression(7)))); cd.Members.Add(cmm); } if (provider.Supports(GeneratorSupport.NestedTypes)) { cmm = new CodeMemberMethod(); cmm.Name = "CallingPublicNestedScenario"; cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i")); cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference ("PublicNestedClassA+PublicNestedClassB2+PublicNestedClassC"), "t", new CodeObjectCreateExpression(new CodeTypeReference ("PublicNestedClassA+PublicNestedClassB2+PublicNestedClassC")))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t"), "publicNestedClassesMethod", new CodeVariableReferenceExpression("i")))); cd.Members.Add(cmm); class1 = new CodeTypeDeclaration("PublicNestedClassA"); class1.IsClass = true; nspace.Types.Add(class1); CodeTypeDeclaration nestedClass = new CodeTypeDeclaration("PublicNestedClassB1"); nestedClass.IsClass = true; nestedClass.TypeAttributes = TypeAttributes.NestedPublic; class1.Members.Add(nestedClass); nestedClass = new CodeTypeDeclaration("PublicNestedClassB2"); nestedClass.TypeAttributes = TypeAttributes.NestedPublic; nestedClass.IsClass = true; class1.Members.Add(nestedClass); CodeTypeDeclaration innerNestedClass = new CodeTypeDeclaration("PublicNestedClassC"); innerNestedClass.TypeAttributes = TypeAttributes.NestedPublic; innerNestedClass.IsClass = true; nestedClass.Members.Add(innerNestedClass); cmm = new CodeMemberMethod(); cmm.Name = "publicNestedClassesMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a")); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final; cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a"))); innerNestedClass.Members.Add(cmm); } // Parameter Attributes if (provider.Supports(GeneratorSupport.ParameterAttributes)) { CodeMemberMethod method1 = new CodeMemberMethod(); method1.Name = "MyMethod"; method1.Attributes = MemberAttributes.Public | MemberAttributes.Final; CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(string), "blah"); param1.CustomAttributes.Add( new CodeAttributeDeclaration( "System.Xml.Serialization.XmlElementAttribute", new CodeAttributeArgument( "Form", new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.Xml.Schema.XmlSchemaForm"), "Unqualified")), new CodeAttributeArgument( "IsNullable", new CodePrimitiveExpression(false)))); method1.Parameters.Add(param1); cd.Members.Add(method1); } // public static members if (provider.Supports(GeneratorSupport.PublicStaticMembers)) { cmm = new CodeMemberMethod(); cmm.Name = "PublicStaticMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(16))); cd.Members.Add(cmm); } // reference parameters if (provider.Supports(GeneratorSupport.ReferenceParameters)) { cmm = new CodeMemberMethod(); cmm.Name = "Work"; cmm.ReturnType = new CodeTypeReference("System.void"); cmm.Attributes = MemberAttributes.Static; // add parameter with ref direction CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i"); param.Direction = FieldDirection.Ref; cmm.Parameters.Add(param); // add parameter with out direction param = new CodeParameterDeclarationExpression(typeof(int), "j"); param.Direction = FieldDirection.Out; cmm.Parameters.Add(param); cmm.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("i"), new CodeBinaryOperatorExpression(new CodeArgumentReferenceExpression("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(4)))); cmm.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("j"), new CodePrimitiveExpression(5))); cd.Members.Add(cmm); cmm = new CodeMemberMethod(); cmm.Name = "CallingWork"; cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; CodeParameterDeclarationExpression parames = new CodeParameterDeclarationExpression(typeof(int), "a"); cmm.Parameters.Add(parames); cmm.ReturnType = new CodeTypeReference("System.int32"); cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"), new CodePrimitiveExpression(10))); cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "b")); // invoke the method called "work" CodeMethodInvokeExpression methodinvoked = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression (new CodeTypeReferenceExpression("TEST"), "Work")); // add parameter with ref direction CodeDirectionExpression parameter = new CodeDirectionExpression(FieldDirection.Ref, new CodeVariableReferenceExpression("a")); methodinvoked.Parameters.Add(parameter); // add parameter with out direction parameter = new CodeDirectionExpression(FieldDirection.Out, new CodeVariableReferenceExpression("b")); methodinvoked.Parameters.Add(parameter); cmm.Statements.Add(methodinvoked); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression (new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression("b")))); cd.Members.Add(cmm); } if (provider.Supports(GeneratorSupport.ReturnTypeAttributes)) { CodeMemberMethod function1 = new CodeMemberMethod(); function1.Name = "MyFunction"; function1.ReturnType = new CodeTypeReference(typeof(string)); function1.Attributes = MemberAttributes.Public | MemberAttributes.Final; function1.ReturnTypeCustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlIgnoreAttribute")); function1.ReturnTypeCustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlRootAttribute", new CodeAttributeArgument("Namespace", new CodePrimitiveExpression("Namespace Value")), new CodeAttributeArgument("ElementName", new CodePrimitiveExpression("Root, hehehe")))); function1.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression("Return"))); cd.Members.Add(function1); } if (provider.Supports(GeneratorSupport.StaticConstructors)) { cmm = new CodeMemberMethod(); cmm.Name = "TestStaticConstructor"; cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; cmm.ReturnType = new CodeTypeReference(typeof(int)); CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a"); cmm.Parameters.Add(param); // utilize constructor cmm.Statements.Add(new CodeVariableDeclarationStatement("Test4", "t", new CodeObjectCreateExpression("Test4"))); // set then get number cmm.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("t"), "i") , new CodeVariableReferenceExpression("a"))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodReferenceExpression( new CodeVariableReferenceExpression("t"), "i"))); cd.Members.Add(cmm); class1 = new CodeTypeDeclaration(); class1.Name = "Test4"; class1.IsClass = true; nspace.Types.Add(class1); class1.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(int)), "number")); CodeMemberProperty prop = new CodeMemberProperty(); prop.Name = "i"; prop.Attributes = MemberAttributes.Public | MemberAttributes.Final; prop.Type = new CodeTypeReference(typeof(int)); prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("number"))); prop.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("number"), new CodePropertySetValueReferenceExpression())); class1.Members.Add(prop); CodeTypeConstructor ctc = new CodeTypeConstructor(); class1.Members.Add(ctc); } if (provider.Supports(GeneratorSupport.TryCatchStatements)) { cmm = new CodeMemberMethod(); cmm.Name = "TryCatchMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a"); cmm.Parameters.Add(param); CodeTryCatchFinallyStatement tcfstmt = new CodeTryCatchFinallyStatement(); tcfstmt.FinallyStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(5)))); cmm.Statements.Add(tcfstmt); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a"))); cd.Members.Add(cmm); } if (provider.Supports(GeneratorSupport.DeclareEvents)) { CodeNamespace ns = new CodeNamespace(); ns.Name = "MyNamespace"; ns.Imports.Add(new CodeNamespaceImport("System")); ns.Imports.Add(new CodeNamespaceImport("System.Drawing")); ns.Imports.Add(new CodeNamespaceImport("System.Windows.Forms")); ns.Imports.Add(new CodeNamespaceImport("System.ComponentModel")); cu.Namespaces.Add(ns); class1 = new CodeTypeDeclaration("Test"); class1.IsClass = true; class1.BaseTypes.Add(new CodeTypeReference("Form")); ns.Types.Add(class1); CodeMemberField mfield = new CodeMemberField(new CodeTypeReference("Button"), "b"); mfield.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference("Button")); class1.Members.Add(mfield); CodeConstructor ctor = new CodeConstructor(); ctor.Attributes = MemberAttributes.Public; ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Size"), new CodeObjectCreateExpression(new CodeTypeReference("Size"), new CodePrimitiveExpression(600), new CodePrimitiveExpression(600)))); ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"), "Text"), new CodePrimitiveExpression("Test"))); ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"), "TabIndex"), new CodePrimitiveExpression(0))); ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"), "Location"), new CodeObjectCreateExpression(new CodeTypeReference("Point"), new CodePrimitiveExpression(400), new CodePrimitiveExpression(525)))); ctor.Statements.Add(new CodeAttachEventStatement(new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "MyEvent"), new CodeDelegateCreateExpression(new CodeTypeReference("EventHandler") , new CodeThisReferenceExpression(), "b_Click"))); class1.Members.Add(ctor); CodeMemberEvent evt = new CodeMemberEvent(); evt.Name = "MyEvent"; evt.Type = new CodeTypeReference("System.EventHandler"); evt.Attributes = MemberAttributes.Public; class1.Members.Add(evt); cmm = new CodeMemberMethod(); cmm.Name = "b_Click"; cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender")); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(EventArgs), "e")); class1.Members.Add(cmm); } AssertEqual(cu, @"//------------------------------------------------------------------------------ // <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> //------------------------------------------------------------------------------ [assembly: System.Reflection.AssemblyTitle(""MyAssembly"")] [assembly: System.Reflection.AssemblyVersion(""1.0.6.2"")] namespace NSPC { using System; using System.Drawing; using System.Windows.Forms; using System.ComponentModel; public class TEST { public int ArraysOfArrays() { int[][] arrayOfArrays = new int[][] { new int[] { 3, 4}, new int[] { 1}}; return arrayOfArrays[0][1]; } public static string ChainedConstructorUse() { Test2 t = new Test2(); return t.accessStringField; } public int ComplexExpressions(int i) { i = (i * (i + 3)); return i; } public static int OutputDecimalEnumVal(int i) { if ((i == 3)) { return ((int)(DecimalEnum.Num3)); } if ((i == 4)) { return ((int)(DecimalEnum.Num4)); } if ((i == 2)) { return ((int)(DecimalEnum.Num2)); } if ((i == 1)) { return ((int)(DecimalEnum.Num1)); } if ((i == 0)) { return ((int)(DecimalEnum.Num0)); } return (i + 10); } public static int TestSingleInterface(int i) { TestSingleInterfaceImp t = new TestSingleInterfaceImp(); return t.InterfaceMethod(i); } public static int TestMultipleInterfaces(int i) { TestMultipleInterfaceImp t = new TestMultipleInterfaceImp(); InterfaceA interfaceAobject = ((InterfaceA)(t)); InterfaceB interfaceBobject = ((InterfaceB)(t)); return (interfaceAobject.InterfaceMethod(i) - interfaceBobject.InterfaceMethod(i)); } public static int NestedStructMethod() { structA varStructA; varStructA.innerStruct.int1 = 3; return varStructA.innerStruct.int1; } public static void Main() { } public int GoToMethod(int i) { if ((i < 1)) { goto comehere; } return 6; comehere: return 7; } public static int CallingPublicNestedScenario(int i) { PublicNestedClassA.PublicNestedClassB2.PublicNestedClassC t = new PublicNestedClassA.PublicNestedClassB2.PublicNestedClassC(); return t.publicNestedClassesMethod(i); } public void MyMethod([System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable=false)] string blah) { } public static int PublicStaticMethod() { return 16; } static void Work(ref int i, out int j) { i = (i + 4); j = 5; } public static int CallingWork(int a) { a = 10; int b; TEST.Work(ref a, out b); return (a + b); } [return: System.Xml.Serialization.XmlIgnoreAttribute()] [return: System.Xml.Serialization.XmlRootAttribute(Namespace=""Namespace Value"", ElementName=""Root, hehehe"")] public string MyFunction() { return ""Return""; } public static int TestStaticConstructor(int a) { Test4 t = new Test4(); t.i = a; return t.i; } public static int TryCatchMethod(int a) { try { } finally { a = (a + 5); } return a; } } public class Test2 { private string stringField; public Test2() : this(""testingString"", null, null) { } public Test2(string p1, string p2, string p3) { this.stringField = p1; } public string accessStringField { get { return this.stringField; } set { this.stringField = value; } } } public enum DecimalEnum { Num0 = 0, Num1 = 1, Num2 = 2, Num3 = 3, Num4 = 4, } public interface InterfaceA { int InterfaceMethod(int a); } public interface InterfaceB { int InterfaceMethod(int a); } public class TestMultipleInterfaceImp : object, InterfaceB, InterfaceA { public int InterfaceMethod(int a) { return a; } } public class TestSingleInterfaceImp : object, InterfaceA { public virtual int InterfaceMethod(int a) { return a; } } public struct structA { public structB innerStruct; public struct structB { public int int1; } } public class PublicNestedClassA { public class PublicNestedClassB1 { } public class PublicNestedClassB2 { public class PublicNestedClassC { public int publicNestedClassesMethod(int a) { return a; } } } } public class Test4 { private int number; static Test4() { } public int i { get { return number; } set { number = value; } } } } namespace MyNamespace { using System; using System.Drawing; using System.Windows.Forms; using System.ComponentModel; public class Test : Form { private Button b = new Button(); public Test() { this.Size = new Size(600, 600); b.Text = ""Test""; b.TabIndex = 0; b.Location = new Point(400, 525); this.MyEvent += new EventHandler(this.b_Click); } public event System.EventHandler MyEvent; private void b_Click(object sender, System.EventArgs e) { } } }"); }
public void GlobalKeyword() { CodeNamespace ns = new CodeNamespace("Foo"); ns.Comments.Add(new CodeCommentStatement("Foo namespace")); var cd = new CodeTypeDeclaration("Foo"); ns.Types.Add(cd); string fieldName1 = "_verifyGlobalGeneration1"; CodeMemberField field = new CodeMemberField(); field.Name = fieldName1; field.Type = new CodeTypeReference(typeof(int), CodeTypeReferenceOptions.GlobalReference); field.Attributes = MemberAttributes.Public; field.InitExpression = new CodePrimitiveExpression(int.MaxValue); cd.Members.Add(field); string fieldName2 = "_verifyGlobalGeneration2"; CodeMemberField field2 = new CodeMemberField(); field2.Name = fieldName2; CodeTypeReference typeRef = new CodeTypeReference("System.Nullable", CodeTypeReferenceOptions.GlobalReference); typeRef.TypeArguments.Add(new CodeTypeReference(typeof(int), CodeTypeReferenceOptions.GlobalReference)); field2.Type = typeRef; field2.InitExpression = new CodePrimitiveExpression(0); cd.Members.Add(field2); CodeMemberMethod method1 = new CodeMemberMethod(); method1.Name = "TestMethod01"; method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public | MemberAttributes.Static; method1.ReturnType = new CodeTypeReference(typeof(int)); method1.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(int.MaxValue))); cd.Members.Add(method1); CodeMemberMethod method2 = new CodeMemberMethod(); method2.Name = "TestMethod02"; method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; method2.ReturnType = new CodeTypeReference(typeof(int)); method2.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "iReturn")); CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression( new CodeMethodReferenceExpression( new CodeTypeReferenceExpression(new CodeTypeReference("Foo.Foo", CodeTypeReferenceOptions.GlobalReference)), "TestMethod01")); CodeAssignStatement cas = new CodeAssignStatement(new CodeVariableReferenceExpression("iReturn"), cmie); method2.Statements.Add(cas); method2.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("iReturn"))); cd.Members.Add(method2); CodeMemberMethod method3 = new CodeMemberMethod(); method3.Name = "TestMethod03"; method3.Attributes = (method3.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; method3.ReturnType = new CodeTypeReference(typeof(int)); method3.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "iReturn")); CodeTypeReferenceOptions ctro = CodeTypeReferenceOptions.GlobalReference; CodeTypeReference ctr = new CodeTypeReference(typeof(Math), ctro); cmie = new CodeMethodInvokeExpression( new CodeMethodReferenceExpression( new CodeTypeReferenceExpression(ctr), "Abs"), new CodeExpression[] { new CodePrimitiveExpression(-1) }); cas = new CodeAssignStatement(new CodeVariableReferenceExpression("iReturn"), cmie); method3.Statements.Add(cas); method3.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("iReturn"))); cd.Members.Add(method3); CodeMemberProperty property = new CodeMemberProperty(); property.Name = "GlobalTestProperty1"; property.Type = new CodeTypeReference(typeof(int)); property.Attributes = (property.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; property.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(fieldName1))); property.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(fieldName1), new CodeVariableReferenceExpression("value"))); cd.Members.Add(property); CodeMemberProperty property2 = new CodeMemberProperty(); property2.Name = "GlobalTestProperty2"; property2.Type = typeRef; property2.Attributes = (property.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; property2.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(fieldName2))); property2.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(fieldName2), new CodeVariableReferenceExpression("value"))); cd.Members.Add(property2); AssertEqual(ns, @"// Foo namespace namespace Foo { public class Foo { public int _verifyGlobalGeneration1 = 2147483647; private global::System.Nullable<int> _verifyGlobalGeneration2 = 0; public int GlobalTestProperty1 { get { return _verifyGlobalGeneration1; } set { _verifyGlobalGeneration1 = value; } } public global::System.Nullable<int> GlobalTestProperty2 { get { return _verifyGlobalGeneration2; } set { _verifyGlobalGeneration2 = value; } } public static int TestMethod01() { return 2147483647; } public int TestMethod02() { int iReturn; iReturn = global::Foo.Foo.TestMethod01(); return iReturn; } public int TestMethod03() { int iReturn; iReturn = global::System.Math.Abs(-1); return iReturn; } } }"); }
public void Indexers() { var nspace = new CodeNamespace("NSPC"); var cd = new CodeTypeDeclaration("TEST"); cd.IsClass = true; nspace.Types.Add(cd); CodeMemberField field = new CodeMemberField(); field.Name = "PublicField"; field.InitExpression = new CodeArrayCreateExpression(new CodeTypeReference(typeof(int)), new CodeExpression[]{ new CodePrimitiveExpression(0), new CodePrimitiveExpression(0),new CodePrimitiveExpression(0),new CodePrimitiveExpression(0), new CodePrimitiveExpression(0),new CodePrimitiveExpression(0), new CodePrimitiveExpression(0)}); field.Attributes = MemberAttributes.Public | MemberAttributes.Final; field.Type = new CodeTypeReference(typeof(int[])); cd.Members.Add(field); // nonarray indexers CodeMemberProperty indexerProperty = new CodeMemberProperty(); indexerProperty.Name = "Item"; indexerProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final; indexerProperty.Type = new CodeTypeReference(typeof(int)); indexerProperty.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i")); // uses array indexer indexerProperty.SetStatements.Add(new CodeAssignStatement(new CodeArrayIndexerExpression( new CodeFieldReferenceExpression(new CodeThisReferenceExpression() , "PublicField"), new CodeExpression[] { new CodeVariableReferenceExpression("i") }), new CodeVariableReferenceExpression("value"))); indexerProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeArrayIndexerExpression( new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "PublicField"), new CodeVariableReferenceExpression("i")))); cd.Members.Add(indexerProperty); // nonarray indexers indexerProperty = new CodeMemberProperty(); indexerProperty.Name = "Item"; indexerProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final; indexerProperty.Type = new CodeTypeReference(typeof(int)); indexerProperty.SetStatements.Add(new CodeAssignStatement(new CodeArrayIndexerExpression( new CodeFieldReferenceExpression(new CodeThisReferenceExpression() , "PublicField"), new CodeExpression[] { new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression("b"))}), new CodeVariableReferenceExpression("value"))); indexerProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeArrayIndexerExpression( new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "PublicField"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression("b"))))); indexerProperty.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "a")); indexerProperty.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "b")); // uses array indexer cd.Members.Add(indexerProperty); cd = new CodeTypeDeclaration("UseTEST"); cd.IsClass = true; nspace.Types.Add(cd); var cmm = new CodeMemberMethod(); cmm.Name = "TestMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i")); cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public; cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("TEST"), "temp", new CodeObjectCreateExpression("TEST"))); cmm.Statements.Add(new CodeAssignStatement(new CodeIndexerExpression( new CodeVariableReferenceExpression("temp"), new CodeExpression[] { new CodePrimitiveExpression(1) }), new CodeVariableReferenceExpression("i"))); cmm.Statements.Add(new CodeAssignStatement(new CodeIndexerExpression( new CodeVariableReferenceExpression("temp"), new CodeExpression[]{new CodePrimitiveExpression(2), new CodePrimitiveExpression(4)}), new CodePrimitiveExpression(83))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression( new CodeIndexerExpression(new CodeVariableReferenceExpression("temp"), new CodeExpression[] { new CodePrimitiveExpression(1) }), CodeBinaryOperatorType.Add, new CodeIndexerExpression(new CodeVariableReferenceExpression("temp"), new CodeExpression[] { new CodePrimitiveExpression(2), new CodePrimitiveExpression(4) })))); cd.Members.Add(cmm); AssertEqual(nspace, @"namespace NSPC { public class TEST { public int[] PublicField = new int[] { 0, 0, 0, 0, 0, 0, 0}; public int this[int i] { get { return this.PublicField[i]; } set { this.PublicField[i] = value; } } public int this[int a, int b] { get { return this.PublicField[(a + b)]; } set { this.PublicField[(a + b)] = value; } } } public class UseTEST { public int TestMethod(int i) { TEST temp = new TEST(); temp[1] = i; temp[2, 4] = 83; return (temp[1] + temp[2, 4]); } } }"); }
public void Properties() { CodeNamespace ns = new CodeNamespace("NS"); ns.Imports.Add(new CodeNamespaceImport("System")); // create a class CodeTypeDeclaration class1 = new CodeTypeDeclaration(); class1.Name = "Test"; class1.IsClass = true; class1.BaseTypes.Add(new CodeTypeReference(typeof(Exception))); ns.Types.Add(class1); CodeMemberField int1 = new CodeMemberField(typeof(int), "int1"); class1.Members.Add(int1); CodeMemberField tempString = new CodeMemberField(typeof(string), "tempString"); class1.Members.Add(tempString); // basic property with get/set CodeMemberProperty prop1 = new CodeMemberProperty(); prop1.Name = "prop1"; prop1.Type = new CodeTypeReference(typeof(int)); prop1.Attributes = MemberAttributes.Public; prop1.HasGet = true; prop1.HasSet = true; prop1.GetStatements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("int1"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1)))); prop1.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("int1"), new CodeVariableReferenceExpression("value"))); class1.Members.Add(prop1); // override Property CodeMemberProperty overrideProp = new CodeMemberProperty(); overrideProp.Name = "Text"; overrideProp.Type = new CodeTypeReference(typeof(string)); overrideProp.Attributes = MemberAttributes.Public | MemberAttributes.Override; overrideProp.HasGet = true; overrideProp.HasSet = true; overrideProp.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("tempString"), new CodeVariableReferenceExpression("value"))); overrideProp.GetStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression("Hello World"))); class1.Members.Add(overrideProp); foreach (MemberAttributes attrs in new[] { MemberAttributes.Private, MemberAttributes.Family, MemberAttributes.Assembly }) { CodeMemberProperty configuredProp = new CodeMemberProperty(); configuredProp.Name = attrs.ToString() + "Prop"; configuredProp.Type = new CodeTypeReference(typeof(int)); configuredProp.Attributes = attrs; configuredProp.HasGet = true; configuredProp.HasSet = true; configuredProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("int1"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1)))); configuredProp.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("int1"), new CodeVariableReferenceExpression("value"))); class1.Members.Add(configuredProp); } // Static property CodeMemberProperty staticProp = new CodeMemberProperty(); staticProp.Name = "staticProp"; staticProp.Type = new CodeTypeReference(typeof(int)); staticProp.Attributes = MemberAttributes.Public | MemberAttributes.Static; staticProp.HasGet = true; staticProp.GetStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(99))); class1.Members.Add(staticProp); // this reference CodeMemberMethod thisRef = new CodeMemberMethod(); thisRef.Name = "thisRef"; thisRef.ReturnType = new CodeTypeReference(typeof(int)); thisRef.Attributes = MemberAttributes.Public; CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "value"); thisRef.Parameters.Add(param); thisRef.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "privProp1"), new CodeVariableReferenceExpression("value"))); thisRef.Statements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "privProp1"))); class1.Members.Add(thisRef); // set value CodeMemberMethod setProp = new CodeMemberMethod(); setProp.Name = "setProp"; setProp.ReturnType = new CodeTypeReference(typeof(int)); setProp.Attributes = MemberAttributes.Public; CodeParameterDeclarationExpression intParam = new CodeParameterDeclarationExpression(typeof(int), "value"); setProp.Parameters.Add(intParam); setProp.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "prop1"), new CodeVariableReferenceExpression("value"))); setProp.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("int1"))); class1.Members.Add(setProp); AssertEqual(ns, @"namespace NS { using System; public class Test : System.Exception { private int int1; private string tempString; public virtual int prop1 { get { return (int1 + 1); } set { int1 = value; } } public override string Text { get { return ""Hello World""; } set { tempString = value; } } private int PrivateProp { get { return (int1 + 1); } set { int1 = value; } } protected virtual int FamilyProp { get { return (int1 + 1); } set { int1 = value; } } internal virtual int AssemblyProp { get { return (int1 + 1); } set { int1 = value; } } public static int staticProp { get { return 99; } } public virtual int thisRef(int value) { this.privProp1 = value; return this.privProp1; } public virtual int setProp(int value) { this.prop1 = value; return int1; } } }"); }
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) { // GENERATES (C#): // [assembly: System.Reflection.AssemblyTitle("MyAssembly")] // [assembly: System.Reflection.AssemblyVersion("1.0.6.2")] // [assembly: System.CLSCompliantAttribute(false)] // // namespace MyNamespace { // using System; // using System.Drawing; // using System.Windows.Forms; // using System.ComponentModel; // CodeNamespace ns = new CodeNamespace (); ns.Name = "MyNamespace"; ns.Imports.Add (new CodeNamespaceImport ("System")); ns.Imports.Add (new CodeNamespaceImport ("System.Drawing")); ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Forms")); ns.Imports.Add (new CodeNamespaceImport ("System.ComponentModel")); cu.Namespaces.Add (ns); cu.ReferencedAssemblies.Add ("System.Xml.dll"); cu.ReferencedAssemblies.Add ("System.Drawing.dll"); cu.ReferencedAssemblies.Add ("System.Windows.Forms.dll"); // Assembly Attributes if (Supports (provider, GeneratorSupport.AssemblyAttributes)) { AddScenario ("CheckAssemblyAttributes", "Check that assembly attributes get generated properly."); CodeAttributeDeclarationCollection attrs = cu.AssemblyCustomAttributes; attrs.Add (new CodeAttributeDeclaration ("System.Reflection.AssemblyTitle", new CodeAttributeArgument (new CodePrimitiveExpression ("MyAssembly")))); attrs.Add (new CodeAttributeDeclaration ("System.Reflection.AssemblyVersion", new CodeAttributeArgument (new CodePrimitiveExpression ("1.0.6.2")))); attrs.Add (new CodeAttributeDeclaration ("System.CLSCompliantAttribute", new CodeAttributeArgument (new CodePrimitiveExpression (false)))); } // GENERATES (C#): // [System.Serializable()] // [System.Obsolete("Don\'t use this Class")] // [System.Windows.Forms.AxHost.ClsidAttribute("Class.ID")] // public class MyClass { // #if !WHIDBEY // Everett versions of C# and VB code providers will never have these generated properly if (!(provider is CSharpCodeProvider) && !(provider is VBCodeProvider) && !(provider is JScriptCodeProvider)) AddScenario ("CheckClassAttributes", "Check that class attributes get generated properly."); #else AddScenario ("CheckClassAttributes", "Check that class attributes get generated properly."); #endif CodeTypeDeclaration class1 = new CodeTypeDeclaration (); class1.Name = "MyClass"; class1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Serializable")); class1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Class")))); class1.CustomAttributes.Add (new CodeAttributeDeclaration (typeof (System.Windows.Forms.AxHost.ClsidAttribute).FullName, new CodeAttributeArgument (new CodePrimitiveExpression ("Class.ID")))); ns.Types.Add (class1); // GENERATES (C#): // [System.Serializable()] // public class NestedClass { // } if (Supports (provider, GeneratorSupport.NestedTypes)) { #if !WHIDBEY // Everett versions of C# and VB code providers will never have these generated properly if (!(provider is CSharpCodeProvider) && !(provider is VBCodeProvider) && !(provider is JScriptCodeProvider)) AddScenario ("CheckNestedClassAttributes", "Check that nested class attributes get generated properly."); #else AddScenario ("CheckNestedClassAttributes", "Check that nested class attributes get generated properly."); #endif CodeTypeDeclaration nestedClass = new CodeTypeDeclaration ("NestedClass"); nestedClass.TypeAttributes = TypeAttributes.NestedPublic; nestedClass.IsClass = true; nestedClass.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Serializable")); class1.Members.Add (nestedClass); } // GENERATES (C#): // [System.Obsolete("Don\'t use this Method")] // [System.ComponentModel.Editor("This", "That")] // public void MyMethod([System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable=false)] string blah, [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable=false)] int[] arrayit) { // } AddScenario ("CheckMyMethodAttributes", "Check that attributes are generated properly on MyMethod()."); CodeMemberMethod method1 = new CodeMemberMethod (); method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; method1.Name = "MyMethod"; method1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Method")))); method1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.ComponentModel.Editor", new CodeAttributeArgument (new CodePrimitiveExpression ("This")), new CodeAttributeArgument (new CodePrimitiveExpression ("That")))); CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression (typeof (string), "blah"); if (Supports (provider, GeneratorSupport.ParameterAttributes)) { AddScenario ("CheckParameterAttributes", "Check that parameter attributes are generated properly."); param1.CustomAttributes.Add ( new CodeAttributeDeclaration ( "System.Xml.Serialization.XmlElement", new CodeAttributeArgument ( "Form", new CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("System.Xml.Schema.XmlSchemaForm"), "Unqualified")), new CodeAttributeArgument ( "IsNullable", new CodePrimitiveExpression (false)))); } method1.Parameters.Add (param1); CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression (typeof (int[]), "arrayit"); if (Supports (provider, GeneratorSupport.ParameterAttributes)) { param2.CustomAttributes.Add ( new CodeAttributeDeclaration ( "System.Xml.Serialization.XmlElement", new CodeAttributeArgument ( "Form", new CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("System.Xml.Schema.XmlSchemaForm"), "Unqualified")), new CodeAttributeArgument ( "IsNullable", new CodePrimitiveExpression (false)))); } //param2.CustomAttributes.Add(new CodeAttributeDeclaration("System.ParamArray")); method1.Parameters.Add (param2); class1.Members.Add (method1); // GENERATES (C#): // [System.Obsolete("Don\'t use this Function")] // [return: System.Xml.Serialization.XmlIgnoreAttribute()] // [return: System.Xml.Serialization.XmlRootAttribute(Namespace="Namespace Value", ElementName="Root, hehehe")] // public string MyFunction() { // return "Return"; // } // if (Supports (provider, GeneratorSupport.ReturnTypeAttributes)) { AddScenario ("CheckMyFunctionAttributes", "Check return type attributes."); CodeMemberMethod function1 = new CodeMemberMethod (); function1.Attributes = MemberAttributes.Public; function1.Name = "MyFunction"; function1.ReturnType = new CodeTypeReference (typeof (string)); function1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Function")))); function1.ReturnTypeCustomAttributes.Add (new CodeAttributeDeclaration ("System.Xml.Serialization.XmlIgnoreAttribute")); function1.ReturnTypeCustomAttributes.Add (new CodeAttributeDeclaration ("System.Xml.Serialization.XmlRootAttribute", new CodeAttributeArgument ("Namespace", new CodePrimitiveExpression ("Namespace Value")), new CodeAttributeArgument ("ElementName", new CodePrimitiveExpression ("Root, hehehe")))); function1.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression ("Return"))); class1.Members.Add (function1); } // GENERATES (C#): // [System.Xml.Serialization.XmlElementAttribute()] // private string myField = "hi!"; // AddScenario ("CheckMyFieldAttributes", "Check that attributes are generated properly on MyField."); CodeMemberField field1 = new CodeMemberField (); field1.Name = "myField"; field1.Attributes = MemberAttributes.Public; field1.Type = new CodeTypeReference (typeof (string)); field1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Xml.Serialization.XmlElementAttribute")); field1.InitExpression = new CodePrimitiveExpression ("hi!"); class1.Members.Add (field1); // GENERATES (C#): // [System.Obsolete("Don\'t use this Property")] // public string MyProperty { // get { // return this.myField; // } // } AddScenario ("CheckMyPropertyAttributes", "Check that attributes are generated properly on MyProperty."); CodeMemberProperty prop1 = new CodeMemberProperty (); prop1.Attributes = MemberAttributes.Public; prop1.Name = "MyProperty"; prop1.Type = new CodeTypeReference (typeof (string)); prop1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Property")))); prop1.GetStatements.Add (new CodeMethodReturnStatement (new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), "myField"))); class1.Members.Add (prop1); // GENERATES (C#): // [System.Obsolete("Don\'t use this Constructor")] // public MyClass() { // } if (!(provider is JScriptCodeProvider)) AddScenario ("CheckConstructorAttributes", "Check that attributes are generated properly on the constructor."); CodeConstructor const1 = new CodeConstructor (); const1.Attributes = MemberAttributes.Public; const1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Constructor")))); class1.Members.Add (const1); // GENERATES (C#): // [System.Obsolete("Don\'t use this Constructor")] // static MyClass() { // } if (Supports (provider, GeneratorSupport.StaticConstructors)) { // C#, VB and JScript code providers don't generate this properly. This will // be fixed in Beta2 (with the exception of JScript code provider. JScript doesn't // support static constructor custom attributes) //if (!(provider is CSharpCodeProvider) && !(provider is VBCodeProvider) && !(provider is JScriptCodeProvider)) { AddScenario ("CheckStaticConstructorAttributes", "Check that attributes are generated properly on type constructors."); //} CodeTypeConstructor typecons = new CodeTypeConstructor (); typecons.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Constructor")))); class1.Members.Add (typecons); } // GENERATES (C#): // [System.Obsolete ("Don\'t use this entry point")] // public static void Main () { // } if (Supports (provider, GeneratorSupport.EntryPointMethod)) { // C#, VB and JScript code providers don't generate this properly. This will // be fixed in Beta2 (with the exception of JScript code provider. JScript doesn't // support static constructor custom attributes) ///if (!(provider is CSharpCodeProvider) && !(provider is VBCodeProvider) && !(provider is JScriptCodeProvider)) { AddScenario ("CheckEntryPointMethodAttributes", "Check that attributes are generated properly on entry point methods."); //} CodeEntryPointMethod entpoint = new CodeEntryPointMethod (); entpoint.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this entry point")))); class1.Members.Add (entpoint); } if (Supports (provider, GeneratorSupport.DeclareDelegates)) { AddScenario ("CheckDelegateAttributes"); CodeTypeDelegate del = new CodeTypeDelegate ("MyDelegate"); del.TypeAttributes = TypeAttributes.Public; del.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this delegate")))); ns.Types.Add (del); } if (Supports (provider, GeneratorSupport.DeclareEvents)) { // GENERATES (C#): // public class Test : Form { // // private Button b = new Button(); // // AddScenario ("CheckEventAttributes", "test attributes on an event"); class1 = new CodeTypeDeclaration ("Test"); class1.IsClass = true; class1.BaseTypes.Add (new CodeTypeReference ("Form")); ns.Types.Add (class1); CodeMemberField mfield = new CodeMemberField (new CodeTypeReference ("Button"), "b"); mfield.InitExpression = new CodeObjectCreateExpression (new CodeTypeReference ("Button")); class1.Members.Add (mfield); // GENERATES (C#): // public Test() { // this.Size = new Size(600, 600); // b.Text = "Test"; // b.TabIndex = 0; // b.Location = new Point(400, 525); // this.MyEvent += new EventHandler(this.b_Click); // } // CodeConstructor ctor = new CodeConstructor (); ctor.Attributes = MemberAttributes.Public; ctor.Statements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), "Size"), new CodeObjectCreateExpression (new CodeTypeReference ("Size"), new CodePrimitiveExpression (600), new CodePrimitiveExpression (600)))); ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"), "Text"), new CodePrimitiveExpression ("Test"))); ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"), "TabIndex"), new CodePrimitiveExpression (0))); ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"), "Location"), new CodeObjectCreateExpression (new CodeTypeReference ("Point"), new CodePrimitiveExpression (400), new CodePrimitiveExpression (525)))); ctor.Statements.Add (new CodeAttachEventStatement (new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "MyEvent"), new CodeDelegateCreateExpression (new CodeTypeReference ("EventHandler") , new CodeThisReferenceExpression (), "b_Click"))); class1.Members.Add (ctor); // GENERATES (C#): // [System.CLSCompliantAttribute(false)] // public event System.EventHandler MyEvent; CodeMemberEvent evt = new CodeMemberEvent (); evt.Name = "MyEvent"; evt.Type = new CodeTypeReference ("System.EventHandler"); evt.Attributes = MemberAttributes.Public; evt.CustomAttributes.Add (new CodeAttributeDeclaration ("System.CLSCompliantAttribute", new CodeAttributeArgument (new CodePrimitiveExpression (false)))); class1.Members.Add (evt); // GENERATES (C#): // private void b_Click(object sender, System.EventArgs e) { // } // } // } // CodeMemberMethod cmm = new CodeMemberMethod (); cmm.Name = "b_Click"; cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object), "sender")); cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (EventArgs), "e")); class1.Members.Add (cmm); } }
/// <summary> /// Generates an OnChanging-pattern for the given property /// </summary> /// <param name="property">The code property</param> /// <returns></returns> public static CodeStatement CreateOnChangingEventPattern(this CodeMemberProperty property) { return(CreateOnChangingEventPattern(property, null, null)); }
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> /// Implements the getter of the given property /// </summary> /// <param name="property">The property</param> /// <param name="fieldRef">A reference to the underlying field</param> public static void ImplementGetter(this CodeMemberProperty property, CodeFieldReferenceExpression fieldRef) { property.GetStatements.Add(new CodeMethodReturnStatement(fieldRef)); property.HasGet = true; }
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) { #if WHIDBEY CodeNamespace ns = new CodeNamespace("Namespace1"); cu.Namespaces.Add(ns); CodeTypeDeclaration cd = new CodeTypeDeclaration ("Class1"); ns.Types.Add(cd); cd.Comments.Add(new CodeCommentStatement("Outer Type Comment")); CodeMemberField field1 = new CodeMemberField(typeof(String), "field1"); CodeMemberField field2 = new CodeMemberField(typeof(String), "field2"); field2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Foo")); field2.EndDirectives.Add(new CodeRegionDirective (CodeRegionMode.End, String.Empty)); field1.Comments.Add(new CodeCommentStatement("Field 1 Comment")); 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; CodeMemberMethod method1 = new CodeMemberMethod(); method1.Name = "Method1"; method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; if (Supports(provider, 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 (Supports(provider, 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")); 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"))); CodeConstructor constructor1 = new CodeConstructor(); constructor1.Attributes = (constructor1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; constructor1.Statements.Add( new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "field1"), new CodePrimitiveExpression("value1"))); constructor1.Statements.Add( new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "field2"), new CodePrimitiveExpression("value2"))); 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(); 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")); 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")); cd.Members.Add(field1); cd.Members.Add(method1); cd.Members.Add(constructor1); cd.Members.Add(property1); if (Supports (provider, GeneratorSupport.EntryPointMethod)) 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(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); } } #endif }
private void CodeDomProducer_CodeDomProduction(object sender, CodeDomProductionEventArgs e) { if (e.EventType == CodeDomProductionEventType.UnitsProducing) { if (e.Argument == null) { return; } foreach (var entity in Project.Entities) { if (!entity.GetAttributeValue("enabled", NamespaceUri, true)) { continue; } CodeTypeDeclaration typeDeclaration = _codeDomProducer.GetType(entity); if (typeDeclaration == null) { continue; } // Class var jsonObjectAttribute = new CodeAttributeDeclaration("Newtonsoft.Json.JsonObjectAttribute"); string optMode = entity.GetAttributeValue("optMode", NamespaceUri, "OptIn"); if (optMode != null) { var memberSerialization = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("Newtonsoft.Json.MemberSerialization"), optMode); jsonObjectAttribute.Arguments.Add(new CodeAttributeArgument("MemberSerialization", memberSerialization)); } CodeDomUtilities.EnsureAttribute(typeDeclaration, jsonObjectAttribute, true); // Properties foreach (CodeTypeMember member in typeDeclaration.Members) { PropertyDefinition propertyDefinition = null; CodeMemberProperty memberProperty = member as CodeMemberProperty; if (memberProperty != null) { propertyDefinition = UserData.GetPropertyDefinition(memberProperty); } Property property = null; if (propertyDefinition != null && propertyDefinition.Property != null) { property = propertyDefinition.Property; if (!property.GetAttributeValue("enabled", NamespaceUri, true)) { continue; } } else { if (!entity.GetAttributeValue("enabledForNonModelProperties", NamespaceUri, true)) { continue; } } bool?serialized = null; if (property != null) { serialized = property.GetAttributeValue("includeInSerialization", NamespaceUri, (bool?)null); } if (serialized == null) { //[System.NonSerializedAttribute()] => false //[System.Xml.Serialization.XmlIgnoreAttribute()] => false //[System.Runtime.Serialization.DataMemberAttribute()] => true if (CodeDomUtilities.GetAttribute(member, typeof(NonSerializedAttribute)) != null) { serialized = false; } else if (CodeDomUtilities.GetAttribute(member, typeof(XmlIgnoreAttribute)) != null) { serialized = false; } else if (CodeDomUtilities.GetAttribute(member, typeof(DataMemberAttribute)) != null) { serialized = true; } else if (CodeDomUtilities.GetAttribute(member, typeof(XmlAttribute)) != null) { serialized = true; } else if (CodeDomUtilities.GetAttribute(member, typeof(XmlElementAttribute)) != null) { serialized = true; } else if (property != null) { serialized = property.IsIncludedInSerialization; } } // [JsonIgnore] or [JsonProperty] if (serialized != null) { var jsonPropertyAttribute = new CodeAttributeDeclaration(); jsonPropertyAttribute.Name = serialized == true ? "Newtonsoft.Json.JsonPropertyAttribute" : "Newtonsoft.Json.JsonIgnoreAttribute"; CodeDomUtilities.EnsureAttribute(member, jsonPropertyAttribute, true); } } } } }
private void DefineWrapperClassFieldsAndMethods(Smoke.Class* smokeClass, CodeTypeDeclaration type) { // define the dummy constructor if (smokeClass->size > 0) { CodeConstructor dummyCtor = new CodeConstructor(); dummyCtor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(Type)), "dummy")); if (data.Smoke->inheritanceList[smokeClass->parents] > 0) { dummyCtor.BaseConstructorArgs.Add(new CodeSnippetExpression("(System.Type) null")); } dummyCtor.Attributes = MemberAttributes.Family; if (SupportingMethodsHooks != null) { SupportingMethodsHooks(data.Smoke, (Smoke.Method*) 0, dummyCtor, type); } type.Members.Add(dummyCtor); } CodeMemberField staticInterceptor = new CodeMemberField("SmokeInvocation", "staticInterceptor"); staticInterceptor.Attributes = MemberAttributes.Static; CodeObjectCreateExpression initExpression = new CodeObjectCreateExpression("SmokeInvocation"); initExpression.Parameters.Add(new CodeTypeOfExpression(type.Name)); initExpression.Parameters.Add(new CodePrimitiveExpression(null)); staticInterceptor.InitExpression = initExpression; type.Members.Add(staticInterceptor); if (smokeClass->size == 0) return; // we only need this for real classes CodeMemberMethod createProxy = new CodeMemberMethod(); createProxy.Name = "CreateProxy"; createProxy.Attributes = MemberAttributes.Public; if (data.Smoke->inheritanceList[smokeClass->parents] != 0) { createProxy.Attributes |= MemberAttributes.Override; } createProxy.Statements.Add(new CodeAssignStatement( new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "interceptor"), // left hand side new CodeObjectCreateExpression("SmokeInvocation", new CodeTypeOfExpression(type.Name), new CodeThisReferenceExpression()) // right hand side )); type.Members.Add(createProxy); if (data.Smoke->inheritanceList[smokeClass->parents] != 0) return; // The following fields are only necessary for classes without superclasses. CodeMemberField interceptor = new CodeMemberField("SmokeInvocation", "interceptor"); interceptor.Attributes = MemberAttributes.Family; type.Members.Add(interceptor); CodeMemberField smokeObject = new CodeMemberField(typeof(IntPtr), "smokeObject"); type.Members.Add(smokeObject); type.BaseTypes.Add(new CodeTypeReference("ISmokeObject")); CodeMemberProperty propertySmokeObject = new CodeMemberProperty(); propertySmokeObject.Name = "SmokeObject"; propertySmokeObject.Type = new CodeTypeReference(typeof(IntPtr)); propertySmokeObject.Attributes = MemberAttributes.Public; CodeFieldReferenceExpression smokeObjectReference = new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), smokeObject.Name); propertySmokeObject.GetStatements.Add(new CodeMethodReturnStatement(smokeObjectReference)); propertySmokeObject.SetStatements.Add(new CodeAssignStatement(smokeObjectReference, new CodePropertySetValueReferenceExpression())); type.Members.Add(propertySmokeObject); }
public void Visit(CodeMemberProperty o) { g.GenerateProperty(o, g.CurrentClass); }
private void DocumentProperty(CodeTypeDeclaration type, Property prop, CodeMemberProperty cmp) { if (type.Name == "QSvgGenerator") { switch (prop.Name) { case "viewBox": this.documentation.DocumentProperty(type, prop.Name, prop.Type + "F", cmp); break; case "viewBoxF": this.documentation.DocumentProperty(type, "viewBox", prop.Type, cmp); break; default: this.documentation.DocumentProperty(type, prop.Name, prop.Type, cmp); break; } } else { this.documentation.DocumentProperty(type, prop.Name, prop.Type, cmp); } }
protected abstract void GenerateProperty(CodeMemberProperty e, CodeTypeDeclaration c);
public void Run() { for (short classId = 1; classId <= data.Smoke->numClasses; classId++) { Smoke.Class* klass = data.Smoke->classes + classId; if (klass->external) continue; string className = ByteArrayManager.GetString(klass->className); IEnumerable<Property> props = this.GetProperties(classId, className); List<GeneratorData.InternalMemberInfo> members = data.GetAccessibleMembers(data.Smoke->classes + classId); CodeTypeDeclaration type = data.SmokeTypeMap[(IntPtr) klass]; foreach (Property prop in props) { CodeMemberProperty cmp = new CodeMemberProperty(); try { bool isRef; short id = data.Smoke->IDType(prop.Type); if (id > 0) { cmp.Type = translator.CppToCSharp(data.Smoke->types + id, type, out isRef); } else { if (!prop.Type.Contains("::")) { id = data.Smoke->IDType(className + "::" + prop.Type); if (id > 0) { cmp.Type = translator.CppToCSharp(data.Smoke->types + id, type, out isRef); } else { cmp.Type = translator.CppToCSharp(prop.Type, type, out isRef); } } cmp.Type = translator.CppToCSharp(prop.Type, type, out isRef); } } catch (NotSupportedException) { Debug.Print(" |--Won't wrap Property {0}::{1}", className, prop.Name); continue; } this.DocumentProperty(type, prop, cmp); string capitalized = NameProperty(cmp, prop, type, members, className); cmp.HasGet = true; cmp.HasSet = prop.IsWritable; cmp.Attributes = MemberAttributes.Public | MemberAttributes.New | MemberAttributes.Final; cmp.CustomAttributes.Add(new CodeAttributeDeclaration("Q_PROPERTY", new CodeAttributeArgument( new CodePrimitiveExpression(prop.Type)), new CodeAttributeArgument( new CodePrimitiveExpression(prop.Name)))); // ===== get-method ===== short getterMapId = FindQPropertyGetAccessorMethodMapId(classId, prop, capitalized); if (getterMapId == 0) { Debug.Print(" |--Missing 'get' method for property {0}::{1} - using QObject.Property()", className, prop.Name); cmp.GetStatements.Add(new CodeMethodReturnStatement(new CodeCastExpression(cmp.Type, new CodeMethodInvokeExpression( new CodeThisReferenceExpression(), "Property", new CodePrimitiveExpression(prop.Name))))); } else { Smoke.MethodMap* map = data.Smoke->methodMaps + getterMapId; short getterId = map->method; if (getterId < 0) { // simply choose the first (i.e. non-const) version if there are alternatives getterId = data.Smoke->ambiguousMethodList[-getterId]; } Smoke.Method* getter = data.Smoke->methods + getterId; if (getter->classId != classId) { // The actual get method is defined in a parent class - don't create a property for it. continue; } this.PropertyMethods.Add((IntPtr) getter); cmp.GetStatements.Add( new CodeMethodReturnStatement( new CodeCastExpression(cmp.Type, new CodeMethodInvokeExpression(SmokeSupport.interceptor_Invoke, new CodePrimitiveExpression(ByteArrayManager.GetString(data.Smoke->methodNames[getter->name])), new CodePrimitiveExpression(data.Smoke->GetMethodSignature(getter)), new CodeTypeOfExpression(cmp.Type), new CodePrimitiveExpression(false))))); this.SetPropertyModifiers(getter, cmp); } // ===== set-method ===== if (!prop.IsWritable) { // not writable? => continue type.Members.Add(cmp); continue; } char mungedSuffix; short setterMethId = FindQPropertySetAccessorMethodId(classId, prop, capitalized, out mungedSuffix); if (setterMethId == 0) { Debug.Print(" |--Missing 'set' method for property {0}::{1} - using QObject.SetProperty()", className, prop.Name); cmp.SetStatements.Add(new CodeExpressionStatement( new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "SetProperty", new CodePrimitiveExpression(prop.Name), new CodeArgumentReferenceExpression("value")))); } else { Smoke.Method* setter = data.Smoke->methods + setterMethId; this.SetPropertyModifiers(setter, cmp); if (setter->classId != classId) { // defined in parent class, continue type.Members.Add(cmp); continue; } string setterName = ByteArrayManager.GetString(data.Smoke->methodNames[setter->name]); this.PropertyMethods.Add((IntPtr) setter); cmp.SetStatements.Add(new CodeExpressionStatement( new CodeMethodInvokeExpression(SmokeSupport.interceptor_Invoke, new CodePrimitiveExpression(setterName + mungedSuffix), new CodePrimitiveExpression( this.data.Smoke->GetMethodSignature(setterMethId)), new CodeTypeOfExpression(typeof(void)), new CodePrimitiveExpression(false), new CodeTypeOfExpression(cmp.Type), new CodeArgumentReferenceExpression("value")))); } type.Members.Add(cmp); } } }
public void Indexers() { CodeNamespace nspace = new CodeNamespace("NSPC"); CodeTypeDeclaration cd = new CodeTypeDeclaration("TEST"); cd.IsClass = true; nspace.Types.Add(cd); CodeMemberField field = new CodeMemberField(); field.Name = "PublicField"; field.InitExpression = new CodeArrayCreateExpression(new CodeTypeReference(typeof(int)), new CodeExpression[]{ new CodePrimitiveExpression(0), new CodePrimitiveExpression(0),new CodePrimitiveExpression(0),new CodePrimitiveExpression(0), new CodePrimitiveExpression(0),new CodePrimitiveExpression(0), new CodePrimitiveExpression(0)}); field.Attributes = MemberAttributes.Public | MemberAttributes.Final; field.Type = new CodeTypeReference(typeof(int[])); cd.Members.Add(field); // nonarray indexers CodeMemberProperty indexerProperty = new CodeMemberProperty(); indexerProperty.Name = "Item"; indexerProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final; indexerProperty.Type = new CodeTypeReference(typeof(int)); indexerProperty.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i")); // uses array indexer indexerProperty.SetStatements.Add(new CodeAssignStatement(new CodeArrayIndexerExpression( new CodeFieldReferenceExpression(new CodeThisReferenceExpression() , "PublicField"), new CodeExpression[] { new CodeVariableReferenceExpression("i") }), new CodeVariableReferenceExpression("value"))); indexerProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeArrayIndexerExpression( new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "PublicField"), new CodeVariableReferenceExpression("i")))); cd.Members.Add(indexerProperty); // nonarray indexers indexerProperty = new CodeMemberProperty(); indexerProperty.Name = "Item"; indexerProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final; indexerProperty.Type = new CodeTypeReference(typeof(int)); indexerProperty.SetStatements.Add(new CodeAssignStatement(new CodeArrayIndexerExpression( new CodeFieldReferenceExpression(new CodeThisReferenceExpression() , "PublicField"), new CodeExpression[] { new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression("b"))}), new CodeVariableReferenceExpression("value"))); indexerProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeArrayIndexerExpression( new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "PublicField"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression("b"))))); indexerProperty.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "a")); indexerProperty.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "b")); // uses array indexer cd.Members.Add(indexerProperty); cd = new CodeTypeDeclaration("UseTEST"); cd.IsClass = true; nspace.Types.Add(cd); CodeMemberMethod cmm = new CodeMemberMethod(); cmm.Name = "TestMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i")); cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public; cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("TEST"), "temp", new CodeObjectCreateExpression("TEST"))); cmm.Statements.Add(new CodeAssignStatement(new CodeIndexerExpression( new CodeVariableReferenceExpression("temp"), new CodeExpression[] { new CodePrimitiveExpression(1) }), new CodeVariableReferenceExpression("i"))); cmm.Statements.Add(new CodeAssignStatement(new CodeIndexerExpression( new CodeVariableReferenceExpression("temp"), new CodeExpression[]{new CodePrimitiveExpression(2), new CodePrimitiveExpression(4)}), new CodePrimitiveExpression(83))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression( new CodeIndexerExpression(new CodeVariableReferenceExpression("temp"), new CodeExpression[] { new CodePrimitiveExpression(1) }), CodeBinaryOperatorType.Add, new CodeIndexerExpression(new CodeVariableReferenceExpression("temp"), new CodeExpression[] { new CodePrimitiveExpression(2), new CodePrimitiveExpression(4) })))); cd.Members.Add(cmm); AssertEqual(nspace, @"Namespace NSPC Public Class TEST Public PublicField() As Integer = New Integer() {0, 0, 0, 0, 0, 0, 0} Public Overloads Default Property Item(ByVal i As Integer) As Integer Get Return Me.PublicField(i) End Get Set Me.PublicField(i) = value End Set End Property Public Overloads Default Property Item(ByVal a As Integer, ByVal b As Integer) As Integer Get Return Me.PublicField((a + b)) End Get Set Me.PublicField((a + b)) = value End Set End Property End Class Public Class UseTEST Public Function TestMethod(ByVal i As Integer) As Integer Dim temp As TEST = New TEST() temp(1) = i temp(2, 4) = 83 Return (temp(1) + temp(2, 4)) End Function End Class End Namespace"); }
public override void Create() { System.Windows.Forms.MessageBox.Show("请选择要输出的目录"); if (dlgSavePath.ShowDialog() != System.Windows.Forms.DialogResult.OK) { return; } string outputPath = dlgSavePath.SelectedPath; Dictionary <string, List <RefKeyMap> > refEntities = GetFKMapping(); foreach (Table table in project.Tables) { Stream s = File.Open(outputPath + "\\" + table.Name + ".cs", FileMode.Create); StreamWriter sw = new StreamWriter(s, Encoding.Default); CSharpCodeProvider cscProvider = new CSharpCodeProvider(); ICodeGenerator cscg = cscProvider.CreateGenerator(sw); CodeGeneratorOptions cop = new CodeGeneratorOptions(); cop.BlankLinesBetweenMembers = false; cop.ElseOnClosing = true; //Create Class Using Statements cscg.GenerateCodeFromCompileUnit(new CodeSnippetCompileUnit("using System;"), sw, cop); cscg.GenerateCodeFromCompileUnit(new CodeSnippetCompileUnit("using System.Collections.Generic;"), sw, cop); cscg.GenerateCodeFromCompileUnit(new CodeSnippetCompileUnit("using System.Data;"), sw, cop); cscg.GenerateCodeFromCompileUnit(new CodeSnippetCompileUnit("using System.Text;"), sw, cop); sw.WriteLine(); //创建命名空间 CodeNamespace cnsCodeDom = new CodeNamespace(Namespace); //创建类 CodeTypeDeclaration ctd = new CodeTypeDeclaration(); cnsCodeDom.Types.Add(ctd); ctd.IsClass = true; ctd.Name = table.Name; ctd.BaseTypes.Add(project.Namespace + ".Entity." + table.Name); //继承 实体 ctd.TypeAttributes = TypeAttributes.Public; foreach (RefKeyMap wmap in refEntities[table.Name]) //增加外键子元素的集合 { string fieldName = wmap.Col.Name + "s" + wmap.Table.Name + "s"; ctd.Members.Add(new CodeMemberField("List<" + wmap.Table.Name + ">", "_" + fieldName)); CodeMemberProperty cmp = new CodeMemberProperty(); cmp.Type = new CodeTypeReference("List<" + wmap.Table.Name + ">"); cmp.Attributes = MemberAttributes.Public; cmp.Name = fieldName; cmp.Comments.Add(new CodeCommentStatement("<summary>", true)); cmp.Comments.Add(new CodeCommentStatement("表示 [" + wmap.Col.Title + "] 的 [" + wmap.Table.Title + "] 集合", true)); cmp.Comments.Add(new CodeCommentStatement("</summary>", true)); cmp.HasGet = true; cmp.GetStatements.Add(new CodeSnippetExpression(@"if (_" + fieldName + @" == null) { if (this." + wmap.Col.Name + @" == null) _" + fieldName + @" = new List<" + wmap.Table.Name + @">(); else _" + fieldName + @" = db.Take<" + wmap.Table.Name + @">(""" + wmap.Col.Name + @"=@" + wmap.Col.Name + @""", Zippy.Helper.ZData.CreateParameter(""" + wmap.Col.Name + @""", this." + wmap.Col.RefCol + @")); } return _" + fieldName)); //cmp.HasSet = true; //cmp.SetStatements.Add(new CodeSnippetExpression("_" + fieldName + " = value")); ctd.Members.Add(cmp); } foreach (Col col in table.Cols) //找到外键映射的实体 { if (!string.IsNullOrEmpty(col.RefTable)) { string fieldName = col.Name + "s" + col.RefTable + ""; ctd.Members.Add(new CodeMemberField(col.RefTable, "_" + fieldName)); CodeMemberProperty cmp = new CodeMemberProperty(); cmp.Type = new CodeTypeReference(col.RefTable); cmp.Attributes = MemberAttributes.Public; cmp.Name = fieldName; cmp.Comments.Add(new CodeCommentStatement("<summary>", true)); cmp.Comments.Add(new CodeCommentStatement("表示 [" + col.Title + "] 对应的实体", true)); cmp.Comments.Add(new CodeCommentStatement("</summary>", true)); cmp.HasGet = true; cmp.GetStatements.Add(new CodeSnippetExpression(@"if (_" + fieldName + @" == null) _" + fieldName + @" = db.FindUnique<" + col.RefTable + @">(""" + col.RefCol + @"=@" + col.RefCol + @""", Zippy.Helper.ZData.CreateParameter(""" + col.RefCol + @""", this." + col.Name + @")); return _" + fieldName)); //cmp.HasSet = true; //cmp.SetStatements.Add(new CodeSnippetExpression("_" + fieldName + " = value")); ctd.Members.Add(cmp); } } CodeMemberField dbField = new CodeMemberField("Zippy.Data.IDalProvider", "db"); dbField.Attributes = MemberAttributes.Public; ctd.Members.Add(dbField); CodeConstructor ctor0 = new CodeConstructor(); ctd.Members.Add(ctor0); ctor0.Attributes = MemberAttributes.Public; ctor0.Statements.Add(new CodeSnippetExpression("db = Zippy.Data.DalFactory.CreateProvider()")); CodeConstructor ctor1 = new CodeConstructor(); ctd.Members.Add(ctor1); ctor1.Parameters.Add(new CodeParameterDeclarationExpression("Zippy.Data.IDalProvider", "_db")); ctor1.Attributes = MemberAttributes.Public; ctor1.Statements.Add(new CodeSnippetExpression("db = _db")); Col colPK = FindPKCol(table); if (colPK != null) { System.Data.DbType xtyppe = TypeConverter.ToDbType(colPK.DataType); Type colType = ZippyCoder.TypeConverter.ToNetType(colPK.DataType); ctd.Members.Add(CreateStaticMethod("FindUnique", table.Name, @"Zippy.Data.IDalProvider db = Zippy.Data.DalFactory.CreateProvider(); return db.FindUnique<" + table.Name + ">(pkValue)", new CodeParameterDeclarationExpression(colType, "pkValue"))); ctd.Members.Add(CreateStaticMethod("FindUnique", table.Name, @"return db.FindUnique<" + table.Name + ">(pkValue)", new CodeParameterDeclarationExpression(colType, "pkValue"), new CodeParameterDeclarationExpression("Zippy.Data.IDalProvider", "db"))); ctd.Members.Add(CreateMethod("Delete", typeof(int), "return db.Delete<" + table.Name + ">(this." + colPK.Name + ")")); ctd.Members.Add(CreateMethod("Insert", typeof(int), "int rtn = db.Insert<" + table.Name + @">(this); this." + colPK.Name + @" = rtn; return rtn")); ctd.Members.Add(CreateMethod("Update", typeof(int), "return db.Update<" + table.Name + ">(this)")); ctd.Members.Add(CreateMethod("Save", typeof(bool), @"int rtn = 0; if (this." + colPK.Name + @" != null) rtn = db.Update<" + table.Name + @">(this); else { rtn = db.Insert<" + table.Name + @">(this); this." + colPK.Name + @" = rtn; } return rtn > 0")); } ctd.Members.Add(CreateMethod("Take", "List<" + table.Name + ">", "return db.Take<" + table.Name + ">(true)")); ctd.Members.Add(CreateMethod("Take", "List<" + table.Name + ">", "return db.Take<" + table.Name + ">(count, true)", new CodeParameterDeclarationExpression(typeof(int), "count"))); ctd.Members.Add(CreateMethod("Take", "List<" + table.Name + ">", "return db.Take<" + table.Name + ">(sqlEntry, cmdParameters)", new CodeParameterDeclarationExpression(typeof(string), "sqlEntry"), new CodeParameterDeclarationExpression("params System.Data.Common.DbParameter[]", "cmdParameters"))); ctd.Members.Add(CreateMethod("Take", "Zippy.Data.Collections.PaginatedList<" + table.Name + ">", @"Zippy.Data.Collections.PaginatedList<" + table.Name + @"> rtn = new Zippy.Data.Collections.PaginatedList<" + table.Name + @">(); List<" + table.Name + @"> records = db.Take<" + table.Name + @">(where + "" order by "" + orderby, pageSize, pageNumber, cmdParameters); rtn.AddRange(records); rtn.PageIndex = pageNumber; rtn.PageSize = pageSize; rtn.TotalCount = db.Count<" + table.Name + @">(where, cmdParameters); return rtn", new CodeParameterDeclarationExpression(typeof(string), "where"), new CodeParameterDeclarationExpression(typeof(string), "orderby"), new CodeParameterDeclarationExpression(typeof(int), "pageSize"), new CodeParameterDeclarationExpression(typeof(int), "pageNumber"), new CodeParameterDeclarationExpression("params System.Data.Common.DbParameter[]", "cmdParameters"))); cscg.GenerateCodeFromNamespace(cnsCodeDom, sw, cop); sw.Close(); s.Close(); } }
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) { CodeNamespace nspace = new CodeNamespace ("NSPC"); nspace.Imports.Add (new CodeNamespaceImport ("System")); cu.Namespaces.Add (nspace); CodeTypeDeclaration cd = new CodeTypeDeclaration ("TestingStructs"); cd.IsClass = true; nspace.Types.Add (cd); if (Supports (provider, GeneratorSupport.DeclareValueTypes)) { // GENERATES (C#): // public int CallingStructMethod(int i) { // StructImplementation o = new StructImplementation (); // return o.StructMethod(i); // } AddScenario ("CheckCallingStructMethod"); CodeMemberMethod cmm = new CodeMemberMethod (); cmm.Name = "CallingStructMethod"; cmm.ReturnType = new CodeTypeReference (typeof (int)); cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i")); cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference ("StructImplementation"), "o", new CodeObjectCreateExpression (new CodeTypeReference ("StructImplementation")))); cmm.Statements.Add (new CodeMethodReturnStatement (new CodeMethodInvokeExpression (new CodeMethodReferenceExpression ( new CodeVariableReferenceExpression ("o"), "StructMethod"), new CodeArgumentReferenceExpression ("i")))); cd.Members.Add (cmm); // GENERATES (C#): // public int UsingValueStruct(int i) { // ValueStruct StructObject = new ValueStruct(); // StructObject.x = i; // return StructObject.x; // } AddScenario ("CheckUsingValueStruct"); cmm = new CodeMemberMethod (); cmm.Name = "UsingValueStruct"; cmm.ReturnType = new CodeTypeReference (typeof (int)); cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i")); cmm.Statements.Add (new CodeVariableDeclarationStatement ("ValueStruct", "StructObject", new CodeObjectCreateExpression ("ValueStruct"))); cmm.Statements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression (new CodeVariableReferenceExpression ("StructObject"), "x"), new CodeArgumentReferenceExpression ("i"))); cmm.Statements.Add (new CodeMethodReturnStatement (new CodeFieldReferenceExpression (new CodeVariableReferenceExpression ("StructObject"), "x"))); cd.Members.Add (cmm); // GENERATES (C#): // public int UsingStructProperty(int i) { // StructImplementation StructObject = new StructImplementation(); // StructObject.UseIField = i; // return StructObject.UseIField; // } AddScenario ("CheckUsingStructProperty"); cmm = new CodeMemberMethod (); cmm.Name = "UsingStructProperty"; cmm.ReturnType = new CodeTypeReference (typeof (int)); cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i")); cmm.Statements.Add (new CodeVariableDeclarationStatement ("StructImplementation", "StructObject", new CodeObjectCreateExpression ("StructImplementation"))); cmm.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression ( new CodeVariableReferenceExpression ("StructObject"), "UseIField"), new CodeArgumentReferenceExpression ("i"))); cmm.Statements.Add (new CodeMethodReturnStatement (new CodePropertyReferenceExpression (new CodeVariableReferenceExpression ("StructObject"), "UseIField"))); cd.Members.Add (cmm); // GENERATES (C#): // public int UsingInterfaceStruct(int i) { // ImplementInterfaceStruct IStructObject = new ImplementInterfaceStruct(); // return IStructObject.InterfaceMethod(i); // } if (Supports (provider, GeneratorSupport.DeclareInterfaces)) { AddScenario ("CheckUsingInterfaceStruct"); // method to test struct implementing interfaces cmm = new CodeMemberMethod (); cmm.Name = "UsingInterfaceStruct"; cmm.ReturnType = new CodeTypeReference (typeof (int)); cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i")); cmm.Statements.Add (new CodeVariableDeclarationStatement ("ImplementInterfaceStruct", "IStructObject", new CodeObjectCreateExpression ("ImplementInterfaceStruct"))); cmm.Statements.Add (new CodeMethodReturnStatement (new CodeMethodInvokeExpression ( new CodeVariableReferenceExpression ("IStructObject"), "InterfaceMethod", new CodeArgumentReferenceExpression ("i")))); cd.Members.Add (cmm); } // GENERATES (C#): // public struct StructImplementation { // int i; // public int UseIField { // get { // return i; // } // set { // i = value; // } // } // public int StructMethod(int i) { // return (5 + i); // } // } cd = new CodeTypeDeclaration ("StructImplementation"); cd.IsStruct = true; nspace.Types.Add (cd); // declare an integer field CodeMemberField field = new CodeMemberField (new CodeTypeReference (typeof (int)), "i"); field.Attributes = MemberAttributes.Public; cd.Members.Add (field); CodeMemberProperty prop = new CodeMemberProperty (); prop.Name = "UseIField"; prop.Type = new CodeTypeReference (typeof (int)); prop.Attributes = MemberAttributes.Public | MemberAttributes.Final; CodeFieldReferenceExpression fref = new CodeFieldReferenceExpression (); fref.FieldName = "i"; prop.GetStatements.Add (new CodeMethodReturnStatement (fref)); prop.SetStatements.Add (new CodeAssignStatement (fref, new CodePropertySetValueReferenceExpression ())); cd.Members.Add (prop); cmm = new CodeMemberMethod (); cmm.Name = "StructMethod"; cmm.ReturnType = new CodeTypeReference (typeof (int)); cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i")); cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression ( new CodePrimitiveExpression (5), CodeBinaryOperatorType.Add, new CodeArgumentReferenceExpression ("i")))); cd.Members.Add (cmm); // GENERATES (C#): // public struct ValueStruct { // public int x; // } cd = new CodeTypeDeclaration ("ValueStruct"); cd.IsStruct = true; nspace.Types.Add (cd); // declare an integer field field = new CodeMemberField (new CodeTypeReference (typeof (int)), "x"); field.Attributes = MemberAttributes.Public; cd.Members.Add (field); if (Supports (provider, GeneratorSupport.DeclareInterfaces)) { // interface to be implemented // GENERATES (C#): // public interface InterfaceStruct { // int InterfaceMethod(int i); // } cd = new CodeTypeDeclaration ("InterfaceStruct"); cd.IsInterface = true; nspace.Types.Add (cd); // method in the interface cmm = new CodeMemberMethod (); cmm.Name = "InterfaceMethod"; cmm.ReturnType = new CodeTypeReference (typeof (int)); cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i")); cd.Members.Add (cmm); // struct to implement an interface // GENERATES (C#): // public struct ImplementInterfaceStruct : InterfaceStruct { // public int InterfaceMethod(int i) { // return (8 + i); // } // } cd = new CodeTypeDeclaration ("ImplementInterfaceStruct"); cd.BaseTypes.Add (new CodeTypeReference ("InterfaceStruct")); cd.IsStruct = true; nspace.Types.Add (cd); field = new CodeMemberField (new CodeTypeReference (typeof (int)), "i"); field.Attributes = MemberAttributes.Public; cd.Members.Add (field); // implement interface method cmm = new CodeMemberMethod (); cmm.Name = "InterfaceMethod"; cmm.ImplementationTypes.Add (new CodeTypeReference ("InterfaceStruct")); cmm.ReturnType = new CodeTypeReference (typeof (int)); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final; cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (new CodePrimitiveExpression (8), CodeBinaryOperatorType.Add, new CodeArgumentReferenceExpression ("i")))); cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i")); cd.Members.Add (cmm); } } }
protected override void DoGenerate(CodeTypeDeclaration genClass) { genClass.BaseTypes.Add(typeof(QuerySproc)); CodeConstructor constructor = new CodeConstructor(); constructor.Attributes = MemberAttributes.Public; constructor.Name = NameWithoutSpaces; constructor.BaseConstructorArgs.Add(new CodePrimitiveExpression(NameWithoutSpaces)); constructor.BaseConstructorArgs.Add(new CodePrimitiveExpression(OutputDefaultConnectionStringName)); genClass.Members.Add(constructor); var criteria = new EmptyQuerySproc(Name, OutputDefaultConnectionStringName).CreateSprocCriteria(); var cmd = _cmdFac.CreateCommand(criteria, false); var sqlCommand = new SqlCommand { CommandText = cmd.CommandText, CommandType = CommandType.StoredProcedure, Connection = (SqlConnection)cmd.Connection }; using (var conn = sqlCommand.Connection) { conn.Open(); SqlCommandBuilder.DeriveParameters(sqlCommand); conn.Close(); } foreach (SqlParameter parameter in sqlCommand.Parameters) { var paramName = parameter.ParameterName.TrimStart('@'); var field = new CodeMemberField(); field.Name = "_" + paramName; field.Attributes = MemberAttributes.Private; var paramType = GetSprocParameterType(parameter.DbType); field.Type = new CodeTypeReference(paramType); field.InitExpression = new CodeObjectCreateExpression( field.Type, paramType == typeof(StringParameterExpression) ? new CodeExpression[] { new CodePrimitiveExpression(paramName), CreateSprocParameterDirectionEnumExpression(parameter.Direction), new CodePrimitiveExpression(IsUnicodeDbType(parameter.DbType)) } : new CodeExpression[] { new CodePrimitiveExpression(paramName), CreateSprocParameterDirectionEnumExpression(parameter.Direction) } ); genClass.Members.Add(field); var property = new CodeMemberProperty(); property.Name = paramName; property.Attributes = MemberAttributes.Public | MemberAttributes.Final; property.Type = field.Type; property.HasGet = true; property.HasSet = false; property.GetStatements.Add( new CodeMethodReturnStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), field.Name ) ) ); genClass.Members.Add(property); } }
public override void Interpret(Script script) { MaxProgress = script.Entries.Count; for (int i = 0; i < script.Entries.Count; i++) { if (!Engine.Working) { Thread.CurrentThread.Abort(); } CurProgress = i; var entry = script.Entries [i]; CodeTypeDeclaration codeType = new CodeTypeDeclaration(); //codeType.CustomAttributes. codeType.BaseTypes.Add(new CodeTypeReference(typeof(EventAction))); codeType.Name = entry.Identifier as string; codeTypes.Add(codeType); if (ScriptEngine.AnalyzeDebug) { Debug.LogWarning((entry.Identifier as string).ToUpper()); } var ctx = entry.Context as Context; if (ctx == null) { continue; } var actionMethod = typeof(EventAction).GetMethod("Action"); var utMethod = typeof(EventAction).GetMethod("Utility"); var scopeMethod = typeof(EventAction).GetMethod("Filter"); var interMethod = typeof(EventAction).GetMethod("Interaction"); CodeAttributeDeclaration attr = new CodeAttributeDeclaration("EventActionAttribute"); codeType.CustomAttributes.Add(attr); CodeAttributeArgument maxArg = new CodeAttributeArgument("ShouldHaveMaxUtility", new CodeSnippetExpression("false")); CodeAttributeArgument onceArg = new CodeAttributeArgument("OncePerObject", new CodeSnippetExpression("false")); CodeAttributeArgument oncePerTurnArg = new CodeAttributeArgument("OncePerTurn", new CodeSnippetExpression("false")); CodeAttributeArgument aiActionArg = new CodeAttributeArgument("IsAIAction", new CodeSnippetExpression("false")); CodeAttributeArgument interactionArg = new CodeAttributeArgument("IsInteraction", new CodeSnippetExpression("false")); CodeAttributeArgument tooltipArg = new CodeAttributeArgument("Tooltip", new CodeSnippetExpression("\"\"")); CodeAttributeArgument onceInCategory = new CodeAttributeArgument("OnceInCategory", new CodeSnippetExpression("false")); attr.Arguments.Add(maxArg); attr.Arguments.Add(onceArg); attr.Arguments.Add(oncePerTurnArg); attr.Arguments.Add(aiActionArg); attr.Arguments.Add(tooltipArg); attr.Arguments.Add(onceInCategory); attr.Arguments.Add(interactionArg); FunctionBlock dependenciesBlock = new FunctionBlock(null, null, codeType); List <string> deps = new List <string>(); for (int j = 0; j < ctx.Entries.Count; j++) { var op = ctx.Entries [j] as Operator; if (op == null) { continue; } if (op.Identifier as string == "tooltip") { tooltipArg.Value = new CodeSnippetExpression((op.Context as InternalDSL.Expression).Operands[0].ToString()); } else if (op.Identifier as string == "ai_action") { aiActionArg.Value = new CodeSnippetExpression("true"); } else if (op.Identifier as string == "once_per_category") { onceInCategory.Value = new CodeSnippetExpression("true"); } else if (op.Identifier as string == "only_max_utility") { maxArg.Value = new CodeSnippetExpression((op.Context as InternalDSL.Expression).Operands[0].ToString()); } else if (op.Identifier as string == "category") { var cat = (((op.Context as Expression).Operands[0] as ExprAtom).Content as Scope).Parts[0].ToString(); var type = Engine.FindType("ScriptedTypes." + cat); if (type == null) { type = Engine.FindType(NameTranslator.CSharpNameFromScript(cat)); } if (type != null) { var props = type.GetProperties(); codeType.BaseTypes.Add(type); foreach (var propInfo in props) { var prop = new CodeMemberProperty(); prop.HasGet = true; prop.HasSet = true; prop.Name = propInfo.Name; prop.Type = new CodeTypeReference(propInfo.PropertyType); var fieldName = NameTranslator.ScriptNameFromCSharp(prop.Name); prop.GetStatements.Add(new CodeSnippetStatement(String.Format("return {0}; ", fieldName))); prop.SetStatements.Add(new CodeSnippetStatement(String.Format("{0} = value; ", fieldName))); prop.PrivateImplementationType = new CodeTypeReference(type); if (!codeType.UserData.Contains(fieldName)) { var field = new CodeMemberField(); field.Name = fieldName; field.Type = new CodeTypeReference(propInfo.PropertyType); codeType.Members.Add(field); codeType.UserData.Add(fieldName, field); field.UserData.Add("type", propInfo.PropertyType); } codeType.Members.Add(prop); } } else { if (!cNamespace.UserData.Contains(cat)) { CodeTypeDeclaration catInterface = new CodeTypeDeclaration(cat); catInterface.IsInterface = true; cNamespace.Types.Add(catInterface); cNamespace.UserData.Add(cat, catInterface); } codeType.BaseTypes.Add(cat); } } else if (op.Identifier as string == "once_per_object") { onceArg.Value = new CodeSnippetExpression("true"); } else if (op.Identifier as string == "once_per_turn") { oncePerTurnArg.Value = new CodeSnippetExpression("true"); } else if (op.Identifier as string == "scope") { //It's a filter function // Debug.Log (op.Context.GetType ()); if (ScriptEngine.AnalyzeDebug) { Debug.Log((op.Context as Expression).Operands[0].GetType()); } (((op.Context as Expression).Operands[0] as ExprAtom).Content as Scope).Parts.Add("true"); DeclareVariableStatement retVal = new DeclareVariableStatement(); retVal.IsReturn = true; retVal.Name = "applicable"; retVal.Type = typeof(bool); retVal.InitExpression = "false"; CreateEventFunction("Filter", op.Context, codeType, scopeMethod, false, retVal); //CreateFilterFunction (op.Context as Expression, codeType); } else if (op.Identifier as string == "interaction") { //It's a filter function // Debug.Log (op.Context.GetType ()); if (ScriptEngine.AnalyzeDebug) { Debug.Log((op.Context as Expression).Operands[0].GetType()); } (((op.Context as Expression).Operands[0] as ExprAtom).Content as Scope).Parts.Add("true"); DeclareVariableStatement retVal = new DeclareVariableStatement(); retVal.IsReturn = true; retVal.Name = "applicable"; retVal.Type = typeof(bool); retVal.InitExpression = "false"; CreateEventFunction("Interaction", op.Context, codeType, interMethod, false, retVal); interactionArg.Value = new CodeSnippetExpression("true"); //CreateFilterFunction (op.Context as Expression, codeType); var type = typeof(EventInteraction); var props = type.GetProperties(); codeType.BaseTypes.Add(type); foreach (var propInfo in props) { var prop = new CodeMemberProperty(); prop.HasGet = true; prop.HasSet = true; prop.Name = propInfo.Name; prop.Type = new CodeTypeReference(propInfo.PropertyType); var fieldName = NameTranslator.ScriptNameFromCSharp(prop.Name); prop.GetStatements.Add(new CodeSnippetStatement(String.Format("return {0}; ", fieldName))); prop.SetStatements.Add(new CodeSnippetStatement(String.Format("{0} = value; ", fieldName))); prop.PrivateImplementationType = new CodeTypeReference(type); if (!codeType.UserData.Contains(fieldName)) { var field = new CodeMemberField(); field.Name = fieldName; field.Type = new CodeTypeReference(propInfo.PropertyType); codeType.Members.Add(field); codeType.UserData.Add(fieldName, field); field.UserData.Add("type", propInfo.PropertyType); } codeType.Members.Add(prop); } } else if (op.Identifier as string == "action") { //It's an action function CreateEventFunction(op.Identifier as string, op.Context, codeType, actionMethod, true); } else if (op.Identifier as string == "utility") { DeclareVariableStatement utVal = new DeclareVariableStatement(); utVal.IsReturn = true; utVal.Name = "ut"; utVal.Type = typeof(float); utVal.InitExpression = "0"; CreateEventFunction(op.Identifier as string, op.Context, codeType, utMethod, false, utVal); } else if (op.Identifier as string == "depends") { //Debug.Log(op); //Debug.Log(((op.Context as Expression).Operands[0] as ExprAtom).Content.GetType().Name); var ctor = ((((op.Context as Expression).Operands[0] as ExprAtom).Content as Scope).Parts[0] as FunctionCall); var type = Engine.FindType(NameTranslator.CSharpNameFromScript(ctor.Name)); MethodInfo initMethod = type.GetMethod("Init"); var args = initMethod.GetParameters(); bool hasInteractable = false; bool hasInitiator = false; foreach (var param in args) { if (param.Name == "interactable") { hasInteractable = true; } else if (param.Name == "initiator") { hasInitiator = true; } } builder.Length = 0; builder.Append("new "); builder.Append(type.FullName); builder.Append("().Init"); builder.Append("("); if (hasInteractable) { builder.Append("this.root"); builder.Append(","); } if (hasInitiator) { builder.Append("this.initiator"); builder.Append(","); } foreach (var funcArg in ctor.Args) { builder.Append(exprInter.InterpretExpression(funcArg, dependenciesBlock).ExprString); builder.Append(","); } if (builder[builder.Length - 1] == ',') { builder.Length = builder.Length - 1; } builder.Append(")"); deps.Add(builder.ToString()); } else { //No idea } } if (deps.Count > 0) { CodeMemberMethod getDepsOverride = new CodeMemberMethod(); getDepsOverride.ReturnType = new CodeTypeReference(typeof(List <Dependency>)); getDepsOverride.Name = "GetDependencies"; getDepsOverride.Attributes = MemberAttributes.Public | MemberAttributes.Override; codeType.Members.Add(getDepsOverride); string listName = "list" + DeclareVariableStatement.VariableId++; string listOp = String.Format("var {0} = new System.Collections.Generic.List<Dependency>({1});", listName, deps.Count); dependenciesBlock.Statements.Add(listOp); var addToListBlock = new FunctionBlock(dependenciesBlock); foreach (var newDep in deps) { addToListBlock.Statements.Add(String.Format("{0}.Add({1});", listName, newDep)); } dependenciesBlock.Statements.Add(addToListBlock); dependenciesBlock.Statements.Add(String.Format("return {0};", listName)); getDepsOverride.Statements.Add(new CodeSnippetStatement(dependenciesBlock.ToString())); } CodeMemberMethod initOverrideMethod = new CodeMemberMethod(); initOverrideMethod.Name = "Init"; initOverrideMethod.Attributes = MemberAttributes.Public | MemberAttributes.Override; codeType.Members.Add(initOverrideMethod); builder.Length = 0; builder.Append("base.Init();").AppendLine(); foreach (var member in codeType.Members) { var field = member as CodeMemberField; if (field != null) { builder.Append("this.").Append(field.Name).Append(" = ").Append("default(").Append((field.UserData["type"] as Type).FullName).Append(");").AppendLine(); } } initOverrideMethod.Statements.Add(new CodeSnippetStatement(builder.ToString())); } CurProgress = MaxProgress; foreach (var type in codeTypes) { cNamespace.Types.Add(type); } CSharpCodeProvider provider = new CSharpCodeProvider(); CodeGeneratorOptions options = new CodeGeneratorOptions(); var writer = new StringWriter(); provider.GenerateCodeFromNamespace(cNamespace, writer, options); Engine.GetPlugin <ScriptCompiler> ().AddSource(writer.ToString()); }
/// <summary> /// Gets the full source code by applying an appropriate template based on the current <see cref="RoslynCodeTaskFactoryCodeType"/>. /// </summary> internal static string GetSourceCode(RoslynCodeTaskFactoryTaskInfo taskInfo, ICollection <TaskPropertyInfo> parameters) { if (taskInfo.CodeType == RoslynCodeTaskFactoryCodeType.Class) { return(taskInfo.SourceCode); } CodeTypeDeclaration codeTypeDeclaration = new CodeTypeDeclaration { IsClass = true, Name = taskInfo.Name, TypeAttributes = TypeAttributes.Public, Attributes = MemberAttributes.Final }; codeTypeDeclaration.BaseTypes.Add("Microsoft.Build.Utilities.Task"); foreach (TaskPropertyInfo propertyInfo in parameters) { CreateProperty(codeTypeDeclaration, propertyInfo.Name, propertyInfo.PropertyType); } if (taskInfo.CodeType == RoslynCodeTaskFactoryCodeType.Fragment) { CodeMemberProperty successProperty = CreateProperty(codeTypeDeclaration, "Success", typeof(bool), true); CodeMemberMethod executeMethod = new CodeMemberMethod { Name = "Execute", // ReSharper disable once BitwiseOperatorOnEnumWithoutFlags Attributes = MemberAttributes.Override | MemberAttributes.Public, ReturnType = new CodeTypeReference(typeof(Boolean)) }; executeMethod.Statements.Add(new CodeSnippetStatement(taskInfo.SourceCode)); executeMethod.Statements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(null, successProperty.Name))); codeTypeDeclaration.Members.Add(executeMethod); } else { codeTypeDeclaration.Members.Add(new CodeSnippetTypeMember(taskInfo.SourceCode)); } CodeNamespace codeNamespace = new CodeNamespace("InlineCode"); codeNamespace.Imports.AddRange(DefaultNamespaces.Union(taskInfo.Namespaces, StringComparer.OrdinalIgnoreCase).Select(i => new CodeNamespaceImport(i)).ToArray()); codeNamespace.Types.Add(codeTypeDeclaration); CodeCompileUnit codeCompileUnit = new CodeCompileUnit(); codeCompileUnit.Namespaces.Add(codeNamespace); using (CodeDomProvider provider = CodeDomProvider.CreateProvider(taskInfo.CodeLanguage)) { using (StringWriter writer = new StringWriter(new StringBuilder(), CultureInfo.CurrentCulture)) { provider.GenerateCodeFromCompileUnit(codeCompileUnit, writer, new CodeGeneratorOptions { BlankLinesBetweenMembers = true, VerbatimOrder = true }); return(writer.ToString()); } } }
private void GenerateNoArgumentAttribute(DynamicProperty dynamicProp, CodeMemberProperty property, Type attributeType) { var attribute = new CodeAttributeDeclaration(new CodeTypeReference(attributeType)); property.CustomAttributes.Add(attribute); }
public void Generate() { var errorEnum = this.generator.Types.SingleOrDefault(t => t.Name.EndsWith("Error")); if (errorEnum == null) { return; } // Add the exception type // Generate the {Name}Exception class CodeTypeDeclaration exceptionType = new CodeTypeDeclaration(); exceptionType.Attributes = MemberAttributes.Public | MemberAttributes.Final; exceptionType.Name = $"{this.generator.Name}Exception"; exceptionType.BaseTypes.Add(typeof(Exception)); exceptionType.Comments.Add( new CodeCommentStatement( $"Represents an exception that occurred when interacting with the {this.generator.Name} API.", true)); exceptionType.CustomAttributes.Add( new CodeAttributeDeclaration( new CodeTypeReference( typeof(SerializableAttribute)))); var defaultConstrutor = new CodeConstructor(); defaultConstrutor.Attributes = MemberAttributes.Public; defaultConstrutor.Comments.Add( new CodeCommentStatement( $"<summary>\r\n Initializes a new instance of the <see cref=\"{exceptionType.Name}\"/> class.\r\n </summary>", true)); exceptionType.Members.Add(defaultConstrutor); // Add the constructor which takes an error code var errorConstructor = new CodeConstructor(); errorConstructor.Attributes = MemberAttributes.Public; errorConstructor.Comments.Add( new CodeCommentStatement( $"<summary>\r\n Initializes a new instance of the <see cref=\"{exceptionType.Name}\"/> class with a specified error code.\r\n </summary>", true)); errorConstructor.Comments.Add( new CodeCommentStatement( $"<param name=\"error\">\r\n The error code of the error that occurred.\r\n </param>", true)); errorConstructor.BaseConstructorArgs.Add( new CodeMethodInvokeExpression( new CodeMethodReferenceExpression( new CodeTypeReferenceExpression(typeof(string)), "Format"), new CodePrimitiveExpression($"An {this.generator.Name} error occurred. The error code was {{0}}"), new CodeArgumentReferenceExpression("error"))); errorConstructor.Statements.Add( new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "errorCode"), new CodeArgumentReferenceExpression("error"))); errorConstructor.Parameters.Add( new CodeParameterDeclarationExpression( new CodeTypeReference($"{this.generator.Name}Error"), "error")); exceptionType.Members.Add(errorConstructor); // Add the constructor which takes an error code and an error message var errorWithMessageConstructor = new CodeConstructor(); errorWithMessageConstructor.Attributes = MemberAttributes.Public; errorWithMessageConstructor.Comments.Add( new CodeCommentStatement( $"<summary>\r\n Initializes a new instance of the <see cref=\"{exceptionType.Name}\"/> class with a specified error code and error message.\r\n <summary>", true)); errorWithMessageConstructor.Comments.Add( new CodeCommentStatement( $"<param name=\"error\">\r\n The error code of the error that occurred.\r\n </param>", true)); errorWithMessageConstructor.Comments.Add( new CodeCommentStatement( $"<param name=\"message\">\r\n A message which describes the error.\r\n </param>", true)); errorWithMessageConstructor.BaseConstructorArgs.Add( new CodeMethodInvokeExpression( new CodeMethodReferenceExpression( new CodeTypeReferenceExpression(typeof(string)), "Format"), new CodePrimitiveExpression($"An {this.generator.Name} error occurred. {{1}}. The error code was {{0}}"), new CodeArgumentReferenceExpression("error"), new CodeArgumentReferenceExpression("message"))); errorWithMessageConstructor.Statements.Add( new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "errorCode"), new CodeArgumentReferenceExpression("error"))); errorWithMessageConstructor.Parameters.Add( new CodeParameterDeclarationExpression( new CodeTypeReference($"{this.generator.Name}Error"), "error")); errorWithMessageConstructor.Parameters.Add( new CodeParameterDeclarationExpression( new CodeTypeReference(typeof(string)), "message")); exceptionType.Members.Add(errorWithMessageConstructor); // Add the Error field var errorCodeField = new CodeMemberField(); errorCodeField.Name = "errorCode"; errorCodeField.Type = new CodeTypeReference($"{this.generator.Name}Error"); errorCodeField.Comments.Add( new CodeCommentStatement( "<summary>\r\n Backing field for the <see cref=\"ErrorCode\"/> property.\r\n </summary>", true)); exceptionType.Members.Add(errorCodeField); var errorCodeProperty = new CodeMemberProperty(); errorCodeProperty.Attributes = MemberAttributes.Public; errorCodeProperty.Name = "ErrorCode"; errorCodeProperty.Type = new CodeTypeReference($"{this.generator.Name}Error"); errorCodeProperty.HasGet = true; errorCodeProperty.GetStatements.Add( new CodeMethodReturnStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "errorCode"))); errorCodeProperty.Comments.Add( new CodeCommentStatement( "<summary>\r\n Gets the error code that represents the error.\r\n </summary>", true)); exceptionType.Members.Add(errorCodeProperty); var messageConstructor = new CodeConstructor(); messageConstructor.Attributes = MemberAttributes.Public; messageConstructor.Comments.Add( new CodeCommentStatement( $"<summary>\r\n Initializes a new instance of the <see cref=\"{exceptionType.Name}\"/> class with a specified error message.\r\n</summary>", true)); messageConstructor.Comments.Add( new CodeCommentStatement( $"<param name=\"message\">\r\n The message that describes the error.\r\n</param>", true)); messageConstructor.BaseConstructorArgs.Add( new CodeArgumentReferenceExpression("message")); messageConstructor.Parameters.Add( new CodeParameterDeclarationExpression( typeof(string), "message")); exceptionType.Members.Add(messageConstructor); var messageAndInnerConstructor = new CodeConstructor(); messageAndInnerConstructor.Attributes = MemberAttributes.Public; messageAndInnerConstructor.Comments.Add( new CodeCommentStatement( $"<summary>\r\n Initializes a new instance of the <see cref=\"{exceptionType.Name}\"/> class with a specified error message and a reference to the inner exception that is the cause of this exception.\r\n </summary>", true)); messageAndInnerConstructor.Comments.Add( new CodeCommentStatement( $"<param name=\"message\">\r\n The error message that explains the reason for the exception.\r\n </param>", true)); messageAndInnerConstructor.Comments.Add( new CodeCommentStatement( $"<param name=\"inner\">\r\n The exception that is the cause of the current exception, or <see langword=\"null\"/> if no inner exception is specified.\r\n </param>", true)); messageAndInnerConstructor.BaseConstructorArgs.Add( new CodeArgumentReferenceExpression("message")); messageAndInnerConstructor.BaseConstructorArgs.Add( new CodeArgumentReferenceExpression("inner")); messageAndInnerConstructor.Parameters.Add( new CodeParameterDeclarationExpression( typeof(string), "message")); messageAndInnerConstructor.Parameters.Add( new CodeParameterDeclarationExpression( typeof(Exception), "inner")); exceptionType.Members.Add(messageAndInnerConstructor); var serializedConstructor = new CodeConstructor(); serializedConstructor.Attributes = MemberAttributes.Family; serializedConstructor.Comments.Add( new CodeCommentStatement( $"<summary>\r\n Initializes a new instance of the <see cref=\"{exceptionType.Name}\"/> class with serialized data.\r\n </summary>", true)); serializedConstructor.Comments.Add( new CodeCommentStatement( $"<param name=\"info\">\r\n The <see cref=\"System.Runtime.Serialization.SerializationInfo\"/> that holds the serialized object data about the exception being thrown.\r\n </param>", true)); serializedConstructor.Comments.Add( new CodeCommentStatement( $"<param name=\"context\">\r\n The <see cref=\"System.Runtime.Serialization.StreamingContext\"/> that contains contextual information about the source or destination.\r\n </param>", true)); serializedConstructor.BaseConstructorArgs.Add( new CodeArgumentReferenceExpression("info")); serializedConstructor.BaseConstructorArgs.Add( new CodeArgumentReferenceExpression("context")); serializedConstructor.Parameters.Add( new CodeParameterDeclarationExpression( typeof(SerializationInfo), "info")); serializedConstructor.Parameters.Add( new CodeParameterDeclarationExpression( typeof(StreamingContext), "context")); serializedConstructor.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "!core")); exceptionType.Members.Add(serializedConstructor); serializedConstructor.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "!core")); this.generator.AddType(exceptionType.Name, exceptionType); CodeTypeDeclaration extensionsType = new CodeTypeDeclaration(); extensionsType.Name = $"{errorEnum.Name}Extensions"; extensionsType.Attributes = MemberAttributes.Public | MemberAttributes.Static; // Add the ThrowOnError method CodeMemberMethod throwOnErrorMethod = new CodeMemberMethod(); throwOnErrorMethod.Name = "ThrowOnError"; throwOnErrorMethod.Attributes = MemberAttributes.Static | MemberAttributes.Public; var parameter = new CodeParameterDeclarationExpression(); parameter.Name = "value"; parameter.Type = new CodeTypeReference("this " + errorEnum.Name); throwOnErrorMethod.Parameters.Add(parameter); throwOnErrorMethod.Statements.Add( new CodeConditionStatement( new CodeBinaryOperatorExpression( new CodeArgumentReferenceExpression("value"), CodeBinaryOperatorType.IdentityInequality, new CodePropertyReferenceExpression( new CodeTypeReferenceExpression(errorEnum.Name), "Success")), new CodeThrowExceptionStatement( new CodeObjectCreateExpression( new CodeTypeReference(exceptionType.Name), new CodeArgumentReferenceExpression("value"))))); extensionsType.Members.Add(throwOnErrorMethod); // Add the ThrowOnError overload which takes an error message CodeMemberMethod throwOnErrorWithMessageMethod = new CodeMemberMethod(); throwOnErrorWithMessageMethod.Name = "ThrowOnError"; throwOnErrorWithMessageMethod.Attributes = MemberAttributes.Static | MemberAttributes.Public; var throwOnErrorWithMessageMethodParameter = new CodeParameterDeclarationExpression(); throwOnErrorWithMessageMethodParameter.Name = "value"; throwOnErrorWithMessageMethodParameter.Type = new CodeTypeReference("this " + errorEnum.Name); throwOnErrorWithMessageMethod.Parameters.Add(throwOnErrorWithMessageMethodParameter); var messageParameter = new CodeParameterDeclarationExpression(); messageParameter.Name = "message"; messageParameter.Type = new CodeTypeReference(typeof(string)); throwOnErrorWithMessageMethod.Parameters.Add(messageParameter); throwOnErrorWithMessageMethod.Statements.Add( new CodeConditionStatement( new CodeBinaryOperatorExpression( new CodeArgumentReferenceExpression("value"), CodeBinaryOperatorType.IdentityInequality, new CodePropertyReferenceExpression( new CodeTypeReferenceExpression(errorEnum.Name), "Success")), new CodeThrowExceptionStatement( new CodeObjectCreateExpression( new CodeTypeReference(exceptionType.Name), new CodeArgumentReferenceExpression("value"), new CodeArgumentReferenceExpression("message"))))); extensionsType.Members.Add(throwOnErrorWithMessageMethod); // Add the CheckError method CodeMemberMethod isErrorMethod = new CodeMemberMethod(); isErrorMethod.Name = "IsError"; isErrorMethod.Attributes = MemberAttributes.Static | MemberAttributes.Public; isErrorMethod.ReturnType = new CodeTypeReference(typeof(bool)); isErrorMethod.Parameters.Add(parameter); isErrorMethod.Statements.Add( new CodeMethodReturnStatement( new CodeBinaryOperatorExpression( new CodeArgumentReferenceExpression("value"), CodeBinaryOperatorType.IdentityInequality, new CodePropertyReferenceExpression( new CodeTypeReferenceExpression(errorEnum.Name), "Success")))); extensionsType.Members.Add(isErrorMethod); this.generator.AddType(extensionsType.Name, extensionsType); }
/// <summary> /// Creates a backing field for the given property /// </summary> /// <param name="property">The code property</param> /// <returns>A reference to the generated backing field</returns> public static CodeFieldReferenceExpression CreateBackingField(this CodeMemberProperty property) { return(CreateBackingField(property, property.Type, null)); }
public override void ModifyImplementation(CodeNamespace cns, CodeTypeDeclaration ctd, Type type) { if (implementation == NullableImplementation.Default || implementation == NullableImplementation.Abstract) { ctd.BaseTypes.Add(new CodeTypeReference("INullable")); CodeMemberProperty prop = new CodeMemberProperty(); prop.Name = "IsNull"; prop.Type = new CodeTypeReference(typeof(bool)); prop.Attributes = MemberAttributes.Public; prop.GetStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(false))); ctd.Members.Add(prop); } if (implementation != NullableImplementation.Abstract) { CodeTypeDeclaration newType = new CodeTypeDeclaration("Null" + ctd.Name); newType.TypeAttributes = TypeAttributes.Class | TypeAttributes.NotPublic | TypeAttributes.Sealed; newType.BaseTypes.Add(new CodeTypeReference(ctd.Name)); cns.Types.Add(newType); System.Reflection.ConstructorInfo baseCtor = MainClass.GetBaseCtor(type); if (baseCtor != null) { CodeConstructor ctor = new CodeConstructor(); ctor.Attributes = MemberAttributes.Private; foreach (object o in baseCtor.GetParameters()) { ctor.BaseConstructorArgs.Add(new CodePrimitiveExpression(null)); } newType.Members.Add(ctor); } CodeMemberField field = new CodeMemberField(newType.Name, "Instance"); field.Attributes = MemberAttributes.Static | MemberAttributes.Assembly; field.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference(newType.Name)); newType.Members.Add(field); CodeMemberProperty prop = new CodeMemberProperty(); prop.Name = "IsNull"; prop.Type = new CodeTypeReference(typeof(bool)); prop.Attributes = MemberAttributes.Public | MemberAttributes.Override; prop.GetStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(true))); newType.Members.Add(prop); CodeMemberMethod method = new CodeMemberMethod(); method.Name = "AcceptVisitor"; method.Attributes = MemberAttributes.Public | MemberAttributes.Override; method.Parameters.Add(new CodeParameterDeclarationExpression("IAstVisitor", "visitor")); method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "data")); method.ReturnType = new CodeTypeReference(typeof(object)); method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null))); newType.Members.Add(method); method = new CodeMemberMethod(); method.Name = "ToString"; method.Attributes = MemberAttributes.Public | MemberAttributes.Override; method.ReturnType = new CodeTypeReference(typeof(string)); method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression("[" + newType.Name + "]"))); newType.Members.Add(method); prop = new CodeMemberProperty(); prop.Name = "Null"; prop.Type = new CodeTypeReference(ctd.Name); prop.Attributes = MemberAttributes.Public | MemberAttributes.Static; if (implementation == NullableImplementation.Shadow) { prop.Attributes |= MemberAttributes.New; } CodeExpression ex = new CodeTypeReferenceExpression(newType.Name); ex = new CodePropertyReferenceExpression(ex, "Instance"); prop.GetStatements.Add(new CodeMethodReturnStatement(ex)); ctd.Members.Add(prop); } }
/// <summary> /// Marks the given code property as a collection property /// </summary> /// <param name="property">The property</param> public static void MarkCollectionProperty(this CodeMemberProperty property) { property.AddAttribute(typeof(DesignerSerializationVisibilityAttribute), DesignerSerializationVisibility.Content); }
protected override void VisitType(CodeTypeDeclaration type) { var arrayMembers = type.Members.OfType <CodeMemberField>().Where(x => !x.Name.StartsWith("__") && x.Type.ArrayElementType != null && !_typesToIgnore.Contains(x.Type.ArrayElementType.BaseType)).ToList(); foreach (var field in arrayMembers) { var prop = new CodeMemberProperty() { Type = field.Type, Name = "__" + field.Name, Attributes = field.Attributes }; prop.CustomAttributes.AddRange(field.CustomAttributes); var fieldName = field.Name.MakePrivateFieldName(); prop.GetStatements.Add(new CodeSnippetExpression() { Value = $@"return {fieldName}?.ToArray()" }); prop.SetStatements.Add(new CodeSnippetExpression() { Value = $@"{fieldName} = value == null ? null : new System.Collections.Generic.List<{field.Type.ArrayElementType.BaseType}>(value)" }); var interfaceDecl = ""; var visibility = "public "; if (type.IsMaindocSchema() && new[] { "UBLExtensions", "Signature" }.Contains(field.Name)) { interfaceDecl = "IBaseDocument."; visibility = ""; } var snip = new CodeSnippetTypeMember(); snip.Text = $@" [System.Xml.Serialization.XmlIgnoreAttribute] {visibility}System.Collections.Generic.List<{field.Type.ArrayElementType.BaseType}> {interfaceDecl}{field.Name} {{ get {{ return {fieldName} ?? ({fieldName} = new System.Collections.Generic.List<{field.Type.ArrayElementType.BaseType}>()); }} set {{ {fieldName} = value; }} }}" + Environment.NewLine; snip.Comments.AddRange(field.Comments); //var propPub = new CodeMemberProperty() //{ // Type = field.Type, // Name = field.Name, // Attributes = field.Attributes, // CustomAttributes = field.CustomAttributes //}; //propPub.Comments.AddRange(field.Comments); //propPub.GetStatements.Add(new CodeSnippetExpression() //{ // Value = $@"return __{field.Name}" //}); //propPub.SetStatements.Add(new CodeSnippetExpression() //{ // Value = $@"__{field.Name} = value" //}); field.Name = fieldName; field.Attributes = MemberAttributes.Private; field.Type = new CodeTypeReference($"System.Collections.Generic.List<{field.Type.ArrayElementType.BaseType}>"); field.CustomAttributes.Clear(); field.Comments.Clear(); // Fix items choice types var attr = prop.CustomAttributes.Cast <CodeAttributeDeclaration>().FirstOrDefault(x => x.Name.EndsWith("XmlChoiceIdentifierAttribute")); if (attr != null) { var expr = (CodePrimitiveExpression)attr.Arguments[0].Value; expr.Value = "__" + expr.Value; } var index = type.Members.IndexOf(field); type.Members.Insert(index + 1, prop); type.Members.Add(snip); } // base.VisitType(type); }
/// <summary> /// Implements the setter of the given property /// </summary> /// <param name="property">The code property</param> /// <param name="fieldRef">A reference to the underlying field</param> /// <param name="whenChanged">A collection of statements that should be performed when the value of the property changed</param> public static void ImplementSetter(this CodeMemberProperty property, CodeFieldReferenceExpression fieldRef, params CodeStatement[] whenChanged) { ImplementSetter(property, fieldRef, (IEnumerable <CodeStatement>)whenChanged); }
private void AddClassVariableToCodeBase(GameDataVariable classVariable) { if (classVariable.VariableType.Contains("List")) { CodeMemberProperty publicProperty = new CodeMemberProperty(); publicProperty.Attributes = MemberAttributes.Public; publicProperty.HasGet = true; publicProperty.HasSet = true; publicProperty.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(classVariable.PrivateVariableName), new CodeVariableReferenceExpression("value"))); publicProperty.Name = classVariable.PublicVariableName; publicProperty.Type = new CodeTypeReference(classVariable.VariableType); CodeExpression getter = new CodeSnippetExpression(string.Format("return {0}", classVariable.PrivateVariableName)); publicProperty.GetStatements.Add(getter); _codeBase.Namespaces[0].Types[0].Members.Add(publicProperty); CodeMemberField var = new CodeMemberField(classVariable.VariableType, classVariable.PrivateVariableName); var.Attributes = MemberAttributes.Private; var.InitExpression = new CodeSnippetExpression("new " + classVariable.VariableType + "()"); _codeBase.Namespaces[0].Types[0].Members.Add(var); } else if (classVariable.VariableType.Contains("I18n")) { CodeMemberProperty publicProperty = new CodeMemberProperty(); publicProperty.Attributes = MemberAttributes.Public; publicProperty.HasGet = true; publicProperty.HasSet = true; publicProperty.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(classVariable.PrivateVariableName), new CodeVariableReferenceExpression("value"))); publicProperty.Name = classVariable.PublicVariableName; publicProperty.Type = new CodeTypeReference(typeof(string)); CodeExpression getter = new CodeSnippetExpression(string.Format("return {0}", classVariable.PrivateVariableName + ".GetText()")); publicProperty.GetStatements.Add(getter); _codeBase.Namespaces[0].Types[0].Members.Add(publicProperty); CodeMemberField privateVar = new CodeMemberField("I18nProperty", classVariable.PrivateVariableName); privateVar.Attributes = MemberAttributes.Private; _codeBase.Namespaces[0].Types[0].Members.Add(privateVar); } else if (_primitiveType.ContainsKey(classVariable.VariableType)) { Type Type = _primitiveType[classVariable.VariableType]; CodeMemberProperty publicProperty = new CodeMemberProperty(); publicProperty.Attributes = MemberAttributes.Public; publicProperty.HasGet = true; publicProperty.HasSet = true; publicProperty.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(classVariable.PrivateVariableName), new CodeVariableReferenceExpression("value"))); publicProperty.Name = classVariable.PublicVariableName; publicProperty.Type = new CodeTypeReference(Type); CodeExpression getter = new CodeSnippetExpression(string.Format("return {0}", classVariable.PrivateVariableName)); publicProperty.GetStatements.Add(getter); _codeBase.Namespaces[0].Types[0].Members.Add(publicProperty); CodeMemberField privateVar = new CodeMemberField(Type, classVariable.PrivateVariableName); privateVar.Attributes = MemberAttributes.Private; _codeBase.Namespaces[0].Types[0].Members.Add(privateVar); } else { CodeMemberProperty publicProperty = new CodeMemberProperty(); publicProperty.Attributes = MemberAttributes.Public; publicProperty.HasGet = true; publicProperty.HasSet = true; publicProperty.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(classVariable.PrivateVariableName), new CodeVariableReferenceExpression("value"))); publicProperty.Name = classVariable.PublicVariableName; publicProperty.Type = new CodeTypeReference(classVariable.VariableType.Replace(";", "")); CodeExpression getter = new CodeSnippetExpression(string.Format("return {0}", classVariable.PrivateVariableName)); publicProperty.GetStatements.Add(getter); _codeBase.Namespaces[0].Types[0].Members.Add(publicProperty); CodeMemberField var = new CodeMemberField(classVariable.VariableType.Replace(";", ""), classVariable.PrivateVariableName); _codeBase.Namespaces[0].Types[0].Members.Add(var); } }
private void GenerateConfigurationElementCollectionCode(ConfigurationElement element, CodeTypeDeclaration elementClass) { ConfigurationElementCollection collectionElement = (ConfigurationElementCollection)element; ConfigurationProperty keyProperty = collectionElement.ItemType.KeyProperties.Single(); string xmlPropertyName = string.Format("{0}PropertyName", collectionElement.ItemType.Name); string configurationElementTypeReference = GetTypeReferenceString(typeof(System.Configuration.ConfigurationElement)); string configurationElementCollectionTypeReference = GetTypeReferenceString(typeof(System.Configuration.ConfigurationElementCollection)); CodeTypeReference collectionItemType = GlobalSelfReference(collectionElement.ItemType.FullName); string collectionItemTypeReference = GetTypeSelfReferenceString(collectionElement.ItemType.FullName); CodeTypeReference icollectionTypeReference = null; if ((collectionElement.CodeGenOptions & ConfigurationElementCollectionCodeGenOptions.ICollection) == ConfigurationElementCollectionCodeGenOptions.ICollection) { icollectionTypeReference = new CodeTypeReference(string.Concat("global::System.Collections.Generic.ICollection<", collectionItemTypeReference, ">")); elementClass.BaseTypes.Add(icollectionTypeReference); } // Add ConfigurationCollectionAttribute CodeAttributeDeclaration collectionType = new CodeAttributeDeclaration( GlobalReference(typeof(System.Configuration.ConfigurationCollectionAttribute)), new CodeAttributeArgument(_selftypeof(collectionElement.ItemType.FullName)), new CodeAttributeArgument("CollectionType", new CodeFieldReferenceExpression( GlobalReferenceExpression(collectionElement.CollectionType.GetType()), Enum.GetName(collectionElement.CollectionType.GetType(), collectionElement.CollectionType) ) ) ); if (collectionElement.CollectionType == System.Configuration.ConfigurationElementCollectionType.BasicMap || collectionElement.CollectionType == System.Configuration.ConfigurationElementCollectionType.BasicMapAlternate) { collectionType.Arguments.Add( new CodeAttributeArgument("AddItemName", new CodeFieldReferenceExpression( GlobalSelfReferenceExpression(element.FullName), xmlPropertyName ) ) ); } else { collectionType.Arguments.Add( new CodeAttributeArgument("AddItemName", new CodePrimitiveExpression(collectionElement.AddItemName) ) ); collectionType.Arguments.Add( new CodeAttributeArgument("RemoveItemName", new CodePrimitiveExpression(collectionElement.RemoveItemName) ) ); collectionType.Arguments.Add( new CodeAttributeArgument("ClearItemsName", new CodePrimitiveExpression(collectionElement.ClearItemsName) ) ); } elementClass.CustomAttributes.Add(collectionType); // Add XmlName field CodeMemberField xmlNameField = new CodeMemberField(_string, xmlPropertyName); elementClass.Members.Add(xmlNameField); xmlNameField.StartDirectives.Add(Region("Constants")); xmlNameField.Comments.Add(DocComment("<summary>")); xmlNameField.Comments.Add(DocComment(string.Format("The XML name of the individual <see cref=\"{0}\"/> instances in this collection.", collectionItemTypeReference))); xmlNameField.Comments.Add(DocComment("</summary>")); xmlNameField.CustomAttributes.Add(_generatedCodeAttribute); xmlNameField.Attributes = MemberAttributes.Const | MemberAttributes.Assembly; xmlNameField.InitExpression = new CodePrimitiveExpression(collectionElement.XmlItemName); xmlNameField.EndDirectives.Add(EndRegion()); // Add collection type property CodeMemberProperty collectionTypeProperty = new CodeMemberProperty(); elementClass.Members.Add(collectionTypeProperty); collectionTypeProperty.StartDirectives.Add(Region("Overrides")); collectionTypeProperty.Comments.Add(DocComment("<summary>")); collectionTypeProperty.Comments.Add(DocComment(string.Format("Gets the type of the <see cref=\"{0}\"/>.", configurationElementCollectionTypeReference))); collectionTypeProperty.Comments.Add(DocComment("</summary>")); collectionTypeProperty.Comments.Add(DocComment(string.Format("<returns>The <see cref=\"{0}\"/> of this collection.</returns>", GetTypeReferenceString(typeof(System.Configuration.ConfigurationElementCollectionType))))); collectionTypeProperty.CustomAttributes.Add(_generatedCodeAttribute); collectionTypeProperty.Attributes = MemberAttributes.Public | MemberAttributes.Override; collectionTypeProperty.Type = GlobalReference(typeof(System.Configuration.ConfigurationElementCollectionType)); collectionTypeProperty.Name = "CollectionType"; collectionTypeProperty.HasGet = true; collectionTypeProperty.GetStatements.Add( new CodeMethodReturnStatement( new CodeFieldReferenceExpression( GlobalReferenceExpression(collectionElement.CollectionType.GetType()), Enum.GetName(collectionElement.CollectionType.GetType(), collectionElement.CollectionType) ) ) ); // Add ElementName property CodeMemberProperty elementNameProperty = new CodeMemberProperty(); elementClass.Members.Add(elementNameProperty); elementNameProperty.Comments.Add(DocComment("<summary>")); elementNameProperty.Comments.Add(DocComment("Gets the name used to identify this collection of elements")); elementNameProperty.Comments.Add(DocComment("</summary>")); elementNameProperty.CustomAttributes.Add(_generatedCodeAttribute); elementNameProperty.Attributes = MemberAttributes.Family | MemberAttributes.Override; elementNameProperty.Type = _string; elementNameProperty.Name = "ElementName"; elementNameProperty.HasGet = true; elementNameProperty.GetStatements.Add( new CodeMethodReturnStatement( new CodeFieldReferenceExpression( GlobalSelfReferenceExpression(element.FullName), xmlPropertyName ) ) ); // Add IsElementName method CodeMemberMethod isElementNameMethod = new CodeMemberMethod(); elementClass.Members.Add(isElementNameMethod); isElementNameMethod.Comments.Add(DocComment("<summary>")); isElementNameMethod.Comments.Add(DocComment(string.Format("Indicates whether the specified <see cref=\"{0}\"/> exists in the <see cref=\"{1}\"/>.", configurationElementTypeReference, configurationElementCollectionTypeReference))); isElementNameMethod.Comments.Add(DocComment("</summary>")); isElementNameMethod.Comments.Add(DocComment("<param name=\"elementName\">The name of the element to verify.</param>")); isElementNameMethod.Comments.Add(DocComment("<returns>")); isElementNameMethod.Comments.Add(DocComment("<see langword=\"true\"/> if the element exists in the collection; otherwise, <see langword=\"false\"/>.")); isElementNameMethod.Comments.Add(DocComment("</returns>")); isElementNameMethod.CustomAttributes.Add(_generatedCodeAttribute); isElementNameMethod.Attributes = MemberAttributes.Family | MemberAttributes.Override; isElementNameMethod.ReturnType = GlobalReference(typeof(bool)); isElementNameMethod.Name = "IsElementName"; isElementNameMethod.Parameters.Add(new CodeParameterDeclarationExpression(_string, "elementName")); isElementNameMethod.Statements.Add( new CodeMethodReturnStatement( new CodeBinaryOperatorExpression( new CodeArgumentReferenceExpression("elementName"), CodeBinaryOperatorType.ValueEquality, new CodeFieldReferenceExpression( GlobalSelfReferenceExpression(string.Format("{0}.{1}", element.ActualNamespace, element.Name)), xmlNameField.Name ) ) ) ); // Add GetElementKey method CodeMemberMethod getElementKeyMethod = new CodeMemberMethod(); elementClass.Members.Add(getElementKeyMethod); getElementKeyMethod.Comments.Add(DocComment("<summary>")); getElementKeyMethod.Comments.Add(DocComment("Gets the element key for the specified configuration element.")); getElementKeyMethod.Comments.Add(DocComment("</summary>")); getElementKeyMethod.Comments.Add(DocComment(string.Format("<param name=\"element\">The <see cref=\"{0}\"/> to return the key for.</param>", configurationElementTypeReference))); getElementKeyMethod.Comments.Add(DocComment("<returns>")); getElementKeyMethod.Comments.Add(DocComment(string.Format("An <see cref=\"{0}\"/> that acts as the key for the specified <see cref=\"{1}\"/>.", GetTypeReferenceString(typeof(object)), configurationElementTypeReference))); getElementKeyMethod.Comments.Add(DocComment("</returns>")); getElementKeyMethod.CustomAttributes.Add(_generatedCodeAttribute); getElementKeyMethod.Attributes = MemberAttributes.Family | MemberAttributes.Override; getElementKeyMethod.ReturnType = _object; getElementKeyMethod.Name = "GetElementKey"; getElementKeyMethod.Parameters.Add(new CodeParameterDeclarationExpression(GlobalReference(typeof(System.Configuration.ConfigurationElement)), "element")); getElementKeyMethod.Statements.Add( new CodeMethodReturnStatement( new CodeFieldReferenceExpression( new CodeCastExpression( GlobalSelfReference(collectionElement.ItemType.FullName), new CodeArgumentReferenceExpression("element") ), keyProperty.Name ) ) ); // Add CreateNewElement method CodeMemberMethod createNewElementMethod = new CodeMemberMethod(); elementClass.Members.Add(createNewElementMethod); createNewElementMethod.Comments.Add(DocComment("<summary>")); createNewElementMethod.Comments.Add(DocComment(string.Format("Creates a new <see cref=\"{0}\"/>.", collectionItemTypeReference))); createNewElementMethod.Comments.Add(DocComment("</summary>")); createNewElementMethod.Comments.Add(DocComment("<returns>")); createNewElementMethod.Comments.Add(DocComment(string.Format("A new <see cref=\"{0}\"/>.", collectionItemTypeReference))); createNewElementMethod.Comments.Add(DocComment("</returns>")); createNewElementMethod.CustomAttributes.Add(_generatedCodeAttribute); createNewElementMethod.Attributes = MemberAttributes.Family | MemberAttributes.Override; createNewElementMethod.ReturnType = GlobalReference(typeof(System.Configuration.ConfigurationElement)); createNewElementMethod.Name = "CreateNewElement"; createNewElementMethod.Statements.Add( new CodeMethodReturnStatement(new CodeObjectCreateExpression(collectionItemType)) ); createNewElementMethod.EndDirectives.Add(EndRegion()); if ((collectionElement.CodeGenOptions & ConfigurationElementCollectionCodeGenOptions.Indexer) == ConfigurationElementCollectionCodeGenOptions.Indexer) { // Add indexer for location CodeMemberProperty locationIndexerProperty = new CodeMemberProperty(); elementClass.Members.Add(locationIndexerProperty); locationIndexerProperty.StartDirectives.Add(Region("Indexer")); locationIndexerProperty.Comments.Add(DocComment("<summary>")); locationIndexerProperty.Comments.Add(DocComment(string.Format("Gets the <see cref=\"{0}\"/> at the specified index.", collectionItemTypeReference))); locationIndexerProperty.Comments.Add(DocComment("</summary>")); locationIndexerProperty.Comments.Add(DocComment(string.Format("<param name=\"index\">The index of the <see cref=\"{0}\"/> to retrieve.</param>", collectionItemTypeReference))); locationIndexerProperty.CustomAttributes.Add(_generatedCodeAttribute); locationIndexerProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Overloaded; locationIndexerProperty.Type = GlobalSelfReference(collectionElement.ItemType.FullName); locationIndexerProperty.Name = "Item"; locationIndexerProperty.Parameters.Add(new CodeParameterDeclarationExpression(_int, "index")); locationIndexerProperty.HasGet = true; locationIndexerProperty.GetStatements.Add( new CodeMethodReturnStatement( new CodeCastExpression( collectionItemType, new CodeMethodInvokeExpression( _base, "BaseGet", new CodeArgumentReferenceExpression("index") ) ) ) ); // Add GetItemByKey method CodeMemberProperty keyIndexerProperty = new CodeMemberProperty(); elementClass.Members.Add(keyIndexerProperty); keyIndexerProperty.Comments.Add(DocComment("<summary>")); keyIndexerProperty.Comments.Add(DocComment(string.Format("Gets the <see cref=\"{0}\"/> with the specified key.", collectionItemTypeReference))); keyIndexerProperty.Comments.Add(DocComment("</summary>")); keyIndexerProperty.Comments.Add(DocComment(string.Format("<param name=\"{0}\">The key of the <see cref=\"{1}\"/> to retrieve.</param>", keyProperty.XmlName, collectionItemTypeReference))); keyIndexerProperty.CustomAttributes.Add(_generatedCodeAttribute); keyIndexerProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Overloaded; keyIndexerProperty.Type = collectionItemType; keyIndexerProperty.Name = "Item"; keyIndexerProperty.Parameters.Add(new CodeParameterDeclarationExpression(_object, keyProperty.XmlName)); keyIndexerProperty.GetStatements.Add( new CodeMethodReturnStatement( new CodeCastExpression( collectionItemType, new CodeMethodInvokeExpression( _base, "BaseGet", new CodeArgumentReferenceExpression(keyProperty.XmlName) ) ) ) ); keyIndexerProperty.EndDirectives.Add(EndRegion()); } if ((collectionElement.CodeGenOptions & ConfigurationElementCollectionCodeGenOptions.AddMethod) == ConfigurationElementCollectionCodeGenOptions.AddMethod || (collectionElement.CodeGenOptions & ConfigurationElementCollectionCodeGenOptions.ICollection) == ConfigurationElementCollectionCodeGenOptions.ICollection) { // Add Add method CodeMemberMethod addMethod = new CodeMemberMethod(); elementClass.Members.Add(addMethod); addMethod.StartDirectives.Add(Region("Add")); addMethod.Comments.Add(DocComment("<summary>")); addMethod.Comments.Add(DocComment(string.Format("Adds the specified <see cref=\"{0}\"/> to the <see cref=\"{1}\"/>.", collectionItemTypeReference, configurationElementCollectionTypeReference))); addMethod.Comments.Add(DocComment("</summary>")); addMethod.Comments.Add(DocComment(string.Format("<param name=\"{0}\">The <see cref=\"{1}\"/> to add.</param>", collectionElement.XmlItemName, collectionItemTypeReference))); addMethod.CustomAttributes.Add(_generatedCodeAttribute); addMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final; addMethod.ReturnType = _void; addMethod.Name = "Add"; addMethod.Parameters.Add(new CodeParameterDeclarationExpression(GlobalSelfReference(collectionElement.ItemType.FullName), collectionElement.XmlItemName)); addMethod.Statements.Add( new CodeMethodInvokeExpression( _base, "BaseAdd", new CodeArgumentReferenceExpression(collectionElement.XmlItemName) ) ); addMethod.EndDirectives.Add(EndRegion()); } if ((collectionElement.CodeGenOptions & ConfigurationElementCollectionCodeGenOptions.RemoveMethod) == ConfigurationElementCollectionCodeGenOptions.RemoveMethod || (collectionElement.CodeGenOptions & ConfigurationElementCollectionCodeGenOptions.ICollection) == ConfigurationElementCollectionCodeGenOptions.ICollection) { // Add Remove method CodeMemberMethod removeMethod = new CodeMemberMethod(); elementClass.Members.Add(removeMethod); removeMethod.StartDirectives.Add(Region("Remove")); removeMethod.Comments.Add(DocComment("<summary>")); removeMethod.Comments.Add(DocComment(string.Format("Removes the specified <see cref=\"{0}\"/> from the <see cref=\"{1}\"/>.", collectionItemTypeReference, configurationElementCollectionTypeReference))); removeMethod.Comments.Add(DocComment("</summary>")); removeMethod.Comments.Add(DocComment(string.Format("<param name=\"{0}\">The <see cref=\"{1}\"/> to remove.</param>", collectionElement.XmlItemName, collectionItemTypeReference))); removeMethod.CustomAttributes.Add(_generatedCodeAttribute); removeMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final; removeMethod.ReturnType = _void; removeMethod.Name = "Remove"; removeMethod.Parameters.Add(new CodeParameterDeclarationExpression(collectionItemType, collectionElement.XmlItemName)); removeMethod.Statements.Add( new CodeMethodInvokeExpression( _base, "BaseRemove", new CodeMethodInvokeExpression( _this, "GetElementKey", new CodeArgumentReferenceExpression(collectionElement.XmlItemName) ) ) ); removeMethod.EndDirectives.Add(EndRegion()); } if ((collectionElement.CodeGenOptions & ConfigurationElementCollectionCodeGenOptions.GetItemMethods) == ConfigurationElementCollectionCodeGenOptions.GetItemMethods) { // Add GetItemAt method CodeMemberMethod getItemAtMethod = new CodeMemberMethod(); elementClass.Members.Add(getItemAtMethod); getItemAtMethod.StartDirectives.Add(Region("GetItem")); getItemAtMethod.Comments.Add(DocComment("<summary>")); getItemAtMethod.Comments.Add(DocComment(string.Format("Gets the <see cref=\"{0}\"/> at the specified index.", collectionItemTypeReference))); getItemAtMethod.Comments.Add(DocComment("</summary>")); getItemAtMethod.Comments.Add(DocComment(string.Format("<param name=\"index\">The index of the <see cref=\"{0}\"/> to retrieve.</param>", collectionItemTypeReference))); getItemAtMethod.CustomAttributes.Add(_generatedCodeAttribute); getItemAtMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final; getItemAtMethod.ReturnType = collectionItemType; getItemAtMethod.Name = "GetItemAt"; getItemAtMethod.Parameters.Add(new CodeParameterDeclarationExpression(_int, "index")); getItemAtMethod.Statements.Add( new CodeMethodReturnStatement( new CodeCastExpression( collectionItemType, new CodeMethodInvokeExpression( _base, "BaseGet", new CodeArgumentReferenceExpression("index") ) ) ) ); // Add GetItemByKey method CodeMemberMethod getItemByKeyMethod = new CodeMemberMethod(); elementClass.Members.Add(getItemByKeyMethod); getItemByKeyMethod.Comments.Add(DocComment("<summary>")); getItemByKeyMethod.Comments.Add(DocComment(string.Format("Gets the <see cref=\"{0}\"/> with the specified key.", collectionItemTypeReference))); getItemByKeyMethod.Comments.Add(DocComment("</summary>")); getItemByKeyMethod.Comments.Add(DocComment(string.Format("<param name=\"{0}\">The key of the <see cref=\"{1}\"/> to retrieve.</param>", keyProperty.XmlName, collectionItemTypeReference))); getItemByKeyMethod.CustomAttributes.Add(_generatedCodeAttribute); getItemByKeyMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final; getItemByKeyMethod.ReturnType = collectionItemType; getItemByKeyMethod.Name = "GetItemByKey"; getItemByKeyMethod.Parameters.Add(new CodeParameterDeclarationExpression(GlobalReference(keyProperty.TypeName), keyProperty.XmlName)); getItemByKeyMethod.Statements.Add( new CodeMethodReturnStatement( new CodeCastExpression( collectionItemType, new CodeMethodInvokeExpression( _base, "BaseGet", new CodeCastExpression( _object, new CodeArgumentReferenceExpression(keyProperty.XmlName) ) ) ) ) ); getItemByKeyMethod.EndDirectives.Add(EndRegion()); } if ((collectionElement.CodeGenOptions & ConfigurationElementCollectionCodeGenOptions.ICollection) == ConfigurationElementCollectionCodeGenOptions.ICollection) { // Add Clear method CodeMemberMethod clearMethod = new CodeMemberMethod(); elementClass.Members.Add(clearMethod); clearMethod.StartDirectives.Add(Region("ICollection")); clearMethod.Comments.Add(DocComment("<summary>")); clearMethod.Comments.Add(DocComment(string.Format("Removes all items from the <see cref=\"{0}\"/>.", configurationElementCollectionTypeReference))); clearMethod.Comments.Add(DocComment("</summary>")); clearMethod.CustomAttributes.Add(_generatedCodeAttribute); clearMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final; clearMethod.ReturnType = _void; clearMethod.Name = "Clear"; clearMethod.Statements.Add( new CodeMethodInvokeExpression(_base, "BaseClear") ); //Add Contains method CodeMemberMethod containsMethod = new CodeMemberMethod(); elementClass.Members.Add(containsMethod); containsMethod.Comments.Add(DocComment("<summary>")); containsMethod.Comments.Add(DocComment(string.Format("Determines whether the <see cref=\"{0}\"/> contains a specific value.", configurationElementCollectionTypeReference))); containsMethod.Comments.Add(DocComment("</summary>")); containsMethod.Comments.Add(DocComment(string.Format("<param name=\"{0}\">The object to locate in the <see cref=\"{1}\"/>.</param>", collectionElement.XmlItemName, collectionItemTypeReference))); containsMethod.CustomAttributes.Add(_generatedCodeAttribute); containsMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final; containsMethod.ReturnType = _bool; containsMethod.Name = "Contains"; containsMethod.Parameters.Add(new CodeParameterDeclarationExpression(collectionItemType, collectionElement.XmlItemName)); containsMethod.Statements.Add( new CodeMethodReturnStatement( new CodeBinaryOperatorExpression( new CodeMethodInvokeExpression(_base, "BaseIndexOf", new CodeArgumentReferenceExpression(collectionElement.XmlItemName)), CodeBinaryOperatorType.GreaterThanOrEqual, new CodePrimitiveExpression(0) ) ) ); //Add CopyTo method CodeMemberMethod copytoMethod = new CodeMemberMethod(); elementClass.Members.Add(copytoMethod); copytoMethod.Comments.Add(DocComment("<summary>")); copytoMethod.Comments.Add(DocComment(string.Format("Copies the elements of the <see cref=\"{0}\"/> to an <see cref=\"System.Array\"/>, starting at a particular <see cref=\"System.Array\"/> index.", configurationElementCollectionTypeReference))); copytoMethod.Comments.Add(DocComment("</summary>")); copytoMethod.Comments.Add(DocComment(string.Format("<param name=\"array\">The one-dimensional <see cref=\"System.Array\"/> that is the destination of the elements copied from <see cref=\"{0}\"/>. The <see cref=\"System.Array\"/> must have zero-based indexing.</param>", configurationElementCollectionTypeReference))); copytoMethod.Comments.Add(DocComment("<param name=\"arrayIndex\">The zero-based index in <paramref name=\"array\"/> at which copying begins.</param>")); copytoMethod.CustomAttributes.Add(_generatedCodeAttribute); copytoMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final; copytoMethod.ReturnType = _void; copytoMethod.Name = "CopyTo"; copytoMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(collectionItemTypeReference, 1), "array")); copytoMethod.Parameters.Add(new CodeParameterDeclarationExpression(_int, "arrayIndex")); copytoMethod.Statements.Add( new CodeMethodInvokeExpression(_base, "CopyTo", new CodeArgumentReferenceExpression("array"), new CodeArgumentReferenceExpression("arrayIndex")) ); //Add ICollection.IsReadOnly property CodeMemberProperty isReadOnlyProperty = new CodeMemberProperty(); elementClass.Members.Add(isReadOnlyProperty); isReadOnlyProperty.Comments.Add(DocComment("<summary>")); isReadOnlyProperty.Comments.Add(DocComment(string.Format("Gets a value indicating whether the <see cref=\"{0}\"/> is read-only.", configurationElementCollectionTypeReference))); isReadOnlyProperty.Comments.Add(DocComment("</summary>")); isReadOnlyProperty.CustomAttributes.Add(_generatedCodeAttribute); isReadOnlyProperty.Attributes = MemberAttributes.Private; isReadOnlyProperty.PrivateImplementationType = icollectionTypeReference; isReadOnlyProperty.Type = _bool; isReadOnlyProperty.HasGet = true; isReadOnlyProperty.HasSet = false; isReadOnlyProperty.Name = "IsReadOnly"; isReadOnlyProperty.GetStatements.Add( new CodeMethodReturnStatement( new CodeMethodInvokeExpression(_this, "IsReadOnly") ) ); //Add ICollection.Remove method CodeMemberMethod icRemoveMethod = new CodeMemberMethod(); elementClass.Members.Add(icRemoveMethod); icRemoveMethod.Comments.Add(DocComment("<summary>")); icRemoveMethod.Comments.Add(DocComment(string.Format("Removes the first occurrence of a specific object from the <see cref=\"{0}\"/>.", configurationElementCollectionTypeReference))); icRemoveMethod.Comments.Add(DocComment("</summary>")); icRemoveMethod.Comments.Add(DocComment(string.Format("<param name=\"item\">The <see cref=\"{0}\"/> to remove.</param>", collectionItemTypeReference))); icRemoveMethod.CustomAttributes.Add(_generatedCodeAttribute); icRemoveMethod.Attributes = MemberAttributes.Private; icRemoveMethod.PrivateImplementationType = icollectionTypeReference; icRemoveMethod.ReturnType = _bool; icRemoveMethod.Name = "Remove"; icRemoveMethod.Parameters.Add(new CodeParameterDeclarationExpression(collectionItemType, "item")); icRemoveMethod.Statements.Add( new CodeVariableDeclarationStatement(_int, "idx", new CodeMethodInvokeExpression(_base, "BaseIndexOf", new CodeArgumentReferenceExpression("item")) ) ); icRemoveMethod.Statements.Add( new CodeConditionStatement( new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression("idx"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(-1) ), new CodeMethodReturnStatement(new CodePrimitiveExpression(false)) ) ); icRemoveMethod.Statements.Add( new CodeMethodInvokeExpression(_base, "BaseRemoveAt", new CodeVariableReferenceExpression("idx")) ); icRemoveMethod.Statements.Add( new CodeMethodReturnStatement(new CodePrimitiveExpression(true)) ); //Add IEnumerator<> method CodeTypeReference ienumTypeReference = new CodeTypeReference(typeof(System.Collections.Generic.IEnumerator <>), CodeTypeReferenceOptions.GlobalReference); ienumTypeReference.Options = CodeTypeReferenceOptions.GlobalReference | CodeTypeReferenceOptions.GenericTypeParameter; ienumTypeReference.TypeArguments.Add(collectionItemType); CodeTypeReference listTypeReference = new CodeTypeReference(typeof(System.Collections.Generic.List <>), CodeTypeReferenceOptions.GlobalReference); listTypeReference.Options = CodeTypeReferenceOptions.GlobalReference | CodeTypeReferenceOptions.GenericTypeParameter; listTypeReference.TypeArguments.Add(collectionItemType); CodeMemberMethod getEnumeratorMethod = new CodeMemberMethod(); elementClass.Members.Add(getEnumeratorMethod); getEnumeratorMethod.Comments.Add(DocComment("<summary>")); getEnumeratorMethod.Comments.Add(DocComment("Returns an enumerator that iterates through the collection.")); getEnumeratorMethod.Comments.Add(DocComment("</summary>")); getEnumeratorMethod.CustomAttributes.Add(_generatedCodeAttribute); getEnumeratorMethod.Attributes = MemberAttributes.New | MemberAttributes.Public | MemberAttributes.Final; getEnumeratorMethod.ReturnType = ienumTypeReference; getEnumeratorMethod.Name = "GetEnumerator"; getEnumeratorMethod.Statements.Add( new CodeVariableDeclarationStatement(listTypeReference, "list", new CodeObjectCreateExpression(listTypeReference, new CodePropertyReferenceExpression(_base, "Count")) ) ); CodeVariableReferenceExpression varList = new CodeVariableReferenceExpression("list"); getEnumeratorMethod.Statements.Add( new CodeVariableDeclarationStatement(GlobalReference(typeof(System.Collections.IEnumerator)), "iter", new CodeMethodInvokeExpression(_base, "GetEnumerator") ) ); CodeVariableReferenceExpression varIter = new CodeVariableReferenceExpression("iter"); CodeExpressionStatement emptyExpr = new CodeExpressionStatement(new CodeSnippetExpression()); getEnumeratorMethod.Statements.Add( new CodeIterationStatement( emptyExpr, new CodeMethodInvokeExpression(varIter, "MoveNext"), emptyExpr, new CodeExpressionStatement( new CodeMethodInvokeExpression( varList, "Add", new CodeCastExpression(collectionItemType, new CodePropertyReferenceExpression(varIter, "Current")) ) ) ) ); getEnumeratorMethod.Statements.Add( new CodeMethodReturnStatement(new CodeMethodInvokeExpression(varList, "GetEnumerator") ) ); getEnumeratorMethod.EndDirectives.Add(EndRegion()); } }
private void GenerateProperties(CodeTypeDeclaration taskClass, LinkedList <Property> propertyList) { foreach (Property property in propertyList) { if (!string.Equals(property.Name, "import", StringComparison.OrdinalIgnoreCase) && this.ContainsCurrentPlatform(property)) { CodeAttributeDeclarationCollection declarations = new CodeAttributeDeclarationCollection(); CodeMemberProperty propertyName = new CodeMemberProperty { Name = property.Name, HasGet = true, HasSet = true, Attributes = MemberAttributes.Public }; if (!string.IsNullOrEmpty(property.DefaultValue)) { this.taskParser.DefaultSet.AddLast(property); } if (!string.IsNullOrEmpty(property.Required) && (property.Required == "true")) { declarations.Add(new CodeAttributeDeclaration("Required")); } if (property.Output) { declarations.Add(new CodeAttributeDeclaration("Output")); } if (string.IsNullOrEmpty(property.Argument) && !string.IsNullOrEmpty(property.Fallback)) { this.taskParser.FallbackSet.Add(property.Name, property.Fallback); } if (property.Type == PropertyType.StringArray) { this.GenerateStringArrays(property, propertyName); } else if (property.Type == PropertyType.String) { this.GenerateStrings(property, propertyName); } else if (property.Type == PropertyType.Boolean) { this.GenerateBooleans(property, propertyName); } else if (property.Type == PropertyType.Integer) { this.GenerateIntegers(property, propertyName); } else if (property.Type == PropertyType.ItemArray) { this.GenerateITaskItemArray(property, propertyName); } else { this.LogError("ImproperType", new object[] { property.Name, property.Type }); } foreach (Property property3 in property.Dependencies) { if (!this.dependencyList.ContainsKey(property3.Name)) { this.dependencyList.Add(property3.Name, property3); property3.Parents.AddLast(property.Name); } else if (!this.dependencyList[property3.Name].Parents.Contains(property.Name)) { this.dependencyList[property3.Name].Parents.AddLast(property.Name); } } this.GenerateOverrides(property, propertyName); propertyName.CustomAttributes = declarations; taskClass.Members.Add(propertyName); } } }
public static CodeTypeDeclaration GetSQLiteEntityForTableDescription(DbSyncTableDescription tableDesc, bool addKeyAttributes, Dictionary <string, string> colsMapping) { CodeTypeDeclaration entityDeclaration = new CodeTypeDeclaration(SanitizeName(tableDesc.UnquotedGlobalName)); entityDeclaration.IsPartial = true; entityDeclaration.IsClass = true; foreach (DbSyncColumnDescription column in tableDesc.Columns) { string colName = column.UnquotedName; if (colsMapping != null) { colsMapping.TryGetValue(column.UnquotedName.ToLowerInvariant(), out colName); colName = colName ?? column.UnquotedName; } CodeTypeReference fieldTypeReference = GetTypeFromSqlType(tableDesc, column); CodeMemberField colField = new CodeMemberField(fieldTypeReference, "_" + SanitizeName(colName)); colField.Attributes = MemberAttributes.Private; CodeMemberProperty propertyField = new CodeMemberProperty(); propertyField.Attributes = MemberAttributes.Public | MemberAttributes.Final; propertyField.Name = SanitizeName(colName); propertyField.Type = fieldTypeReference; propertyField.GetStatements.Add(new CodeMethodReturnStatement(new CodeArgumentReferenceExpression(colField.Name))); propertyField.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(colField.Name), new CodeVariableReferenceExpression("value"))); if (addKeyAttributes) { if (column.IsPrimaryKey) { //Add the Key attribute propertyField.CustomAttributes.Add(new CodeAttributeDeclaration(Constants.SQLitePrimaryKeyAtributeType)); } if (column.SizeSpecified && column.Size != "0") { int maxSize; var isNotMaxSize = int.TryParse(column.Size, out maxSize); string maxLength = isNotMaxSize ? column.Size : "8000"; var cad = new CodeAttributeDeclaration(Constants.SQLiteMaxLengthAttribute); cad.Arguments.Add(new CodeAttributeArgument(new CodeSnippetExpression(maxLength))); //Add the MaxLength at CodeAttributeDeclaration(maxSizeAttributeString)tribute propertyField.CustomAttributes.Add(cad); } if (column.AutoIncrementSeedSpecified) { propertyField.CustomAttributes.Add(new CodeAttributeDeclaration(Constants.SQLiteAutoIncrementAttribute)); } } else { // This is service entity. Check to see if column mappings is present i.e colName is not the same as column.UnquotedName. if (!colName.Equals(column.UnquotedName, StringComparison.Ordinal)) { propertyField.CustomAttributes.Add(new CodeAttributeDeclaration(Constants.ServiceSyncColumnMappingAttribute, new CodeAttributeArgument("LocalName", new CodeSnippetExpression("\"" + column.UnquotedName + "\"")))); } // For a nullable data type, we add the [SyncEntityPropertyNullable] attribute to the property that is code-generated. // This is required because some data types such as string are nullable by default in .NET and so there is no good way to // later determine whether the type in the underlying data store is nullable or not. if (column.IsNullable) { propertyField.CustomAttributes.Add(new CodeAttributeDeclaration(Constants.EntityPropertyNullableAttributeType)); } } entityDeclaration.Members.Add(colField); entityDeclaration.Members.Add(propertyField); } return(entityDeclaration); }
protected override void GenerateProperty (CodeMemberProperty e, CodeTypeDeclaration c) { // Bail out if not a class, struct, or interface. if(!IsCurrentClass && !IsCurrentStruct && !IsCurrentInterface) { return; } // Output the attributes and property signature. OutputAttributeDeclarations(e.CustomAttributes); if(!IsCurrentInterface) { if(e.PrivateImplementationType == null) { OutputMemberAccessModifier(e.Attributes); OutputMemberScopeModifier(e.Attributes); } } else if((e.Attributes & MemberAttributes.VTableMask) == MemberAttributes.New) { Output.Write("new "); } OutputType(e.Type); Output.Write(" "); if(e.PrivateImplementationType != null && !IsCurrentInterface) { Output.Write(e.PrivateImplementationType.BaseType); Output.Write("."); } if(e.Parameters.Count == 0) { OutputIdentifier(e.Name); } else { Output.Write("this["); OutputParameters(e.Parameters); Output.Write("]"); } // Output the body of the property. StartBlock(); if(e.HasGet) { if(IsCurrentInterface || (e.Attributes & MemberAttributes.ScopeMask) == MemberAttributes.Abstract) { Output.WriteLine("get;"); } else { Output.Write("get"); StartBlock(); GenerateStatements(e.GetStatements); EndBlock(); } } if(e.HasSet) { if(IsCurrentInterface || (e.Attributes & MemberAttributes.ScopeMask) == MemberAttributes.Abstract) { Output.WriteLine("set;"); } else { Output.Write("set"); StartBlock(); GenerateStatements(e.SetStatements); EndBlock(); } } EndBlock(); }
/// <summary> /// Creates a class declaration /// </summary> /// <param name="schema">record schema</param> /// <param name="ns">namespace</param> /// <returns></returns> protected virtual CodeTypeDeclaration processRecord(Schema schema) { RecordSchema recordSchema = schema as RecordSchema; if (null == recordSchema) { throw new CodeGenException("Unable to cast schema into a record"); } bool isError = recordSchema.Tag == Schema.Type.Error; // declare the class var ctd = new CodeTypeDeclaration(CodeGenUtil.Instance.Mangle(recordSchema.Name)); ctd.BaseTypes.Add(isError ? "SpecificException" : "ISpecificRecord"); ctd.Attributes = MemberAttributes.Public; ctd.IsClass = true; ctd.IsPartial = true; if (recordSchema.Documentation != null) { ctd.Comments.Add(createDocComment(recordSchema.Documentation)); } createSchemaField(schema, ctd, isError); // declare Get() to be used by the Writer classes var cmmGet = new CodeMemberMethod(); cmmGet.Name = "Get"; cmmGet.Attributes = MemberAttributes.Public; cmmGet.ReturnType = new CodeTypeReference("System.Object"); cmmGet.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "fieldPos")); StringBuilder getFieldStmt = new StringBuilder("switch (fieldPos)\n\t\t\t{\n"); // declare Put() to be used by the Reader classes var cmmPut = new CodeMemberMethod(); cmmPut.Name = "Put"; cmmPut.Attributes = MemberAttributes.Public; cmmPut.ReturnType = new CodeTypeReference(typeof(void)); cmmPut.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "fieldPos")); cmmPut.Parameters.Add(new CodeParameterDeclarationExpression("System.Object", "fieldValue")); var putFieldStmt = new StringBuilder("switch (fieldPos)\n\t\t\t{\n"); if (isError) { cmmGet.Attributes |= MemberAttributes.Override; cmmPut.Attributes |= MemberAttributes.Override; } foreach (Field field in recordSchema.Fields) { // Determine type of field bool nullibleEnum = false; string baseType = getType(field.Schema, false, ref nullibleEnum); var ctrfield = new CodeTypeReference(baseType); // Create field string privFieldName = string.Concat("_", field.Name); var codeField = new CodeMemberField(ctrfield, privFieldName); codeField.Attributes = MemberAttributes.Private; // Process field documentation if it exist and add to the field CodeCommentStatement propertyComment = null; if (!string.IsNullOrEmpty(field.Documentation)) { propertyComment = createDocComment(field.Documentation); if (null != propertyComment) { codeField.Comments.Add(propertyComment); } } // Add field to class ctd.Members.Add(codeField); // Create reference to the field - this.fieldname var fieldRef = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), privFieldName); var mangledName = CodeGenUtil.Instance.Mangle(field.Name); // Create field property with get and set methods var property = new CodeMemberProperty(); property.Attributes = MemberAttributes.Public | MemberAttributes.Final; property.Name = mangledName; property.Type = ctrfield; property.GetStatements.Add(new CodeMethodReturnStatement(fieldRef)); property.SetStatements.Add(new CodeAssignStatement(fieldRef, new CodePropertySetValueReferenceExpression())); if (null != propertyComment) { property.Comments.Add(propertyComment); } // Add field property to class ctd.Members.Add(property); // add to Get() getFieldStmt.Append("\t\t\tcase "); getFieldStmt.Append(field.Pos); getFieldStmt.Append(": return this."); getFieldStmt.Append(mangledName); getFieldStmt.Append(";\n"); // add to Put() putFieldStmt.Append("\t\t\tcase "); putFieldStmt.Append(field.Pos); putFieldStmt.Append(": this."); putFieldStmt.Append(mangledName); if (nullibleEnum) { putFieldStmt.Append(" = fieldValue == null ? ("); putFieldStmt.Append(baseType); putFieldStmt.Append(")null : ("); string type = baseType.Remove(0, 16); // remove System.Nullable< type = type.Remove(type.Length - 1); // remove > putFieldStmt.Append(type); putFieldStmt.Append(")fieldValue; break;\n"); } else { putFieldStmt.Append(" = ("); putFieldStmt.Append(baseType); putFieldStmt.Append(")fieldValue; break;\n"); } } // end switch block for Get() getFieldStmt.Append("\t\t\tdefault: throw new AvroRuntimeException(\"Bad index \" + fieldPos + \" in Get()\");\n\t\t\t}"); var cseGet = new CodeSnippetExpression(getFieldStmt.ToString()); cmmGet.Statements.Add(cseGet); ctd.Members.Add(cmmGet); // end switch block for Put() putFieldStmt.Append("\t\t\tdefault: throw new AvroRuntimeException(\"Bad index \" + fieldPos + \" in Put()\");\n\t\t\t}"); var csePut = new CodeSnippetExpression(putFieldStmt.ToString()); cmmPut.Statements.Add(csePut); ctd.Members.Add(cmmPut); string nspace = recordSchema.Namespace; if (string.IsNullOrEmpty(nspace)) { throw new CodeGenException("Namespace required for record schema " + recordSchema.Name); } CodeNamespace codens = addNamespace(nspace); codens.Types.Add(ctd); return(ctd); }
public override void Visit(VisitableElementComplexType element) { ArrayList nodes = Retriever.RetrieveCustomization(element, NodeType.Collection); string name = element.Name + Configuration.CollectionNaming; if (nodes.Count != 0) { CodeTypeDeclaration type = null; foreach (CodeTypeDeclaration obj in CurrentNamespace.Types) { if (obj.Name == name) { type = obj; break; } } if (type == null) { type = new CodeTypeDeclaration(name); CurrentNamespace.Types.Add(type); // Mark the type as being a collection. type.UserData.Add("IsCollection", true); // Append unhandled attributes to the type UserData property, for use by custom visitors. XmlAttribute[] attributes = element.SchemaObject.UnhandledAttributes; if (attributes != null) { foreach (XmlAttribute attr in attributes) { type.UserData.Add(attr.LocalName, attr); } } } type.CustomAttributes.AddRange(CodeDomHelper.BuildCustomAttributes(nodes)); type.BaseTypes.AddRange(CodeDomHelper.BuildBaseTypes(nodes)); } // If the element is contained in another element, and generateContainerProperty configuration // is "true", add the corresponding property if it isn't already present. if (Configuration.InnerData.GenerateContainerProperty && element.Parent != null && element.Parent is VisitableElementComplexType) { CodeTypeDeclaration enclosing = null; foreach (CodeTypeDeclaration type in CurrentNamespace.Types) { if (type.Name == element.Parent.TypeName) { enclosing = type; break; } } // If we find the parent type and the property hasn't been defined already if (enclosing != null) { bool existing = false; foreach (CodeTypeMember prop in enclosing.Members) { if (prop.Name == element.Name) { existing = true; break; } } if (!existing) { CodeMemberProperty prop = new CodeMemberProperty(); prop.Name = element.Name; prop.Attributes = MemberAttributes.Public; // TODO: Review if it is necessary to add an attribute to specify getter and setter for the property. prop.HasGet = true; prop.HasSet = true; // Do we have a custom Collection? if (nodes.Count != 0) { prop.Type = new CodeTypeReference(element.Name + Configuration.CollectionNaming); } else { prop.Type = new CodeTypeReference(element.TypeName, 1); } enclosing.Members.Add(prop); } } } }
} //Main() public static void SpitList (TextWriter w, string typeName, ICodeGenerator baseCompiler, string ns) { CodeCommentStatement c = new CodeCommentStatement (string.Format ("List of {0}", typeName)); baseCompiler.GenerateCodeFromStatement (c, w, null); CodeNamespace cnamespace = new CodeNamespace("Microsoft.Samples"); cnamespace.Imports.Add (new CodeNamespaceImport ("System") ); cnamespace.Imports.Add (new CodeNamespaceImport ("System.Collections") ); if (ns != null && ns != "") cnamespace.Imports.Add (new CodeNamespaceImport (ns) ); CodeTypeDeclaration co = new CodeTypeDeclaration (typeName +"List"); co.IsClass = true; cnamespace.Types.Add (co); co.BaseTypes.Add (typeof (CollectionBase) ); co.TypeAttributes = TypeAttributes.Public; //Generates: public <TYPE> this[int index] { // get { // return ((<TYPE>)List[index]); // } // set { // List[index] = value; // } // } CodeMemberProperty cp = new CodeMemberProperty (); cp.Name = "Item"; cp.Attributes = MemberAttributes.Public | MemberAttributes.Final ; cp.Type = new CodeTypeReference(typeName); cp.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference(typeof(int)), "index")); cp.GetStatements.Add (new CodeMethodReturnStatement (new CodeCastExpression (typeName, new CodeIndexerExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(), "List"), new CodeArgumentReferenceExpression ("index"))))); cp.SetStatements.Add (new CodeAssignStatement (new CodeIndexerExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(),"List"), new CodeArgumentReferenceExpression ("index")), new CodeArgumentReferenceExpression ("value"))); co.Members.Add (cp); //Gen: public int Add(<TYPE> value) { // return List.Add(value); // } CodeMemberMethod cm = new CodeMemberMethod (); cm.Name = "Add"; cm.ReturnType = new CodeTypeReference(typeof(int)); cm.Parameters.Add (new CodeParameterDeclarationExpression (typeName, "value")); cm.Attributes = MemberAttributes.Public | MemberAttributes.Final ; cm.Statements.Add (new CodeMethodReturnStatement (new CodeMethodInvokeExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(),"List"), "Add", new CodeArgumentReferenceExpression ("value")))); co.Members.Add (cm); //Gen: public void Insert(int index, <TYPE> value) // { // List.Insert(index, info); // } cm = new CodeMemberMethod (); cm.Name = "Insert"; cm.ReturnType = new CodeTypeReference(typeof(void)); cm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference(typeof(int)), "index")); cm.Parameters.Add (new CodeParameterDeclarationExpression (typeName, "value")); cm.Attributes = MemberAttributes.Public | MemberAttributes.Final ; cm.Statements.Add (new CodeMethodInvokeExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(),"List"), "Insert", new CodeArgumentReferenceExpression ("index"), new CodeArgumentReferenceExpression ("value"))); co.Members.Add (cm); //Gen: public int IndexOf(<TYPE> value) // { // return List.IndexOf(value); // } cm = new CodeMemberMethod (); cm.Name = "IndexOf"; cm.ReturnType = new CodeTypeReference(typeof(int)); cm.Parameters.Add (new CodeParameterDeclarationExpression (typeName, "value")); cm.Attributes = MemberAttributes.Public | MemberAttributes.Final ; cm.Statements.Add (new CodeMethodReturnStatement (new CodeMethodInvokeExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(),"List"), "IndexOf", new CodeExpression [] {new CodeArgumentReferenceExpression ("value")}))); co.Members.Add (cm); //Gen: public bool Contains(<TYPE> value) // { // return List.Contains(value); // } cm = new CodeMemberMethod (); cm.Name = "Contains"; cm.ReturnType = new CodeTypeReference(typeof(bool)); cm.Parameters.Add (new CodeParameterDeclarationExpression (typeName, "value")); cm.Attributes = MemberAttributes.Public | MemberAttributes.Final ; cm.Statements.Add (new CodeMethodReturnStatement (new CodeMethodInvokeExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(),"List"), "Contains", new CodeExpression [] {new CodeArgumentReferenceExpression ("value")}))); co.Members.Add (cm); //Gen: public void Remove(<TYPE> value) // { // List.Remove(value); // } cm = new CodeMemberMethod (); cm.Name = "Remove"; cm.Parameters.Add (new CodeParameterDeclarationExpression (typeName, "value")); cm.Attributes = MemberAttributes.Public | MemberAttributes.Final ; cm.Statements.Add (new CodeMethodInvokeExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(),"List"), "Remove", new CodeExpression [] {new CodeArgumentReferenceExpression ("value")})); co.Members.Add (cm); //Gen: public void CopyTo(<Type>[] array, int index) // { // List.CopyTo(array, index); // } cm = new CodeMemberMethod (); cm.Name = "CopyTo"; cm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference(typeName, 1), "array")); cm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference(typeof(int)), "index")); cm.Attributes = MemberAttributes.Public | MemberAttributes.Final ; cm.Statements.Add (new CodeMethodInvokeExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(),"List"), "CopyTo", new CodeExpression [] {new CodeArgumentReferenceExpression ("array"), new CodeArgumentReferenceExpression ("index")})); co.Members.Add (cm); baseCompiler.GenerateCodeFromNamespace (cnamespace, w, null); } //SpitList()
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 CodeTypeDeclaration GenerateClass(Generator g, CodeTypeDeclaration libDecl, string libFieldName) { var decl = new CodeTypeDeclaration (Name); decl.IsPartial = true; if (BaseClasses.Count > 0) decl.BaseTypes.Add (new CodeTypeReference (BaseClasses [0].Name)); else decl.BaseTypes.Add (new CodeTypeReference ("ICppObject")); bool hasBase = BaseClasses.Count > 0; var layout = new CodeTypeDeclaration ("_" + Name); layout.IsStruct = true; layout.TypeAttributes = TypeAttributes.NotPublic; decl.Members.Add (layout); foreach (var f in Fields) { CodeMemberField field = new CodeMemberField { Name = f.Name, Type = g.CppTypeToCodeDomType (f.Type) }; layout.Members.Add (field); } var iface = new CodeTypeDeclaration ("I" + Name); iface.IsInterface = true; layout.TypeAttributes = TypeAttributes.NotPublic; iface.BaseTypes.Add (new CodeTypeReference ("ICppClassOverridable", new CodeTypeReference [] { new CodeTypeReference (decl.Name) })); decl.Members.Add (iface); var layoutField = new CodeMemberField (new CodeTypeReference (typeof (Type)), "native_layout"); layoutField.Attributes = MemberAttributes.Private|MemberAttributes.Static; layoutField.InitExpression = new CodeTypeOfExpression (layout.Name); decl.Members.Add (layoutField); var implField = new CodeMemberField (new CodeTypeReference (iface.Name), "impl"); implField.Attributes = MemberAttributes.Private|MemberAttributes.Static; var getclass = new CodeMethodReferenceExpression (new CodeFieldReferenceExpression (new CodeTypeReferenceExpression (libDecl.Name), libFieldName), "GetClass", new CodeTypeReference [] { new CodeTypeReference (iface.Name), new CodeTypeReference (layout.Name), new CodeTypeReference (decl.Name) }); implField.InitExpression = new CodeMethodInvokeExpression (getclass, new CodeExpression [] { new CodePrimitiveExpression (Name) }); decl.Members.Add (implField); //private static IClass impl = global::CppTests.Libs.Test.GetClass <IClass, _Class, Class>("Class"); if (!hasBase) { var ptrField = new CodeMemberField (new CodeTypeReference ("CppInstancePtr"), "native_ptr"); ptrField.Attributes = MemberAttributes.Family; decl.Members.Add (ptrField); } var allocCtor = new CodeConstructor () { }; allocCtor.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("CppLibrary"), "dummy")); allocCtor.Statements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression (null, "native_ptr"), new CodeMethodInvokeExpression (new CodeMethodReferenceExpression (new CodeFieldReferenceExpression (null, "impl"), "Alloc"), new CodeExpression [] { new CodeThisReferenceExpression () }))); if (hasBase) { var implTypeInfo = new CodeFieldReferenceExpression (new CodeFieldReferenceExpression { FieldName = "impl" }, "TypeInfo"); allocCtor.BaseConstructorArgs.Add (implTypeInfo); } decl.Members.Add (allocCtor); var subclassCtor = new CodeConstructor () { Attributes = MemberAttributes.Family }; subclassCtor.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("CppTypeInfo"), "subClass")); subclassCtor.Statements.Add (new CodeExpressionStatement (new CodeMethodInvokeExpression (new CodeMethodReferenceExpression (new CodeArgumentReferenceExpression ("subClass"), "AddBase"), new CodeExpression [] { new CodeFieldReferenceExpression (new CodeFieldReferenceExpression (null, "impl"), "TypeInfo") }))); if (hasBase) { var implTypeInfo = new CodeFieldReferenceExpression (new CodeFieldReferenceExpression { FieldName = "impl" }, "TypeInfo"); subclassCtor.BaseConstructorArgs.Add (implTypeInfo); } decl.Members.Add (subclassCtor); if (!hasBase) { var nativeProperty = new CodeMemberProperty () { Name = "Native", Type = new CodeTypeReference ("CppInstancePtr"), Attributes = MemberAttributes.Public|MemberAttributes.Final }; nativeProperty.GetStatements.Add (new CodeMethodReturnStatement (new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), "native_ptr"))); decl.Members.Add (nativeProperty); } var disposeMethod = new CodeMemberMethod () { Name = "Dispose", Attributes = MemberAttributes.Public }; if (Methods.Any (m => m.IsDestructor)) disposeMethod.Statements.Add (new CodeExpressionStatement (new CodeMethodInvokeExpression (new CodeMethodReferenceExpression (new CodeFieldReferenceExpression (null, "impl"), "Destruct"), new CodeExpression [] { new CodeFieldReferenceExpression (null, "Native") }))); disposeMethod.Statements.Add (new CodeExpressionStatement (new CodeMethodInvokeExpression (new CodeMethodReferenceExpression (new CodeFieldReferenceExpression (null, "Native"), "Dispose")))); decl.Members.Add (disposeMethod); foreach (Method m in Methods) { iface.Members.Add (m.GenerateIFaceMethod (g)); if (m.GenWrapperMethod) { var cm = m.GenerateWrapperMethod (g); if (m.IsConstructor && hasBase) { var implTypeInfo = new CodeFieldReferenceExpression (new CodeFieldReferenceExpression { FieldName = "impl" }, "TypeInfo"); (cm as CodeConstructor).BaseConstructorArgs.Add (implTypeInfo); } decl.Members.Add (cm); } } foreach (Property p in Properties) { decl.Members.Add (p.GenerateProperty (g)); } return decl; }
/// <inheritdoc/> protected override void HandleProperty(CodeMemberProperty obj, Context ctx, bool isExt, CodeMemberPropertyExt objExt, bool doDefaultImplementation) { if (obj.PrivateImplementationType == null) { ctx.HandlerProvider.MemberAttributesHandler.Handle(obj.Attributes, ctx); } ctx.HandlerProvider.TypeReferenceHandler.Handle(obj.Type, ctx); ctx.Writer.Write(" "); if (obj.PrivateImplementationType == null) { ctx.Writer.Write(obj.Name.AsCsId()); } else { HandlePrivateImplementationTypeMemberName(obj.Name, obj.PrivateImplementationType, ctx); } ctx.Writer.NewLine(); ctx.Writer.IndentAndWriteLine("{", ctx); ctx.Indent(); if (obj.HasGet) { ctx.Writer.Indent(ctx); if (isExt && objExt.GetAccessibilityLevel != obj.Attributes.GetAccessibilityLevel() && obj.PrivateImplementationType == null) { ctx.Writer.Write($"{CSharpKeywordsUtils.AccessibilityLevelKeyword(objExt.GetAccessibilityLevel)} "); } ctx.Writer.Write("get"); if (doDefaultImplementation) { ctx.Writer.WriteLine(";"); } else { CSharpUtils.HandleStatementCollection(obj.GetStatements, ctx); } } if (obj.HasSet) { ctx.Writer.Indent(ctx); if (isExt && objExt.SetAccessibilityLevel != obj.Attributes.GetAccessibilityLevel() && obj.PrivateImplementationType == null) { ctx.Writer.Write($"{CSharpKeywordsUtils.AccessibilityLevelKeyword(objExt.SetAccessibilityLevel)} "); } ctx.Writer.Write("set"); if (doDefaultImplementation) { ctx.Writer.WriteLine(";"); } else { CSharpUtils.HandleStatementCollection(obj.SetStatements, ctx); } } ctx.Unindent(); ctx.Writer.IndentAndWrite("}", ctx); if (isExt && objExt.PropertyInitializer != null) { ctx.Writer.Write(" = "); ctx.HandlerProvider.ExpressionHandler.Handle(objExt.PropertyInitializer, ctx); ctx.Writer.Write(";"); } ctx.Writer.NewLine(); }
string FindProxyTypeAndAugmentCodeDom(CodeNamespace codeNamespace) { // add new type containing Type properties for each type // in the web service proxy assembly (kind of a namespace) string nsName = string.Format("ws_namespace_{0:x}", Guid.NewGuid().GetHashCode()); CodeTypeDeclaration nsType = new CodeTypeDeclaration(nsName); CodeTypeDeclaration wsType = null; // the web service type (only one) foreach (CodeTypeDeclaration t in codeNamespace.Types) { string name = t.Name; // find the one derived from SoapHttpClientProtocol foreach (CodeTypeReference baseType in t.BaseTypes) { if (baseType.BaseType == typeof(SoapHttpClientProtocol).FullName) { if (wsType != null) { throw new InvalidDataException("Found more than one web service proxy type."); } wsType = t; } } // add the corresponding property to the namespace type CodeMemberProperty p = new CodeMemberProperty(); p.Attributes &= ~MemberAttributes.AccessMask; p.Attributes |= MemberAttributes.Public; p.Name = name; // same as type name p.Type = new CodeTypeReference(typeof(DynamicType)); p.GetStatements.Add(new CodeMethodReturnStatement( new CodeMethodInvokeExpression( new CodeMethodReferenceExpression( new CodeTypeReferenceExpression(typeof(Ops)), "GetDynamicTypeFromType"), new CodeTypeOfExpression(name)))); nsType.Members.Add(p); } if (wsType == null) { // must have exactly one ws proxy throw new InvalidDataException("Web service proxy type not found."); } codeNamespace.Types.Add(nsType); // add ServiceNamespace property of the above type to the proxy type CodeMemberField nsField = new CodeMemberField(nsName, "_serviceNamespace"); nsField.Attributes &= ~MemberAttributes.AccessMask; nsField.Attributes |= MemberAttributes.Private; nsField.InitExpression = new CodeObjectCreateExpression(nsName); wsType.Members.Add(nsField); CodeMemberProperty nsProp = new CodeMemberProperty(); nsProp.Attributes &= ~MemberAttributes.AccessMask; nsProp.Attributes |= MemberAttributes.Public; nsProp.Name = "ServiceNamespace"; nsProp.Type = new CodeTypeReference(nsName); nsProp.GetStatements.Add(new CodeMethodReturnStatement( new CodePropertyReferenceExpression( new CodeThisReferenceExpression(), "_serviceNamespace"))); wsType.Members.Add(nsProp); // return the proxy type name return wsType.Name; }
protected override void GenerateProperty( CodeMemberProperty property, CodeTypeDeclaration declaration) { TextWriter output = Output; if (property.CustomAttributes.Count > 0) { OutputAttributeDeclarations(property.CustomAttributes); } MemberAttributes attributes = property.Attributes; OutputMemberAccessModifier(attributes); OutputMemberScopeModifier(attributes); if (property.Name == "Item") { // indexer output.Write(GetSafeName(property.Name)); output.Write("("); OutputParameters(property.Parameters); output.Write(")"); output.Write(" as "); OutputType(property.Type); } else { OutputTypeNamePair(property.Type, GetSafeName(property.Name)); } output.WriteLine(" :"); ++Indent; if (declaration.IsInterface) { if (property.HasGet) { output.WriteLine("get: "); } if (property.HasSet) { output.WriteLine("set: "); } } else { if (property.HasGet) { output.WriteLine("get :"); ++Indent; GenerateStatements(property.GetStatements); if ((property.GetStatements.Count) == 0) { output.WriteLine("pass"); } --Indent; } if (property.HasSet) { output.WriteLine("set :"); ++Indent; GenerateStatements(property.SetStatements); if (property.SetStatements.Count == 0) { output.WriteLine("pass"); } --Indent; } } --Indent; }
public void Properties() { CodeNamespace ns = new CodeNamespace("NS"); ns.Imports.Add(new CodeNamespaceImport("System")); // create a class CodeTypeDeclaration class1 = new CodeTypeDeclaration(); class1.Name = "Test"; class1.IsClass = true; class1.BaseTypes.Add(new CodeTypeReference(typeof(Exception))); ns.Types.Add(class1); CodeMemberField int1 = new CodeMemberField(typeof(int), "int1"); class1.Members.Add(int1); CodeMemberField tempString = new CodeMemberField(typeof(string), "tempString"); class1.Members.Add(tempString); // basic property with get/set CodeMemberProperty prop1 = new CodeMemberProperty(); prop1.Name = "prop1"; prop1.Type = new CodeTypeReference(typeof(int)); prop1.Attributes = MemberAttributes.Public; prop1.HasGet = true; prop1.HasSet = true; prop1.GetStatements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("int1"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1)))); prop1.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("int1"), new CodeVariableReferenceExpression("value"))); class1.Members.Add(prop1); // override Property CodeMemberProperty overrideProp = new CodeMemberProperty(); overrideProp.Name = "Text"; overrideProp.Type = new CodeTypeReference(typeof(string)); overrideProp.Attributes = MemberAttributes.Public | MemberAttributes.Override; overrideProp.HasGet = true; overrideProp.HasSet = true; overrideProp.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("tempString"), new CodeVariableReferenceExpression("value"))); overrideProp.GetStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression("Hello World"))); class1.Members.Add(overrideProp); foreach (MemberAttributes attrs in new[] { MemberAttributes.Private, MemberAttributes.Family, MemberAttributes.Assembly }) { CodeMemberProperty configuredProp = new CodeMemberProperty(); configuredProp.Name = attrs.ToString() + "Prop"; configuredProp.Type = new CodeTypeReference(typeof(int)); configuredProp.Attributes = attrs; configuredProp.HasGet = true; configuredProp.HasSet = true; configuredProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("int1"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1)))); configuredProp.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("int1"), new CodeVariableReferenceExpression("value"))); class1.Members.Add(configuredProp); } // Static property CodeMemberProperty staticProp = new CodeMemberProperty(); staticProp.Name = "staticProp"; staticProp.Type = new CodeTypeReference(typeof(int)); staticProp.Attributes = MemberAttributes.Public | MemberAttributes.Static; staticProp.HasGet = true; staticProp.GetStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(99))); class1.Members.Add(staticProp); // this reference CodeMemberMethod thisRef = new CodeMemberMethod(); thisRef.Name = "thisRef"; thisRef.ReturnType = new CodeTypeReference(typeof(int)); thisRef.Attributes = MemberAttributes.Public; CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "value"); thisRef.Parameters.Add(param); thisRef.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "privProp1"), new CodeVariableReferenceExpression("value"))); thisRef.Statements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "privProp1"))); class1.Members.Add(thisRef); // set value CodeMemberMethod setProp = new CodeMemberMethod(); setProp.Name = "setProp"; setProp.ReturnType = new CodeTypeReference(typeof(int)); setProp.Attributes = MemberAttributes.Public; CodeParameterDeclarationExpression intParam = new CodeParameterDeclarationExpression(typeof(int), "value"); setProp.Parameters.Add(intParam); setProp.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "prop1"), new CodeVariableReferenceExpression("value"))); setProp.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("int1"))); class1.Members.Add(setProp); AssertEqual(ns, @"Imports System Namespace NS Public Class Test Inherits System.Exception Private int1 As Integer Private tempString As String Public Overridable Property prop1() As Integer Get Return (int1 + 1) End Get Set int1 = value End Set End Property Public Overrides Property Text() As String Get Return ""Hello World"" End Get Set tempString = value End Set End Property Private Property PrivateProp() As Integer Get Return (int1 + 1) End Get Set int1 = value End Set End Property Protected Overridable Property FamilyProp() As Integer Get Return (int1 + 1) End Get Set int1 = value End Set End Property Friend Overridable Property AssemblyProp() As Integer Get Return (int1 + 1) End Get Set int1 = value End Set End Property Public Shared ReadOnly Property staticProp() As Integer Get Return 99 End Get End Property Public Overridable Function thisRef(ByVal value As Integer) As Integer Me.privProp1 = value Return Me.privProp1 End Function Public Overridable Function setProp(ByVal value As Integer) As Integer Me.prop1 = value Return int1 End Function End Class End Namespace"); }
public override void BuildTree(CodeDomProvider provider, CodeCompileUnit cu) { CodeNamespace nspace = new CodeNamespace("NSPC"); nspace.Imports.Add(new CodeNamespaceImport("System")); cu.Namespaces.Add(nspace); CodeTypeDeclaration cd = new CodeTypeDeclaration("TestingStructs"); cd.IsClass = true; nspace.Types.Add(cd); if (Supports(provider, GeneratorSupport.DeclareValueTypes)) { // GENERATES (C#): // public int CallingStructMethod(int i) { // StructImplementation o = new StructImplementation (); // return o.StructMethod(i); // } AddScenario("CheckCallingStructMethod"); CodeMemberMethod cmm = new CodeMemberMethod(); cmm.Name = "CallingStructMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i")); cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("StructImplementation"), "o", new CodeObjectCreateExpression(new CodeTypeReference("StructImplementation")))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression( new CodeVariableReferenceExpression("o"), "StructMethod"), new CodeArgumentReferenceExpression("i")))); cd.Members.Add(cmm); // GENERATES (C#): // public int UsingValueStruct(int i) { // ValueStruct StructObject = new ValueStruct(); // StructObject.x = i; // return StructObject.x; // } AddScenario("CheckUsingValueStruct"); cmm = new CodeMemberMethod(); cmm.Name = "UsingValueStruct"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i")); cmm.Statements.Add(new CodeVariableDeclarationStatement("ValueStruct", "StructObject", new CodeObjectCreateExpression("ValueStruct"))); cmm.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("StructObject"), "x"), new CodeArgumentReferenceExpression("i"))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("StructObject"), "x"))); cd.Members.Add(cmm); // GENERATES (C#): // public int UsingStructProperty(int i) { // StructImplementation StructObject = new StructImplementation(); // StructObject.UseIField = i; // return StructObject.UseIField; // } AddScenario("CheckUsingStructProperty"); cmm = new CodeMemberMethod(); cmm.Name = "UsingStructProperty"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i")); cmm.Statements.Add(new CodeVariableDeclarationStatement("StructImplementation", "StructObject", new CodeObjectCreateExpression("StructImplementation"))); cmm.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression( new CodeVariableReferenceExpression("StructObject"), "UseIField"), new CodeArgumentReferenceExpression("i"))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("StructObject"), "UseIField"))); cd.Members.Add(cmm); // GENERATES (C#): // public int UsingInterfaceStruct(int i) { // ImplementInterfaceStruct IStructObject = new ImplementInterfaceStruct(); // return IStructObject.InterfaceMethod(i); // } if (Supports(provider, GeneratorSupport.DeclareInterfaces)) { AddScenario("CheckUsingInterfaceStruct"); // method to test struct implementing interfaces cmm = new CodeMemberMethod(); cmm.Name = "UsingInterfaceStruct"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i")); cmm.Statements.Add(new CodeVariableDeclarationStatement("ImplementInterfaceStruct", "IStructObject", new CodeObjectCreateExpression("ImplementInterfaceStruct"))); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression( new CodeVariableReferenceExpression("IStructObject"), "InterfaceMethod", new CodeArgumentReferenceExpression("i")))); cd.Members.Add(cmm); } // GENERATES (C#): // public struct StructImplementation { // int i; // public int UseIField { // get { // return i; // } // set { // i = value; // } // } // public int StructMethod(int i) { // return (5 + i); // } // } cd = new CodeTypeDeclaration("StructImplementation"); cd.IsStruct = true; nspace.Types.Add(cd); // declare an integer field CodeMemberField field = new CodeMemberField(new CodeTypeReference(typeof(int)), "i"); field.Attributes = MemberAttributes.Public; cd.Members.Add(field); CodeMemberProperty prop = new CodeMemberProperty(); prop.Name = "UseIField"; prop.Type = new CodeTypeReference(typeof(int)); prop.Attributes = MemberAttributes.Public | MemberAttributes.Final; CodeFieldReferenceExpression fref = new CodeFieldReferenceExpression(); fref.FieldName = "i"; prop.GetStatements.Add(new CodeMethodReturnStatement(fref)); prop.SetStatements.Add(new CodeAssignStatement(fref, new CodePropertySetValueReferenceExpression())); cd.Members.Add(prop); cmm = new CodeMemberMethod(); cmm.Name = "StructMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i")); cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression( new CodePrimitiveExpression(5), CodeBinaryOperatorType.Add, new CodeArgumentReferenceExpression("i")))); cd.Members.Add(cmm); // GENERATES (C#): // public struct ValueStruct { // public int x; // } cd = new CodeTypeDeclaration("ValueStruct"); cd.IsStruct = true; nspace.Types.Add(cd); // declare an integer field field = new CodeMemberField(new CodeTypeReference(typeof(int)), "x"); field.Attributes = MemberAttributes.Public; cd.Members.Add(field); if (Supports(provider, GeneratorSupport.DeclareInterfaces)) { // interface to be implemented // GENERATES (C#): // public interface InterfaceStruct { // int InterfaceMethod(int i); // } cd = new CodeTypeDeclaration("InterfaceStruct"); cd.IsInterface = true; nspace.Types.Add(cd); // method in the interface cmm = new CodeMemberMethod(); cmm.Name = "InterfaceMethod"; cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i")); cd.Members.Add(cmm); // struct to implement an interface // GENERATES (C#): // public struct ImplementInterfaceStruct : InterfaceStruct { // public int InterfaceMethod(int i) { // return (8 + i); // } // } cd = new CodeTypeDeclaration("ImplementInterfaceStruct"); cd.BaseTypes.Add(new CodeTypeReference("InterfaceStruct")); cd.IsStruct = true; nspace.Types.Add(cd); field = new CodeMemberField(new CodeTypeReference(typeof(int)), "i"); field.Attributes = MemberAttributes.Public; cd.Members.Add(field); // implement interface method cmm = new CodeMemberMethod(); cmm.Name = "InterfaceMethod"; cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceStruct")); cmm.ReturnType = new CodeTypeReference(typeof(int)); cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final; cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(new CodePrimitiveExpression(8), CodeBinaryOperatorType.Add, new CodeArgumentReferenceExpression("i")))); cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i")); cd.Members.Add(cmm); } } }
public void GlobalKeyword() { CodeNamespace ns = new CodeNamespace("Foo"); ns.Comments.Add(new CodeCommentStatement("Foo namespace")); CodeTypeDeclaration cd = new CodeTypeDeclaration("Foo"); ns.Types.Add(cd); string fieldName1 = "_verifyGlobalGeneration1"; CodeMemberField field = new CodeMemberField(); field.Name = fieldName1; field.Type = new CodeTypeReference(typeof(int), CodeTypeReferenceOptions.GlobalReference); field.Attributes = MemberAttributes.Public; field.InitExpression = new CodePrimitiveExpression(int.MaxValue); cd.Members.Add(field); string fieldName2 = "_verifyGlobalGeneration2"; CodeMemberField field2 = new CodeMemberField(); field2.Name = fieldName2; CodeTypeReference typeRef = new CodeTypeReference("System.Nullable", CodeTypeReferenceOptions.GlobalReference); typeRef.TypeArguments.Add(new CodeTypeReference(typeof(int), CodeTypeReferenceOptions.GlobalReference)); field2.Type = typeRef; field2.InitExpression = new CodePrimitiveExpression(0); cd.Members.Add(field2); CodeMemberMethod method1 = new CodeMemberMethod(); method1.Name = "TestMethod01"; method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public | MemberAttributes.Static; method1.ReturnType = new CodeTypeReference(typeof(int)); method1.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(int.MaxValue))); cd.Members.Add(method1); CodeMemberMethod method2 = new CodeMemberMethod(); method2.Name = "TestMethod02"; method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; method2.ReturnType = new CodeTypeReference(typeof(int)); method2.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "iReturn")); CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression( new CodeMethodReferenceExpression( new CodeTypeReferenceExpression(new CodeTypeReference("Foo.Foo", CodeTypeReferenceOptions.GlobalReference)), "TestMethod01")); CodeAssignStatement cas = new CodeAssignStatement(new CodeVariableReferenceExpression("iReturn"), cmie); method2.Statements.Add(cas); method2.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("iReturn"))); cd.Members.Add(method2); CodeMemberMethod method3 = new CodeMemberMethod(); method3.Name = "TestMethod03"; method3.Attributes = (method3.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; method3.ReturnType = new CodeTypeReference(typeof(int)); method3.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "iReturn")); CodeTypeReferenceOptions ctro = CodeTypeReferenceOptions.GlobalReference; CodeTypeReference ctr = new CodeTypeReference(typeof(Math), ctro); cmie = new CodeMethodInvokeExpression( new CodeMethodReferenceExpression( new CodeTypeReferenceExpression(ctr), "Abs"), new CodeExpression[] { new CodePrimitiveExpression(-1) }); cas = new CodeAssignStatement(new CodeVariableReferenceExpression("iReturn"), cmie); method3.Statements.Add(cas); method3.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("iReturn"))); cd.Members.Add(method3); CodeMemberProperty property = new CodeMemberProperty(); property.Name = "GlobalTestProperty1"; property.Type = new CodeTypeReference(typeof(int)); property.Attributes = (property.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; property.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(fieldName1))); property.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(fieldName1), new CodeVariableReferenceExpression("value"))); cd.Members.Add(property); CodeMemberProperty property2 = new CodeMemberProperty(); property2.Name = "GlobalTestProperty2"; property2.Type = typeRef; property2.Attributes = (property.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public; property2.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(fieldName2))); property2.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(fieldName2), new CodeVariableReferenceExpression("value"))); cd.Members.Add(property2); AssertEqual(ns, @"'Foo namespace Namespace Foo Public Class Foo Public _verifyGlobalGeneration1 As Integer = 2147483647 Private _verifyGlobalGeneration2 As Global.System.Nullable(Of Integer) = 0 Public Property GlobalTestProperty1() As Integer Get Return _verifyGlobalGeneration1 End Get Set _verifyGlobalGeneration1 = value End Set End Property Public Property GlobalTestProperty2() As Global.System.Nullable(Of Integer) Get Return _verifyGlobalGeneration2 End Get Set _verifyGlobalGeneration2 = value End Set End Property Public Shared Function TestMethod01() As Integer Return 2147483647 End Function Public Function TestMethod02() As Integer Dim iReturn As Integer iReturn = Global.Foo.Foo.TestMethod01 Return iReturn End Function Public Function TestMethod03() As Integer Dim iReturn As Integer iReturn = Global.System.Math.Abs(-1) Return iReturn End Function End Class End Namespace"); }
protected abstract void GenerateProperty(CodeMemberProperty p, CodeTypeDeclaration d);
public void MetadataAttributes() { var cu = new CodeCompileUnit(); var ns = new CodeNamespace(); ns.Name = "MyNamespace"; ns.Imports.Add(new CodeNamespaceImport("System")); ns.Imports.Add(new CodeNamespaceImport("System.Drawing")); ns.Imports.Add(new CodeNamespaceImport("System.Windows.Forms")); ns.Imports.Add(new CodeNamespaceImport("System.ComponentModel")); cu.Namespaces.Add(ns); var attrs = cu.AssemblyCustomAttributes; attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyTitle", new CodeAttributeArgument(new CodePrimitiveExpression("MyAssembly")))); attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyVersion", new CodeAttributeArgument(new CodePrimitiveExpression("1.0.6.2")))); attrs.Add(new CodeAttributeDeclaration("System.CLSCompliantAttribute", new CodeAttributeArgument(new CodePrimitiveExpression(false)))); var class1 = new CodeTypeDeclaration() { Name = "MyClass" }; class1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Serializable")); class1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Obsolete", new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Class")))); ns.Types.Add(class1); var nestedClass = new CodeTypeDeclaration("NestedClass") { IsClass = true, TypeAttributes = TypeAttributes.NestedPublic }; nestedClass.CustomAttributes.Add(new CodeAttributeDeclaration("System.Serializable")); class1.Members.Add(nestedClass); var method1 = new CodeMemberMethod() { Name = "MyMethod" }; method1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Obsolete", new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Method")))); method1.CustomAttributes.Add(new CodeAttributeDeclaration("System.ComponentModel.Editor", new CodeAttributeArgument(new CodePrimitiveExpression("This")), new CodeAttributeArgument(new CodePrimitiveExpression("That")))); var param1 = new CodeParameterDeclarationExpression(typeof(string), "blah"); param1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlElementAttribute", new CodeAttributeArgument("Form", new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.Xml.Schema.XmlSchemaForm"), "Unqualified")), new CodeAttributeArgument("IsNullable", new CodePrimitiveExpression(false)))); method1.Parameters.Add(param1); var param2 = new CodeParameterDeclarationExpression(typeof(int[]), "arrayit"); param2.CustomAttributes.Add( new CodeAttributeDeclaration("System.Xml.Serialization.XmlElementAttribute", new CodeAttributeArgument("Form", new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.Xml.Schema.XmlSchemaForm"), "Unqualified")), new CodeAttributeArgument("IsNullable", new CodePrimitiveExpression(false)))); method1.Parameters.Add(param2); class1.Members.Add(method1); var function1 = new CodeMemberMethod(); function1.Name = "MyFunction"; function1.ReturnType = new CodeTypeReference(typeof(string)); function1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Obsolete", new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Function")))); function1.ReturnTypeCustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlIgnoreAttribute")); function1.ReturnTypeCustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlRootAttribute", new CodeAttributeArgument("Namespace", new CodePrimitiveExpression("Namespace Value")), new CodeAttributeArgument("ElementName", new CodePrimitiveExpression("Root, hehehe")))); function1.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression("Return"))); class1.Members.Add(function1); CodeMemberMethod function2 = new CodeMemberMethod(); function2.Name = "GlobalKeywordFunction"; function2.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(ObsoleteAttribute), CodeTypeReferenceOptions.GlobalReference), new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Function")))); CodeTypeReference typeRef = new CodeTypeReference("System.Xml.Serialization.XmlIgnoreAttribute", CodeTypeReferenceOptions.GlobalReference); CodeAttributeDeclaration codeAttrib = new CodeAttributeDeclaration(typeRef); function2.ReturnTypeCustomAttributes.Add(codeAttrib); class1.Members.Add(function2); CodeMemberField field1 = new CodeMemberField(); field1.Name = "myField"; field1.Type = new CodeTypeReference(typeof(string)); field1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlElementAttribute")); field1.InitExpression = new CodePrimitiveExpression("hi!"); class1.Members.Add(field1); CodeMemberProperty prop1 = new CodeMemberProperty(); prop1.Name = "MyProperty"; prop1.Type = new CodeTypeReference(typeof(string)); prop1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Obsolete", new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Property")))); prop1.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "myField"))); class1.Members.Add(prop1); CodeConstructor const1 = new CodeConstructor(); const1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Obsolete", new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Constructor")))); class1.Members.Add(const1); class1 = new CodeTypeDeclaration("Test"); class1.IsClass = true; class1.BaseTypes.Add(new CodeTypeReference("Form")); ns.Types.Add(class1); CodeMemberField mfield = new CodeMemberField(new CodeTypeReference("Button"), "b"); mfield.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference("Button")); class1.Members.Add(mfield); CodeConstructor ctor = new CodeConstructor(); ctor.Attributes = MemberAttributes.Public; ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Size"), new CodeObjectCreateExpression(new CodeTypeReference("Size"), new CodePrimitiveExpression(600), new CodePrimitiveExpression(600)))); ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"), "Text"), new CodePrimitiveExpression("Test"))); ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"), "TabIndex"), new CodePrimitiveExpression(0))); ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"), "Location"), new CodeObjectCreateExpression(new CodeTypeReference("Point"), new CodePrimitiveExpression(400), new CodePrimitiveExpression(525)))); ctor.Statements.Add(new CodeAttachEventStatement(new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "MyEvent"), new CodeDelegateCreateExpression(new CodeTypeReference("EventHandler") , new CodeThisReferenceExpression(), "b_Click"))); class1.Members.Add(ctor); CodeMemberEvent evt = new CodeMemberEvent(); evt.Name = "MyEvent"; evt.Type = new CodeTypeReference("System.EventHandler"); evt.Attributes = MemberAttributes.Public; evt.CustomAttributes.Add(new CodeAttributeDeclaration("System.CLSCompliantAttribute", new CodeAttributeArgument(new CodePrimitiveExpression(false)))); class1.Members.Add(evt); CodeMemberMethod cmm = new CodeMemberMethod(); cmm.Name = "b_Click"; cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender")); cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(EventArgs), "e")); class1.Members.Add(cmm); AssertEqual(cu, @"'------------------------------------------------------------------------------ ' <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 Imports System Imports System.ComponentModel Imports System.Drawing Imports System.Windows.Forms <Assembly: System.Reflection.AssemblyTitle(""MyAssembly""), _ Assembly: System.Reflection.AssemblyVersion(""1.0.6.2""), _ Assembly: System.CLSCompliantAttribute(false)> Namespace MyNamespace <System.Serializable(), _ System.Obsolete(""Don't use this Class"")> _ Public Class [MyClass] <System.Xml.Serialization.XmlElementAttribute()> _ Private myField As String = ""hi!"" <System.Obsolete(""Don't use this Constructor"")> _ Private Sub New() MyBase.New End Sub <System.Obsolete(""Don't use this Property"")> _ Private ReadOnly Property MyProperty() As String Get Return Me.myField End Get End Property <System.Obsolete(""Don't use this Method""), _ System.ComponentModel.Editor(""This"", ""That"")> _ Private Sub MyMethod(<System.Xml.Serialization.XmlElementAttribute(Form:=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable:=false)> ByVal blah As String, <System.Xml.Serialization.XmlElementAttribute(Form:=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable:=false)> ByVal arrayit() As Integer) End Sub <System.Obsolete(""Don't use this Function"")> _ Private Function MyFunction() As <System.Xml.Serialization.XmlIgnoreAttribute(), System.Xml.Serialization.XmlRootAttribute([Namespace]:=""Namespace Value"", ElementName:=""Root, hehehe"")> String Return ""Return"" End Function <Global.System.ObsoleteAttribute(""Don't use this Function"")> _ Private Sub GlobalKeywordFunction() End Sub <System.Serializable()> _ Public Class NestedClass End Class End Class Public Class Test Inherits Form Private b As Button = New Button() Public Sub New() MyBase.New Me.Size = New Size(600, 600) b.Text = ""Test"" b.TabIndex = 0 b.Location = New Point(400, 525) AddHandler MyEvent, AddressOf Me.b_Click End Sub <System.CLSCompliantAttribute(false)> _ Public Event MyEvent As System.EventHandler Private Sub b_Click(ByVal sender As Object, ByVal e As System.EventArgs) End Sub End Class End Namespace"); }
private CodeMemberProperty CreateEntitySetProperty(EntitySet set) { Debug.Assert(set != null, "Property is Null"); // trying to get // // [System.ComponentModel.Browsable(false)] // public ObjectQuery<Customer> Customers // { // get // { // if ((this._Customers == null)) // { // this._Customers = base.CreateQuery<Customer>("[Customers]"); // } // return this._Customers; // } // } // CodeMemberProperty codeProperty = new CodeMemberProperty(); Generator.AttributeEmitter.EmitGeneratedCodeAttribute(codeProperty); codeProperty.Attributes = MemberAttributes.Final | GetEntitySetPropertyAccessibility(set); codeProperty.Name = set.Name; codeProperty.HasGet = true; codeProperty.HasSet = false; // Determine type to use for field/property and name of factory method on ObjectContext string typeName = "ObjectQuery"; string createMethodName = "CreateQuery"; // When the EntitySet name is used as CommandText, it should be quoted string createMethodArgument = "[" + set.Name + "]"; CodeTypeReference genericParameter = Generator.GetLeastPossibleQualifiedTypeReference(set.ElementType); codeProperty.Type = TypeReference.AdoFrameworkGenericClass(typeName, genericParameter); string fieldName = Utils.FieldNameFromPropName(set.Name); // raise the PropertyGenerated event before proceeding further PropertyGeneratedEventArgs eventArgs = new PropertyGeneratedEventArgs(set, fieldName, codeProperty.Type); Generator.RaisePropertyGeneratedEvent(eventArgs); if (eventArgs.ReturnType == null || !eventArgs.ReturnType.Equals(codeProperty.Type)) { throw EDesignUtil.InvalidOperation(Strings.CannotChangePropertyReturnType(set.Name, Item.Name)); } List <CodeAttributeDeclaration> additionalAttributes = eventArgs.AdditionalAttributes; if (additionalAttributes != null && additionalAttributes.Count > 0) { try { codeProperty.CustomAttributes.AddRange(additionalAttributes.ToArray()); } catch (ArgumentNullException e) { Generator.AddError(Strings.InvalidAttributeSuppliedForProperty(Item.Name), ModelBuilderErrorCode.InvalidAttributeSuppliedForProperty, EdmSchemaErrorSeverity.Error, e); } } // we need to insert user-specified code before other/existing code, including // the return statement List <CodeStatement> additionalGetStatements = eventArgs.AdditionalGetStatements; if (additionalGetStatements != null && additionalGetStatements.Count > 0) { try { codeProperty.GetStatements.AddRange(additionalGetStatements.ToArray()); } catch (ArgumentNullException e) { Generator.AddError(Strings.InvalidGetStatementSuppliedForProperty(Item.Name), ModelBuilderErrorCode.InvalidGetStatementSuppliedForProperty, EdmSchemaErrorSeverity.Error, e); } } codeProperty.GetStatements.Add( new CodeConditionStatement( EmitExpressionEqualsNull(new CodeFieldReferenceExpression(ThisRef, fieldName)), new CodeAssignStatement( new CodeFieldReferenceExpression(ThisRef, fieldName), new CodeMethodInvokeExpression( new CodeMethodReferenceExpression( new CodeBaseReferenceExpression(), createMethodName, new CodeTypeReference[] { genericParameter } ), new CodePrimitiveExpression(createMethodArgument) ) ) ) ); codeProperty.GetStatements.Add( new CodeMethodReturnStatement( new CodeFieldReferenceExpression( ThisRef, fieldName ) ) ); // property summary CommentEmitter.EmitSummaryComments(set, codeProperty.Comments); return(codeProperty); }
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 }
/// <summary> /// Creates the CodeTypeDeclarations necessary to generate the code for the EntityContainer schema element /// </summary> /// <returns></returns> public override CodeTypeDeclarationCollection EmitApiClass() { Validate(); // emitter-specific validation // declare the new class // public partial class LOBScenario : ObjectContext CodeTypeDeclaration typeDecl = new CodeTypeDeclaration(Item.Name); typeDecl.IsPartial = true; // raise the TypeGenerated event CodeTypeReference objectContextTypeRef = TypeReference.ObjectContext; TypeGeneratedEventArgs eventArgs = new TypeGeneratedEventArgs(Item, objectContextTypeRef); Generator.RaiseTypeGeneratedEvent(eventArgs); if (eventArgs.BaseType != null && !eventArgs.BaseType.Equals(objectContextTypeRef)) { typeDecl.BaseTypes.Add(eventArgs.BaseType); } else { typeDecl.BaseTypes.Add(TypeReference.ObjectContext); } AddInterfaces(Item.Name, typeDecl, eventArgs.AdditionalInterfaces); CommentEmitter.EmitSummaryComments(Item, typeDecl.Comments); EmitTypeAttributes(Item.Name, typeDecl, eventArgs.AdditionalAttributes); CreateConstructors(typeDecl); // adding partial OnContextCreated method CreateContextPartialMethods(typeDecl); foreach (EntitySetBase entitySetBase in Item.BaseEntitySets) { if (MetadataUtil.IsEntitySet(entitySetBase)) { EntitySet set = (EntitySet)entitySetBase; CodeMemberProperty codeProperty = CreateEntitySetProperty(set); typeDecl.Members.Add(codeProperty); CodeMemberField codeField = CreateEntitySetField(set); typeDecl.Members.Add(codeField); } } foreach (EntitySetBase entitySetBase in Item.BaseEntitySets) { if (MetadataUtil.IsEntitySet(entitySetBase)) { EntitySet set = (EntitySet)entitySetBase; CodeMemberMethod codeProperty = CreateEntitySetAddObjectProperty(set); typeDecl.Members.Add(codeProperty); } } foreach (EdmFunction functionImport in Item.FunctionImports) { if (ShouldEmitFunctionImport(functionImport)) { CodeMemberMethod functionMethod = CreateFunctionImportStructuralTypeReaderMethod(functionImport); typeDecl.Members.Add(functionMethod); } } // additional members, if provided by the event subscriber AddMembers(Item.Name, typeDecl, eventArgs.AdditionalMembers); CodeTypeDeclarationCollection typeDecls = new CodeTypeDeclarationCollection(); typeDecls.Add(typeDecl); return(typeDecls); }