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);
}
