private static void AddMethodImpl(CodeMemberMethod method)
{
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(GetChannelReference(), method.Name, new CodeExpression[0]);
foreach (CodeParameterDeclarationExpression expression2 in method.Parameters)
{
expression.Parameters.Add(new CodeDirectionExpression(expression2.Direction, new CodeVariableReferenceExpression(expression2.Name)));
}
if (IsVoid(method))
{
method.Statements.Add(expression);
}
else
{
method.Statements.Add(new CodeMethodReturnStatement(expression));
}
}
public override CodeExpression GetCodeExpression(BoundPropertyEntry entry,
object parsedData, ExpressionBuilderContext context)
{
// entry.Expression - строка с числом
// без префикса (например: "1,6").
if (!entry.Expression.Contains(","))
{
throw new ArgumentException(" Должны быть указаны два числа, разделенные запятой");
}
else
{
// Получить два числа
string[] numbers = entry.Expression.Split(',');
if (numbers.Length != 2)
{
throw new ArgumentException("Должны быть указаны два числа");
}
else
{
int min, max;
if (Int32.TryParse(numbers[0], out min) &&
Int32.TryParse(numbers[1], out max))
{
// Получить ссылку на класс, имеющий метод GetRandomNumber().
// (Это класс, где данный код выполняется.)
CodeTypeReferenceExpression typeRef = new CodeTypeReferenceExpression(this.GetType());
// Определить параметры для GetRandomNumber().
CodeExpression[] methodParameters = new CodeExpression[2];
methodParameters[0] = new CodePrimitiveExpression(min);
methodParameters[1] = new CodePrimitiveExpression(max);
// Вернуть выражение привязки вызвав метод GetRandomNumber()
CodeMethodInvokeExpression methodCall = new CodeMethodInvokeExpression(
typeRef, "GetRandomNumber", methodParameters);
return methodCall;
}
else
{
throw new ArgumentException("Должны использоваться допустимые целые числа");
}
}
}
}
private static CodeMemberMethod CreateEndOperationMethod(ServiceContractGenerationContext context, CodeTypeDeclaration clientType, string syncMethodName, CodeMemberMethod endMethod)
{
CodeMemberMethod method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Private;
method.ReturnType = new CodeTypeReference(objectArrayType);
method.Name = NamingHelper.GetUniqueName(GetEndOperationMethodName(syncMethodName), new NamingHelper.DoesNameExist(ClientClassGenerator.DoesMethodNameExist), context.Operations);
int asyncResultParamIndex = GetAsyncResultParamIndex(endMethod);
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), endMethod.Name, new CodeExpression[0]);
CodeArrayCreateExpression expression2 = new CodeArrayCreateExpression();
expression2.CreateType = new CodeTypeReference(objectArrayType);
for (int i = 0; i < endMethod.Parameters.Count; i++)
{
if (i == asyncResultParamIndex)
{
method.Parameters.Add(new CodeParameterDeclarationExpression(endMethod.Parameters[i].Type, endMethod.Parameters[i].Name));
expression.Parameters.Add(new CodeVariableReferenceExpression(endMethod.Parameters[i].Name));
}
else
{
CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(endMethod.Parameters[i].Type, endMethod.Parameters[i].Name);
CodeMethodReferenceExpression expression3 = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), getDefaultValueForInitializationMethodName, new CodeTypeReference[] { endMethod.Parameters[i].Type });
statement.InitExpression = new CodeMethodInvokeExpression(expression3, new CodeExpression[0]);
method.Statements.Add(statement);
expression.Parameters.Add(new CodeDirectionExpression(endMethod.Parameters[i].Direction, new CodeVariableReferenceExpression(statement.Name)));
expression2.Initializers.Add(new CodeVariableReferenceExpression(statement.Name));
}
}
if (endMethod.ReturnType.BaseType != voidTypeRef.BaseType)
{
CodeVariableDeclarationStatement statement2 = new CodeVariableDeclarationStatement();
statement2.Type = endMethod.ReturnType;
statement2.Name = NamingHelper.GetUniqueName("retVal", new NamingHelper.DoesNameExist(ClientClassGenerator.DoesParameterNameExist), endMethod);
statement2.InitExpression = expression;
expression2.Initializers.Add(new CodeVariableReferenceExpression(statement2.Name));
method.Statements.Add(statement2);
}
else
{
method.Statements.Add(expression);
}
if (expression2.Initializers.Count > 0)
{
method.Statements.Add(new CodeMethodReturnStatement(expression2));
}
else
{
method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
}
clientType.Members.Add(method);
return method;
}
public void Visit(FileTable table)
{
var descriptor = new TableDescriptor(typeof(FileTable <>));
var fileTable = new CodeTypeDeclaration(table.Variable)
{
TypeAttributes = TypeAttributes.NestedPrivate
};
fileTable.BaseTypes.Add(new CodeTypeReference("IRowWriter"));
fileTable.BaseTypes.Add(new CodeTypeReference("IRowReader"));
//field
var fileTableCodeDomType = new CodeTypeReference("FileTable", new CodeTypeReference(table.Variable));
Scope.Current.Type.Type.Members.Add(
new CodeMemberField(fileTableCodeDomType, table.Variable)
{
Attributes = MemberAttributes.Public | MemberAttributes.Final
});
var locationArg = VisitChild(table.Location);
//constructor
Scope.Current.Type.Constructor.Statements.Add(new CodeAssignStatement(
new CodeSnippetExpression(table.Variable),
new CodeObjectCreateExpression(
new CodeTypeReference("FileTable", new CodeTypeReference(table.Variable)))));
BuildIRowWriterImplementation(fileTable, table.Args);
BuildIRowReaderImplementation(fileTable, table.Args);
foreach (var arg in table.Args)
{
var domArg = VisitChild(arg);
fileTable.Members.AddRange(domArg.ParentMemberDefinitions);
descriptor.Variables.Add(new VariableTypePair {
Variable = arg.Variable, Primitive = TablePrimitive.FromString(arg.Type)
});
}
_mainType.Type.Members.Add(fileTable);
if (Scope.Current.IsCurrentScopeRegistered(table.Variable))
{
Errors.Add(new VariableAlreadyExists(new Semantic.LineInfo(table.Line.Line, table.Line.CharacterPosition), table.Variable));
}
Scope.Current.RegisterTable(table.Variable, descriptor, fileTableCodeDomType);
//Init Code
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "Init_" + fileTable.Name;
method.Attributes = MemberAttributes.Private;
_mainType.Type.Members.Add(method);
var assignment = new CodeAssignStatement(new CodeVariableReferenceExpression("_" + Scope.Current.ScopeIdentifier + "." + table.Variable + ".Location"), locationArg.CodeExpression);
method.Statements.Add(assignment);
assignment = new CodeAssignStatement(new CodeVariableReferenceExpression("_" + Scope.Current.ScopeIdentifier + "." + table.Variable + ".FieldTerminator"), new CodePrimitiveExpression(table.FieldTerminator));
method.Statements.Add(assignment);
assignment = new CodeAssignStatement(new CodeVariableReferenceExpression("_" + Scope.Current.ScopeIdentifier + "." + table.Variable + ".RowTerminator"), new CodePrimitiveExpression(table.RowTerminator));
method.Statements.Add(assignment);
method.Statements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("_" + Scope.Current.ScopeIdentifier + "." + table.Variable), "Load"));
var methodcall = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(null, method.Name));
_codeStack.Peek().ParentStatements.Add(methodcall);
_codeStack.Peek().CodeExpression = methodcall;
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
CodeNamespace nspace = new CodeNamespace ("NSPC");
cu.Namespaces.Add (nspace);
CodeTypeDeclaration class1 = new CodeTypeDeclaration ("ClassWithField");
class1.IsClass = true;
nspace.Types.Add (class1);
// internal modifier
// public class ClassWithField {
// /*FamANDAssem*/ internal static int InternalField = 0;
// }
CodeMemberField field = new CodeMemberField ();
field.Name = "InternalField";
field.Attributes = MemberAttributes.Assembly | MemberAttributes.Static;
field.Type = new CodeTypeReference (typeof (int));
field.InitExpression = new CodePrimitiveExpression (0);
class1.Members.Add (field);
class1 = new CodeTypeDeclaration ("ClassToTest");
class1.IsClass = true;
nspace.Types.Add (class1);
// test internal field
// public static int UseInternalField(int i) {
// ClassWithField.InternalField = i;
// return ClassWithField.InternalField;
// }
AddScenario ("CheckUseInternalField");
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "UseInternalField";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i"));
cmm.Statements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression (new
CodeTypeReferenceExpression ("ClassWithField"), "InternalField"),
new CodeArgumentReferenceExpression ("i")));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeFieldReferenceExpression (new
CodeTypeReferenceExpression ("ClassWithField"), "InternalField")));
class1.Members.Add (cmm);
// nested array reference
// public int MoreArrayTests(int i) {
// int[][] arrayOfArrays = new int[][] {
// new int[] {
// 3,
// 4},
// new int[1],
// new int[0]};
// return (arrayOfArrays[0][1] + i);
// }
// VB code provider doesn't support array of array initialization
if (Supports (provider, GeneratorSupport.ArraysOfArrays) && !(provider is VBCodeProvider)) {
AddScenario ("CheckMoreArrayTests");
CodeMemberMethod secondMethod = new CodeMemberMethod ();
secondMethod.Name = "MoreArrayTests";
secondMethod.Attributes = (secondMethod.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
secondMethod.ReturnType = new CodeTypeReference (typeof (int));
secondMethod.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
// array of arrays
secondMethod.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 CodePrimitiveExpression (1)), new CodeArrayCreateExpression (typeof (int[])))));
secondMethod.Statements.Add (new CodeMethodReturnStatement (
new CodeBinaryOperatorExpression (new CodeArrayIndexerExpression (
new CodeArrayIndexerExpression (new CodeVariableReferenceExpression ("arrayOfArrays"), new CodePrimitiveExpression (0))
, new CodePrimitiveExpression (1)),
CodeBinaryOperatorType.Add, new CodeArgumentReferenceExpression ("i"))));
class1.Members.Add (secondMethod);
}
// value and reference
if (Supports (provider, GeneratorSupport.ReferenceParameters)) {
// GENERATE (C#):
// static void Work(ref int i, out int j) {
// i = (i + 4);
// j = 5;
// }
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)));
class1.Members.Add (cmm);
// add a method that calls method work to verify that ref and out are working properly
// GENERATE (C#):
// public static int CallingWork(int a) {
// a = 10;
// int b;
// TEST.Work(ref a, out b);
// return (a + b);
// }
AddScenario ("CheckCallingWork");
cmm = new CodeMemberMethod ();
cmm.Name = "CallingWork";
cmm.Attributes = MemberAttributes.Public;
CodeParameterDeclarationExpression parames = new CodeParameterDeclarationExpression (typeof (int), "a");
cmm.Parameters.Add (parames);
cmm.ReturnType = new CodeTypeReference ("System.Int32");
cmm.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("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 ("ClassToTest"), "Work"));
// add parameter with ref direction
CodeDirectionExpression parameter = new CodeDirectionExpression (FieldDirection.Ref,
new CodeArgumentReferenceExpression ("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 CodeArgumentReferenceExpression ("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression ("b"))));
class1.Members.Add (cmm);
}
}
private static void ProcessEqualityOperators(CodeMemberMethod cmm)
{
if (cmm.Name == "operator==" || cmm.Name == "operator!=")
{
CodeMethodInvokeExpression methodInvokeExpression =
new CodeMethodInvokeExpression(null, "ReferenceEquals",
new CodeArgumentReferenceExpression(cmm.Parameters[0].Name),
new CodeArgumentReferenceExpression(cmm.Parameters[1].Name));
CodeConditionStatement conditionStatement =
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeMethodInvokeExpression(null, "ReferenceEquals",
new CodeArgumentReferenceExpression(cmm.Parameters[0].Name),
new CodePrimitiveExpression(null)),
CodeBinaryOperatorType.BooleanOr,
new CodeMethodInvokeExpression(null, "ReferenceEquals",
new CodeArgumentReferenceExpression(cmm.Parameters[1].Name),
new CodePrimitiveExpression(null))),
new CodeMethodReturnStatement(
cmm.Name == "operator=="
? (CodeExpression) methodInvokeExpression
: new CodeBinaryOperatorExpression(
methodInvokeExpression, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false))));
cmm.Statements.Add(conditionStatement);
}
}
public void CallingMethods()
{
var ns = new CodeNamespace("MyNamespace");
var cd = new CodeTypeDeclaration("TEST") { IsClass = true };
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = "CallingOverrideScenario";
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("ClassWVirtualMethod", "t", new CodeObjectCreateExpression("ClassWOverrideMethod")));
CodeMethodInvokeExpression methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t"), "VirtualMethod");
methodinvoke.Parameters.Add(new CodeVariableReferenceExpression("i"));
cmm.Statements.Add(new CodeMethodReturnStatement(methodinvoke));
cd.Members.Add(cmm);
// declare a method without parameters
cmm = new CodeMemberMethod();
cmm.Name = "NoParamsMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(16)));
cd.Members.Add(cmm);
// declare a method with multiple parameters
cmm = new CodeMemberMethod();
cmm.Name = "MultipleParamsMethod";
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "b"));
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(new
CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add,
new CodeVariableReferenceExpression("b"))));
cd.Members.Add(cmm);
// call method with no parameters, call a method with multiple parameters,
// and call a method from a method call
cmm = new CodeMemberMethod();
cmm.Name = "CallParamsMethods";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("TEST"), "t", new CodeObjectCreateExpression("TEST")));
CodeVariableReferenceExpression cvre = new CodeVariableReferenceExpression(); //To increase code coverage
cvre.VariableName = "t";
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(cvre,
"MultipleParamsMethod", new CodePrimitiveExpression(78),
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t"), "NoParamsMethod"))));
cd.Members.Add(cmm);
// method to test the 'new' scenario by calling the 'new' method
cmm = new CodeMemberMethod();
cmm.Name = "CallingNewScenario";
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("ClassWVirtualMethod", "t", new CodeObjectCreateExpression("ClassWNewMethod")));
methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t"), "VirtualMethod");
methodinvoke.Parameters.Add(new CodeVariableReferenceExpression("i"));
CodeMethodInvokeExpression methodinvoke2 = new CodeMethodInvokeExpression(new CodeCastExpression("ClassWNewMethod", new
CodeVariableReferenceExpression("t")), "VirtualMethod");
methodinvoke2.Parameters.Add(new CodeVariableReferenceExpression("i"));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
methodinvoke2, CodeBinaryOperatorType.Subtract, methodinvoke)));
cd.Members.Add(cmm);
// first declare a class with a virtual method in it
cd = new CodeTypeDeclaration("ClassWVirtualMethod");
cd.IsClass = true;
ns.Types.Add(cd);
cmm = new CodeMemberMethod();
cmm.Name = "VirtualMethod";
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")));
cd.Members.Add(cmm);
// now declare a class that inherits from the previous class and has a 'new' method with the
cd = new CodeTypeDeclaration("ClassWNewMethod");
cd.BaseTypes.Add(new CodeTypeReference("ClassWVirtualMethod"));
cd.IsClass = true;
ns.Types.Add(cd);
cmm = new CodeMemberMethod();
cmm.Name = "VirtualMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.New;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(2), CodeBinaryOperatorType.Multiply, new CodeVariableReferenceExpression("a"))));
cd.Members.Add(cmm);
// now declare a class that inherits from the previous class and has a 'new' method with the
cd = new CodeTypeDeclaration("ClassWOverrideMethod");
cd.BaseTypes.Add(new CodeTypeReference("ClassWVirtualMethod"));
cd.IsClass = true;
ns.Types.Add(cd);
cmm = new CodeMemberMethod();
cmm.Name = "VirtualMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(2), CodeBinaryOperatorType.Multiply, new CodeVariableReferenceExpression("a"))));
cd.Members.Add(cmm);
// new class which will include both functions
cd = new CodeTypeDeclaration("TEST7");
cd.IsClass = true;
ns.Types.Add(cd);
cmm = new CodeMemberMethod();
cmm.Name = "OverloadedMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "OverloadedMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "b"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("b"), CodeBinaryOperatorType.Add,
new CodeVariableReferenceExpression("a"))));
cd.Members.Add(cmm);
// declare a method that will call both OverloadedMethod functions
cmm = new CodeMemberMethod();
cmm.Name = "CallingOverloadedMethods";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeMethodReferenceExpression methodref = new CodeMethodReferenceExpression();
methodref.MethodName = "OverloadedMethod";
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
new CodeMethodInvokeExpression(methodref, new
CodeVariableReferenceExpression("i"), new CodeVariableReferenceExpression("i"))
, CodeBinaryOperatorType.Subtract, new CodeMethodInvokeExpression(methodref, new
CodeVariableReferenceExpression("i")))));
cd.Members.Add(cmm);
AssertEqual(ns,
@"Namespace MyNamespace
Public Class ClassWVirtualMethod
Public Overridable Function VirtualMethod(ByVal a As Integer) As Integer
Return a
End Function
End Class
Public Class ClassWNewMethod
Inherits ClassWVirtualMethod
Public Shadows Overridable Function VirtualMethod(ByVal a As Integer) As Integer
Return (2 * a)
End Function
End Class
Public Class ClassWOverrideMethod
Inherits ClassWVirtualMethod
Public Overrides Function VirtualMethod(ByVal a As Integer) As Integer
Return (2 * a)
End Function
End Class
Public Class TEST7
Public Overloads Shared Function OverloadedMethod(ByVal a As Integer) As Integer
Return a
End Function
Public Overloads Shared Function OverloadedMethod(ByVal a As Integer, ByVal b As Integer) As Integer
Return (b + a)
End Function
Public Shared Function CallingOverloadedMethods(ByVal i As Integer) As Integer
Return (OverloadedMethod(i, i) - OverloadedMethod(i))
End Function
End Class
End Namespace");
}
private void GenerateMethods(CodeTypeDeclaration targetClass, Type baseType, IEnumerable <MethodInfo> methods)
{
if (methods.Any() == true)
{
var finalizeMethod = methods.First().DeclaringType.GetMethod("Finalize", BindingFlags.NonPublic | BindingFlags.Instance);
foreach (var method in methods)
{
if (method == finalizeMethod)
{
continue;
}
if (method.IsSpecialName == true)
{
continue;
}
var m = new CodeMemberMethod();
m.Name = method.Name;
m.ReturnType = new CodeTypeReference(method.ReturnType);
if (baseType != interfaceProxyType)
{
m.Attributes = MemberAttributes.Override;
}
targetClass.Members.Add(m);
foreach (var parameter in method.GetParameters())
{
m.Parameters.Add(new CodeParameterDeclarationExpression(parameter.ParameterType, parameter.Name));
}
if ((method.Attributes & MethodAttributes.Public) == MethodAttributes.Public)
{
m.Attributes |= MemberAttributes.Public;
}
else if ((method.Attributes & MethodAttributes.FamORAssem) == MethodAttributes.FamORAssem)
{
m.Attributes |= MemberAttributes.FamilyOrAssembly;
}
else if ((method.Attributes & MethodAttributes.Family) == MethodAttributes.Family)
{
m.Attributes |= MemberAttributes.Family;
}
else if ((method.Attributes & MethodAttributes.FamANDAssem) == MethodAttributes.FamANDAssem)
{
m.Attributes |= MemberAttributes.FamilyAndAssembly;
}
if (baseType == interfaceProxyType)
{
m.Attributes = MemberAttributes.Public | MemberAttributes.Final;
}
var currentMethod = new CodeVariableDeclarationStatement(typeof(MethodInfo), "currentMethod", new CodeCastExpression(typeof(MethodInfo), new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(MethodBase)), "GetCurrentMethod"))));
var getType = new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance"), "GetType");
var getMethod = new CodeMethodInvokeExpression(getType, "GetMethod", new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("currentMethod"), "Name"));
var originalMethod = new CodeVariableDeclarationStatement(typeof(MethodInfo), "originalMethod", getMethod);
m.Statements.Add(currentMethod);
m.Statements.Add(originalMethod);
var ps = new CodeExpression[] { new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance"), new CodeVariableReferenceExpression("originalMethod") }.Concat(method.GetParameters().Select(x => new CodeVariableReferenceExpression(x.Name))).ToArray();
var arg = new CodeVariableDeclarationStatement(typeof(InterceptionArgs), "args", new CodeObjectCreateExpression(typeof(InterceptionArgs), ps));
m.Statements.Add(arg);
var handler = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "handler"), "Invoke"), new CodeVariableReferenceExpression("args"));
m.Statements.Add(handler);
var comparison = new CodeBinaryOperatorExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("args"), "Handled"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(method.ReturnType != typeof(void)));
CodeConditionStatement @if = null;
if (method.ReturnType != typeof(void))
{
if (baseType != interfaceProxyType)
{
@if = new CodeConditionStatement(comparison, new CodeMethodReturnStatement(new CodeCastExpression(method.ReturnType, new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("args"), "Result"))));
m.Statements.Add(@if);
m.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), method.Name, method.GetParameters().Select(x => new CodeArgumentReferenceExpression(x.Name)).ToArray())));
}
else
{
@if = new CodeConditionStatement(comparison, new CodeMethodReturnStatement(new CodeCastExpression(method.ReturnType, new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("args"), "Result"))));
m.Statements.Add(@if);
m.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeCastExpression(method.DeclaringType, new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance")), m.Name), method.GetParameters().Select(x => new CodeArgumentReferenceExpression(x.Name)).ToArray())));
}
}
else
{
if (baseType != interfaceProxyType)
{
@if = new CodeConditionStatement(comparison, new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), method.Name, method.GetParameters().Select(x => new CodeArgumentReferenceExpression(x.Name)).ToArray())));
m.Statements.Add(@if);
}
else
{
@if = new CodeConditionStatement(comparison, new CodeMethodReturnStatement(new CodeCastExpression(method.ReturnType, new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("args"), "Result"))));
m.Statements.Add(@if);
m.Statements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeCastExpression(method.DeclaringType, new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance")), m.Name), method.GetParameters().Select(x => new CodeArgumentReferenceExpression(x.Name)).ToArray())));
}
}
}
}
}
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) {
}
}
}");
}
void AddStatementsFromDirective(ControlBuilder builder, CodeMemberMethod method, ILocation location)
{
#if NET_2_0
AssignPropertyWithExpression <string> (method, "ResponseEncoding", pageParser.ResponseEncoding, location);
AssignPropertyWithExpression <int> (method, "CodePage", pageParser.CodePage, location);
AssignPropertyWithExpression <int> (method, "LCID", pageParser.LCID, location);
#else
AssignPropertyWithExpression(method, "ResponseEncoding", pageParser.ResponseEncoding, location);
AssignPropertyWithExpression(method, "CodePage", pageParser.CodePage, location);
AssignPropertyWithExpression(method, "LCID", pageParser.LCID, location);
#endif
string contentType = pageParser.ContentType;
if (contentType != null)
{
method.Statements.Add(AddLinePragma(CreatePropertyAssign("ContentType", contentType), location));
}
#if !NET_2_0
if (pageParser.OutputCache)
{
CodeMethodReferenceExpression init = new CodeMethodReferenceExpression(null,
"InitOutputCache");
CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression(init,
OutputCacheParams());
method.Statements.Add(AddLinePragma(invoke, builder));
}
#endif
string culture = pageParser.Culture;
if (culture != null)
{
method.Statements.Add(AddLinePragma(CreatePropertyAssign("Culture", culture), location));
}
culture = pageParser.UICulture;
if (culture != null)
{
method.Statements.Add(AddLinePragma(CreatePropertyAssign("UICulture", culture), location));
}
string errorPage = pageParser.ErrorPage;
if (errorPage != null)
{
method.Statements.Add(AddLinePragma(CreatePropertyAssign("ErrorPage", errorPage), location));
}
if (pageParser.HaveTrace)
{
CodeAssignStatement stmt = new CodeAssignStatement();
stmt.Left = new CodePropertyReferenceExpression(thisRef, "TraceEnabled");
stmt.Right = new CodePrimitiveExpression(pageParser.Trace);
method.Statements.Add(AddLinePragma(stmt, location));
}
if (pageParser.TraceMode != TraceMode.Default)
{
CodeAssignStatement stmt = new CodeAssignStatement();
CodeTypeReferenceExpression tm = new CodeTypeReferenceExpression("System.Web.TraceMode");
stmt.Left = new CodePropertyReferenceExpression(thisRef, "TraceModeValue");
stmt.Right = new CodeFieldReferenceExpression(tm, pageParser.TraceMode.ToString());
method.Statements.Add(AddLinePragma(stmt, location));
}
if (pageParser.NotBuffer)
{
CodeAssignStatement stmt = new CodeAssignStatement();
stmt.Left = new CodePropertyReferenceExpression(thisRef, "Buffer");
stmt.Right = new CodePrimitiveExpression(false);
method.Statements.Add(AddLinePragma(stmt, location));
}
#if NET_2_0
if (!pageParser.EnableEventValidation)
{
CodeAssignStatement stmt = new CodeAssignStatement();
CodePropertyReferenceExpression prop;
prop = new CodePropertyReferenceExpression(thisRef, "EnableEventValidation");
stmt.Left = prop;
stmt.Right = new CodePrimitiveExpression(pageParser.EnableEventValidation);
method.Statements.Add(AddLinePragma(stmt, location));
}
if (pageParser.MaintainScrollPositionOnPostBack)
{
CodeAssignStatement stmt = new CodeAssignStatement();
CodePropertyReferenceExpression prop;
prop = new CodePropertyReferenceExpression(thisRef, "MaintainScrollPositionOnPostBack");
stmt.Left = prop;
stmt.Right = new CodePrimitiveExpression(pageParser.MaintainScrollPositionOnPostBack);
method.Statements.Add(AddLinePragma(stmt, location));
}
#endif
}
public void Visit(CodeMethodInvokeExpression o)
{
g.GenerateMethodInvokeExpression(o);
}
private void ValidateMethodInvokeExpression(CodeMethodInvokeExpression e)
{
ValidateMethodReferenceExpression(e.Method);
ValidateExpressionList(e.Parameters);
}
public CodeExpression CreateBindingSignature(CreateBindingSignatureParams createBindingSignatureParams)
{
var elementName = createBindingSignatureParams.ElementView.Element.Name;
var propertyName = string.Format(createBindingSignatureParams.SubscribablePropertyNameFormat, createBindingSignatureParams.SourceItem.Name);
var name = createBindingSignatureParams.SourceItem.Name;
var methodInvoke = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), MethodInfo.Name);
var isExtensionMethod = MethodInfo.IsDefined(typeof(ExtensionAttribute), true);
for (int index = 0; index < MethodInfo.GetParameters().Length; index++)
{
var parameter = MethodInfo.GetParameters()[index];
if (isExtensionMethod && index == 0)
{
continue;
}
var genericArguments = parameter.ParameterType.GetGenericArguments();
if (typeof(Delegate).IsAssignableFrom(parameter.ParameterType))
{
var method = CreateDelegateMethod(createBindingSignatureParams.ConvertGenericParameter, parameter, genericArguments, propertyName, name);
methodInvoke.Parameters.Add(new CodeSnippetExpression(String.Format((string)"this.{0}", (object)method.Name)));
createBindingSignatureParams.Context.Members.Add(method);
if (HandlerImplementation != null)
{
HandlerImplementation(new BindingHandlerArgs()
{
View = createBindingSignatureParams.ElementView,
SourceItem = createBindingSignatureParams.SourceItem,
Method = method,
Decleration = createBindingSignatureParams.Context,
IsDesignerFile = !createBindingSignatureParams.DontImplement
});
}
if (createBindingSignatureParams.DontImplement)
{
method.Attributes |= MemberAttributes.Override;
}
createBindingSignatureParams.Ctx.AddMemberOutput(createBindingSignatureParams.BindingsReference,
new TemplateMemberResult(null,
null,
new GenerateMethod(TemplateLocation.Both),
method,
createBindingSignatureParams.Ctx.CurrentDeclaration));
}
else if (typeof(ICollection).IsAssignableFrom(parameter.ParameterType))
{
methodInvoke.Parameters.Add(new CodeSnippetExpression(String.Format("this.{0}.{1}", elementName, createBindingSignatureParams.SourceItem.Name)));
}
else if (ObservablePropertyType.IsAssignableFrom(parameter.ParameterType))
{
methodInvoke.Parameters.Add(new CodeSnippetExpression(String.Format("this.{0}.{1}", elementName, propertyName)));
}
else if (ICommandType.IsAssignableFrom(parameter.ParameterType))
{
methodInvoke.Parameters.Add(new CodeSnippetExpression(String.Format("this.{0}.{1}", elementName, createBindingSignatureParams.SourceItem.Name)));
}
else if (!createBindingSignatureParams.DontImplement)
{
var parameterName = parameter.Name.Substring(0, 1).ToUpper() + parameter.Name.Substring(1);
var field = createBindingSignatureParams.Context._protected_(parameter.ParameterType, "_{0}{1}", name, parameterName);
field.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(UFGroupType),
new CodeAttributeArgument(new CodePrimitiveExpression(name))));
field.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(SerializeField))));
field.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(HideInInspector))));
methodInvoke.Parameters.Add(new CodeSnippetExpression(field.Name));
field.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(FormerlySerializedAsAttribute)),
new CodeAttributeArgument(new CodePrimitiveExpression(string.Format("_{0}{1}", name, parameter.Name)))));
}
}
return(methodInvoke);
}
internal static void GenerateCode(string rootType, string rootNs, CodeTypeReference baseType,
IDictionary <string, CodeTypeReference> namesAndTypes, string xamlFile, string outFile)
{
if (rootType == null)
{
File.WriteAllText(outFile, "");
return;
}
var ccu = new CodeCompileUnit();
var declNs = new CodeNamespace(rootNs);
ccu.Namespaces.Add(declNs);
var declType = new CodeTypeDeclaration(rootType)
{
IsPartial = true,
CustomAttributes =
{
new CodeAttributeDeclaration(new CodeTypeReference($"global::{typeof(XamlFilePathAttribute).FullName}"),
new CodeAttributeArgument(new CodePrimitiveExpression(xamlFile)))
}
};
declType.BaseTypes.Add(baseType);
declNs.Types.Add(declType);
var initcomp = new CodeMemberMethod
{
Name = "InitializeComponent",
CustomAttributes =
{
new CodeAttributeDeclaration(new CodeTypeReference($"global::{typeof (GeneratedCodeAttribute).FullName}"),
new CodeAttributeArgument(new CodePrimitiveExpression("Xamarin.Forms.Build.Tasks.XamlG")),
new CodeAttributeArgument(new CodePrimitiveExpression("0.0.0.0")))
}
};
declType.Members.Add(initcomp);
initcomp.Statements.Add(new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(new CodeTypeReference($"global::{typeof(Extensions).FullName}")),
"LoadFromXaml", new CodeThisReferenceExpression(), new CodeTypeOfExpression(declType.Name)));
foreach (var entry in namesAndTypes)
{
string name = entry.Key;
var type = entry.Value;
var field = new CodeMemberField
{
Name = name,
Type = type,
CustomAttributes =
{
new CodeAttributeDeclaration(new CodeTypeReference($"global::{typeof (GeneratedCodeAttribute).FullName}"),
new CodeAttributeArgument(new CodePrimitiveExpression("Xamarin.Forms.Build.Tasks.XamlG")),
new CodeAttributeArgument(new CodePrimitiveExpression("0.0.0.0")))
}
};
declType.Members.Add(field);
var find_invoke = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression(new CodeTypeReference($"global::{typeof(NameScopeExtensions).FullName}")),
"FindByName", type),
new CodeThisReferenceExpression(), new CodePrimitiveExpression(name));
//CodeCastExpression cast = new CodeCastExpression (type, find_invoke);
CodeAssignStatement assign = new CodeAssignStatement(
new CodeVariableReferenceExpression(name), find_invoke);
initcomp.Statements.Add(assign);
}
using (var writer = new StreamWriter(outFile))
Provider.GenerateCodeFromCompileUnit(ccu, writer, new CodeGeneratorOptions());
}
protected override void GenerateMethodInvokeExpression(CodeMethodInvokeExpression e)
{
}
/// <summary>
/// Deserializes a method invocation expression.
/// This is used for extender providers, e.g.
/// <code>myProvider.SetSomeProperty(targetComponent, value)</code>
/// </summary>
bool DeserializeProjectResourceMethodInvokeExpression(IDesignerSerializationManager manager, CodeMethodInvokeExpression invokeExpression)
{
if (!invokeExpression.Method.MethodName.StartsWith("Set", StringComparison.OrdinalIgnoreCase) ||
invokeExpression.Parameters.Count != 2)
{
return(false);
}
var propRefSource = invokeExpression.Parameters[1] as CodePropertyReferenceExpression;
if (propRefSource == null)
{
return(false);
}
LoggingService.Debug("Forms designer: deserializing a method invocation:");
LoggingService.Debug("-> " + CodeStatementToString(new CodeExpressionStatement(invokeExpression)));
object extenderProvider = this.baseSerializer.Deserialize(manager, invokeExpression.Method.TargetObject);
if (extenderProvider == null)
{
return(false);
}
IComponent targetComponent = this.baseSerializer.Deserialize(manager, invokeExpression.Parameters[0]) as IComponent;
if (targetComponent == null)
{
LoggingService.Info("Forms designer: ProjectResourcesComponentCodeDomSerializer could not deserialze the target object to IComponent");
return(false);
}
if (targetComponent.Site == null)
{
LoggingService.Info("Forms designer: ProjectResourcesComponentCodeDomSerializer: The deserialized component '" + targetComponent.ToString() + "' does not have a Site.");
return(false);
}
ProjectResourceInfo resourceInfo = GetProjectResourceFromPropertyReference(manager, propRefSource);
if (resourceInfo == null)
{
return(false);
}
// Set the property value of the target component to the value from the resource
extenderProvider.GetType()
.InvokeMember(invokeExpression.Method.MethodName,
BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.Public,
null,
extenderProvider,
new [] { targetComponent, resourceInfo.OriginalValue },
System.Globalization.CultureInfo.InvariantCulture);
// Store our resource info in the dictionary service.
// This is needed for the serializer so that it can
// serialize this value as a project resource reference again.
StoreResourceInfo(targetComponent, invokeExpression.Method.MethodName.Substring(3), resourceInfo);
return(true);
}
private static CodeMemberMethod CreateEventAsyncMethodOverload(CodeTypeDeclaration clientType, CodeMemberMethod eventAsyncMethod)
{
CodeMemberMethod method = new CodeMemberMethod();
method.Attributes = eventAsyncMethod.Attributes;
method.Name = eventAsyncMethod.Name;
method.ReturnType = eventAsyncMethod.ReturnType;
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), eventAsyncMethod.Name, new CodeExpression[0]);
for (int i = 0; i < (eventAsyncMethod.Parameters.Count - 1); i++)
{
method.Parameters.Add(new CodeParameterDeclarationExpression(eventAsyncMethod.Parameters[i].Type, eventAsyncMethod.Parameters[i].Name));
expression.Parameters.Add(new CodeVariableReferenceExpression(eventAsyncMethod.Parameters[i].Name));
}
expression.Parameters.Add(new CodePrimitiveExpression(null));
method.Statements.Add(expression);
int index = clientType.Members.IndexOf(eventAsyncMethod);
clientType.Members.Insert(index, method);
return method;
}
static void BuildCountry (Country c, CodeMemberMethod method)
{
CodeObjectCreateExpression country =
new CodeObjectCreateExpression (countryType,
new CodeExpression[] {
new CodePrimitiveExpression (c.Name),
new CodePrimitiveExpression (c.Locations.Count)
});
string methodName = String.Format ("Country_{0}", countryCounter++);
CodeMemberMethod countryMethod = new CodeMemberMethod ();
countryMethod.Name = methodName;
MainClass.Members.Add (countryMethod);
CodeAssignStatement countryAssign = new CodeAssignStatement ();
countryAssign.Left = curCountry;
countryAssign.Right = country;
countryMethod.Statements.Add (countryAssign);
CodeMethodInvokeExpression methodCall = new CodeMethodInvokeExpression (
thisref,
methodName
);
method.Statements.Add (methodCall);
methodCall = new CodeMethodInvokeExpression (
curCountry,
"Add",
new CodeExpression[] {curCountryLocation}
);
CodeMethodInvokeExpression locationAddDirect;
CodeObjectCreateExpression expr;
foreach (Element e in c.Locations) {
expr = BuildCountryLocation (e, countryMethod);
if (expr == null)
countryMethod.Statements.Add (methodCall);
else {
locationAddDirect = new CodeMethodInvokeExpression (
curCountry,
"Add",
new CodeExpression[] {expr}
);
countryMethod.Statements.Add (locationAddDirect);
}
}
}
void CreateAsyncMethods()
{
CodeMemberMethod method = new CodeMemberMethod();
CodeParameterDeclarationExpression arg;
CodeMethodInvokeExpression invoke;
// public virtual System.IAsyncResult BeginProcessRequest(System.Web.HttpContext context, System.AsyncCallback cb, object data);
method.ReturnType = new CodeTypeReference(typeof(IAsyncResult));
method.Name = "BeginProcessRequest";
method.Attributes = MemberAttributes.Public;
arg = new CodeParameterDeclarationExpression();
arg.Type = new CodeTypeReference(typeof(HttpContext));
arg.Name = "context";
method.Parameters.Add(arg);
arg = new CodeParameterDeclarationExpression();
arg.Type = new CodeTypeReference(typeof(AsyncCallback));
arg.Name = "cb";
method.Parameters.Add(arg);
arg = new CodeParameterDeclarationExpression();
arg.Type = new CodeTypeReference(typeof(object));
arg.Name = "data";
method.Parameters.Add(arg);
invoke = new CodeMethodInvokeExpression(thisRef, "AsyncPageBeginProcessRequest");
invoke.Parameters.Add(new CodeArgumentReferenceExpression("context"));
invoke.Parameters.Add(new CodeArgumentReferenceExpression("cb"));
invoke.Parameters.Add(new CodeArgumentReferenceExpression("data"));
method.Statements.Add(new CodeMethodReturnStatement(invoke));
mainClass.Members.Add(method);
// public virtual void EndProcessRequest(System.IAsyncResult ar);
method = new CodeMemberMethod();
method.ReturnType = new CodeTypeReference(typeof(void));
method.Name = "EndProcessRequest";
method.Attributes = MemberAttributes.Public;
arg = new CodeParameterDeclarationExpression();
arg.Type = new CodeTypeReference(typeof(IAsyncResult));
arg.Name = "ar";
method.Parameters.Add(arg);
invoke = new CodeMethodInvokeExpression(thisRef, "AsyncPageEndProcessRequest");
invoke.Parameters.Add(new CodeArgumentReferenceExpression("ar"));
method.Statements.Add(invoke);
mainClass.Members.Add(method);
// public override void ProcessRequest(System.Web.HttpContext context);
method = new CodeMemberMethod();
method.ReturnType = new CodeTypeReference(typeof(void));
method.Name = "ProcessRequest";
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
arg = new CodeParameterDeclarationExpression();
arg.Type = new CodeTypeReference(typeof(HttpContext));
arg.Name = "context";
method.Parameters.Add(arg);
invoke = new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), "ProcessRequest");
invoke.Parameters.Add(new CodeArgumentReferenceExpression("context"));
method.Statements.Add(invoke);
mainClass.Members.Add(method);
}
private void GenerateProperties(CodeTypeDeclaration targetClass, Type baseType, IEnumerable <PropertyInfo> properties)
{
var interceptorProperty = new CodeMemberProperty();
interceptorProperty.Name = "Interceptor";
interceptorProperty.Type = interceptorTypeReference;
interceptorProperty.Attributes |= MemberAttributes.Private;
interceptorProperty.PrivateImplementationType = proxyTypeReference;
interceptorProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "interceptor")));
targetClass.Members.Add(interceptorProperty);
foreach (var property in properties)
{
var p = new CodeMemberProperty();
p.Name = property.Name;
p.Type = new CodeTypeReference(property.PropertyType);
if (baseType != interfaceProxyType)
{
p.Attributes = MemberAttributes.Override;
}
targetClass.Members.Add(p);
if (property.CanRead == true)
{
p.HasGet = true;
if ((property.GetMethod.Attributes & MethodAttributes.Public) == MethodAttributes.Public)
{
p.Attributes |= MemberAttributes.Public;
}
else if ((property.GetMethod.Attributes & MethodAttributes.FamORAssem) == MethodAttributes.FamORAssem)
{
p.Attributes |= MemberAttributes.FamilyOrAssembly;
}
else if ((property.GetMethod.Attributes & MethodAttributes.Family) == MethodAttributes.Family)
{
p.Attributes |= MemberAttributes.Family;
}
else if ((property.GetMethod.Attributes & MethodAttributes.FamANDAssem) == MethodAttributes.FamANDAssem)
{
p.Attributes |= MemberAttributes.FamilyAndAssembly;
}
if (baseType == interfaceProxyType)
{
p.Attributes = MemberAttributes.Public | MemberAttributes.Final;
}
var currentMethod = new CodeVariableDeclarationStatement(typeof(MethodInfo), "currentMethod", new CodeCastExpression(typeof(MethodInfo), new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(MethodBase)), "GetCurrentMethod"))));
var getType = new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance"), "GetType");
var getMethod = new CodeMethodInvokeExpression(getType, "GetMethod", new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("currentMethod"), "Name"));
var originalMethod = new CodeVariableDeclarationStatement(typeof(MethodInfo), "originalMethod", getMethod);
p.GetStatements.Add(currentMethod);
p.GetStatements.Add(originalMethod);
var ps = new CodeExpression[] { new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance"), new CodeVariableReferenceExpression("originalMethod") };
var arg = new CodeVariableDeclarationStatement(typeof(InterceptionArgs), "args", new CodeObjectCreateExpression(typeof(InterceptionArgs), ps));
p.GetStatements.Add(arg);
var handler = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "handler"), "Invoke"), new CodeVariableReferenceExpression("args"));
p.GetStatements.Add(handler);
var comparison = new CodeBinaryOperatorExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("args"), "Handled"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(true));
var @if = new CodeConditionStatement(comparison, new CodeMethodReturnStatement(new CodeCastExpression(property.PropertyType, new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("args"), "Result"))));
p.GetStatements.Add(@if);
if (baseType != interfaceProxyType)
{
p.GetStatements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(new CodeBaseReferenceExpression(), property.Name)));
}
else
{
p.GetStatements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(new CodeCastExpression(property.DeclaringType, new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance")), property.Name)));
}
}
if (property.CanWrite == true)
{
p.HasSet = true;
var ps = new CodeExpression[]
{
new CodeThisReferenceExpression(),
new CodeCastExpression(typeof(MethodInfo), new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(MethodBase)), "GetCurrentMethod"))),
new CodeVariableReferenceExpression("value")
};
var arg = new CodeVariableDeclarationStatement(typeof(InterceptionArgs), "args", new CodeObjectCreateExpression(typeof(InterceptionArgs), ps));
p.SetStatements.Add(arg);
var handler = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "handler"), "Invoke"), new CodeVariableReferenceExpression("args"));
p.SetStatements.Add(handler);
var comparison = new CodeBinaryOperatorExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("args"), "Handled"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(true));
var @if = new CodeConditionStatement(comparison, new CodeMethodReturnStatement());
p.SetStatements.Add(@if);
if (baseType != interfaceProxyType)
{
p.SetStatements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeBaseReferenceExpression(), property.Name), new CodeVariableReferenceExpression("value")));
}
else
{
p.SetStatements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeCastExpression(property.DeclaringType, new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance")), property.Name), new CodeVariableReferenceExpression("value")));
}
}
}
}
static void BuildCity (City c, CodeMemberMethod method, CodeFieldReferenceExpression curVar,
CodeFieldReferenceExpression curLocation)
{
CodeAssignStatement cityAssign = new CodeAssignStatement ();
cityAssign.Left = curCity;
cityAssign.Right = new CodeCastExpression (cityType, curLocation);
method.Statements.Add (cityAssign);
CodeMethodInvokeExpression locationAdd;
foreach (Location l in c.Locations) {
locationAdd = new CodeMethodInvokeExpression (
curCity,
"Add",
new CodeExpression[] {BuildCityLocation (l, method)}
);
method.Statements.Add (locationAdd);
}
}
protected override void CreateConstructor(CodeStatementCollection localVars,
CodeStatementCollection trueStmt)
{
#if NET_2_0
MainDirectiveAttribute <string> masterPageFile = pageParser.MasterPageFile;
if (masterPageFile != null && !masterPageFile.IsExpression)
{
// This is here just to trigger master page build, so that its type
// is available when compiling the page itself.
BuildManager.GetCompiledType(masterPageFile.Value);
}
MainDirectiveAttribute <string> clientTarget;
#else
MainDirectiveAttribute clientTarget;
#endif
clientTarget = pageParser.ClientTarget;
if (clientTarget != null)
{
CodeExpression prop;
prop = new CodePropertyReferenceExpression(thisRef, "ClientTarget");
CodeExpression ct = null;
#if NET_2_0
if (clientTarget.IsExpression)
{
var pi = GetFieldOrProperty(typeof(Page), "ClientTarget") as PropertyInfo;
if (pi != null)
{
ct = CompileExpression(pi, pi.PropertyType, clientTarget.UnparsedValue, false);
}
}
if (ct == null)
#endif
ct = new CodePrimitiveExpression(clientTarget.Value);
if (localVars == null)
{
localVars = new CodeStatementCollection();
}
localVars.Add(new CodeAssignStatement(prop, ct));
}
ArrayList deps = pageParser.Dependencies;
int depsCount = deps != null ? deps.Count : 0;
if (depsCount > 0)
{
if (localVars == null)
{
localVars = new CodeStatementCollection();
}
if (trueStmt == null)
{
trueStmt = new CodeStatementCollection();
}
CodeAssignStatement assign;
#if NET_2_0
localVars.Add(
new CodeVariableDeclarationStatement(
typeof(string[]),
"dependencies")
);
CodeVariableReferenceExpression dependencies = new CodeVariableReferenceExpression("dependencies");
trueStmt.Add(
new CodeAssignStatement(dependencies, new CodeArrayCreateExpression(typeof(string), depsCount))
);
CodeArrayIndexerExpression arrayIndex;
object o;
for (int i = 0; i < depsCount; i++)
{
o = deps [i];
arrayIndex = new CodeArrayIndexerExpression(dependencies, new CodeExpression[] { new CodePrimitiveExpression(i) });
assign = new CodeAssignStatement(arrayIndex, new CodePrimitiveExpression(o));
trueStmt.Add(assign);
}
CodeMethodInvokeExpression getDepsCall = new CodeMethodInvokeExpression(
thisRef,
"GetWrappedFileDependencies",
new CodeExpression[] { dependencies }
);
assign = new CodeAssignStatement(GetMainClassFieldReferenceExpression("__fileDependencies"), getDepsCall);
#else
localVars.Add(new CodeVariableDeclarationStatement(
typeof(ArrayList),
"dependencies")
);
CodeVariableReferenceExpression dependencies = new CodeVariableReferenceExpression("dependencies");
trueStmt.Add(
new CodeAssignStatement(dependencies, new CodeObjectCreateExpression(typeof(ArrayList), new CodeExpression[] { new CodePrimitiveExpression(depsCount) }))
);
CodeMethodInvokeExpression invoke;
for (int i = 0; i < depsCount; i++)
{
invoke = new CodeMethodInvokeExpression(dependencies, "Add", new CodeExpression[] { new CodePrimitiveExpression(deps [i]) });
trueStmt.Add(invoke);
}
assign = new CodeAssignStatement(GetMainClassFieldReferenceExpression("__fileDependencies"), dependencies);
#endif
trueStmt.Add(assign);
}
base.CreateConstructor(localVars, trueStmt);
}
public void Visit(CaseBooleanStatement statement)
{
var domArg = new CodeDomArg();
SelectArgsInfo selectArg = null;
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "Case_" + domArg.MethodIdentifier;
method.Attributes = MemberAttributes.Private;
method.ReturnType = new CodeTypeReference(typeof(object));
GenerateCallStatement(method.Statements, statement.Line.Line);
foreach (var childArg in statement.BooleanStatements)
{
domArg = VisitChild(childArg, new CodeDomArg()
{
Scope = _codeStack.Peek().Scope
});
if (domArg.Tag != null)
{
selectArg = domArg.Tag as SelectArgsInfo;
}
method.Statements.AddRange(domArg.ParentStatements);
}
if (statement.ElseStatement == null)
{
method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
}
else
{
domArg = VisitChild(statement.ElseStatement, new CodeDomArg()
{
Scope = _codeStack.Peek().Scope
});
if (domArg.Tag != null)
{
selectArg = domArg.Tag as SelectArgsInfo;
}
method.Statements.Add(new CodeMethodReturnStatement(domArg.CodeExpression));
}
var methodcall = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(null, method.Name));
var rowParam = new CodeParameterDeclarationExpression(_codeStack.Peek().Scope.CodeDomReference.TypeArguments[0], "row");
method.Parameters.Add(rowParam);
methodcall.Parameters.Add(new CodeVariableReferenceExpression("row"));
if (selectArg != null && selectArg.IsPickStatement) //pick statement
{
var htmlNodeParam = new CodeParameterDeclarationExpression(new CodeTypeReference("HtmlElement"), "node");
methodcall.Parameters.Add(new CodeVariableReferenceExpression("node"));
method.Parameters.Add(htmlNodeParam);
}
_codeStack.Peek().Tag = selectArg;
_mainType.Type.Members.Add(method);
_codeStack.Peek().CodeExpression = methodcall;
}
internal static void EmitCodeToAddIntoCustomStdBinding(Type standardBindingType, string generatedElementClassName, string generatedCollectionElementClassName, string srcFile)
{
CodeMemberMethod applyCfgMethodForStdBinding = new CodeMemberMethod();
applyCfgMethodForStdBinding.Name = MethodNameConstants.ApplyConfigurationMethod;
string paramConfigName = "configurationName";
CodeVariableReferenceExpression paramVarRef = new CodeVariableReferenceExpression(paramConfigName);
applyCfgMethodForStdBinding.Parameters.Add(new CodeParameterDeclarationExpression(
CodeDomHelperObjects.stringTypeRef,
paramConfigName));
string bindingsString = "bindings";
CodeVariableReferenceExpression bindingsVarRef = new CodeVariableReferenceExpression(bindingsString);
string sectionString = "section";
CodeVariableReferenceExpression sectionVarRef = new CodeVariableReferenceExpression(sectionString);
string elementString = "element";
CodeVariableReferenceExpression elementVarRef = new CodeVariableReferenceExpression(elementString);
string topLevelSectionNameInConfig = "system.serviceModel/bindings/";
string subSectionNameInConfig = Helpers.TurnFirstCharLower(standardBindingType.Name);
CodeVariableDeclarationStatement bindingsInit = new CodeVariableDeclarationStatement(
new CodeTypeReference(TypeNameConstants.BindingsSection),
bindingsString,
new CodeCastExpression(TypeNameConstants.BindingsSection,
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(TypeNameConstants.ConfigurationManager),
MethodNameConstants.GetSectionMethod,
new CodePrimitiveExpression(topLevelSectionNameInConfig))));
applyCfgMethodForStdBinding.Statements.Add(bindingsInit);
CodeVariableDeclarationStatement sectionInit = new CodeVariableDeclarationStatement(
new CodeTypeReference(generatedCollectionElementClassName),
sectionString,
new CodeCastExpression(generatedCollectionElementClassName,
new CodeArrayIndexerExpression(
bindingsVarRef,
new CodePrimitiveExpression(subSectionNameInConfig))));
applyCfgMethodForStdBinding.Statements.Add(sectionInit);
CodeVariableDeclarationStatement elementInit = new CodeVariableDeclarationStatement(
new CodeTypeReference(generatedElementClassName),
elementString,
new CodeArrayIndexerExpression(
new CodeFieldReferenceExpression(
sectionVarRef,
PropertyNameConstants.BindingsProperty),
paramVarRef));
applyCfgMethodForStdBinding.Statements.Add(elementInit);
CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression(
elementVarRef,
CodeBinaryOperatorType.IdentityEquality,
CodeDomHelperObjects.NullRef);
CodeThrowExceptionStatement ctes = new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(
new CodeTypeReference(typeof(ConfigurationErrorsException)),
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(CodeDomHelperObjects.stringTypeRef),
MethodNameConstants.FormatMethod,
CodeDomHelperObjects.cultureInfoCurrent,
new CodePrimitiveExpression("There is no binding named {0} at {1}."),
paramVarRef,
new CodePropertyReferenceExpression(
sectionVarRef, PropertyNameConstants.BindingNameProperty))));
CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(
elementVarRef,
MethodNameConstants.ApplyConfigurationMethod,
CodeDomHelperObjects.ThisRef);
CodeStatement[] trueStatements = { ctes };
CodeStatement[] falseStatements = { new CodeExpressionStatement(cmie) };
CodeConditionStatement ccs = new CodeConditionStatement(cboe, trueStatements, falseStatements);
applyCfgMethodForStdBinding.Statements.Add(ccs);
string indent = " ";
CodeDomProvider provider = new Microsoft.CSharp.CSharpCodeProvider();
using (System.IO.StreamWriter sbSW = new System.IO.StreamWriter(srcFile, false))
{
using (IndentedTextWriter sbTW = new IndentedTextWriter(sbSW, indent))
{
provider.GenerateCodeFromMember(
applyCfgMethodForStdBinding,
sbTW,
new CodeGeneratorOptions());
}
}
}
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 ("TEST");
cd.IsClass = true;
nspace.Types.Add (cd);
if (Supports (provider, GeneratorSupport.ReferenceParameters)) {
//************** static internal method with parameters with out and ref directions, **************
//************** and void return type **************
// GENERATES (C#):
// /*FamANDAssem*/ internal static void Work(ref int i, out int j) {
// i = (i + 4);
// j = 5;
// }
CodeMemberMethod cmm1 = new CodeMemberMethod ();
cmm1.Name = "Work";
cmm1.ReturnType = new CodeTypeReference ("System.void");
cmm1.Attributes = MemberAttributes.Static | MemberAttributes.FamilyAndAssembly;
// add parameter with ref direction
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (typeof (int), "i");
param.Direction = FieldDirection.Ref;
cmm1.Parameters.Add (param);
// add parameter with out direction
param = new CodeParameterDeclarationExpression (typeof (int), "j");
param.Direction = FieldDirection.Out;
cmm1.Parameters.Add (param);
cmm1.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("i"),
new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.Add, new CodePrimitiveExpression (4))));
cmm1.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("j"),
new CodePrimitiveExpression (5)));
cd.Members.Add (cmm1);
}
// ********* pass by value using a protected method ******
// GENERATES (C#):
// protected static int ProtectedMethod(int a) {
// return a;
// }
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "ProtectedMethod";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Family | MemberAttributes.Static;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cd.Members.Add (cmm);
// declare a method to test the protected method with new attribute
// GENERATES (C#):
// public static int CallProtected(int a) {
// return (a + ProtectedMethod(a));
// }
AddScenario ("CheckCallProtected");
cmm = new CodeMemberMethod ();
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Name = "CallProtected";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public;
CodeMethodReferenceExpression meth = new CodeMethodReferenceExpression ();
meth.MethodName = "ProtectedMethod";
meth.TargetObject = new CodeTypeReferenceExpression("TEST2");
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("a"),
CodeBinaryOperatorType.Add, new CodeMethodInvokeExpression (meth, new CodeArgumentReferenceExpression ("a")))));
cd.Members.Add (cmm);
// GENERATES (C#):
// public static void Main() {
// }
if (Supports (provider, GeneratorSupport.EntryPointMethod)) {
CodeEntryPointMethod cep = new CodeEntryPointMethod ();
cd.Members.Add (cep);
}
// add a second class
cd = new CodeTypeDeclaration ("TEST2");
cd.BaseTypes.Add (new CodeTypeReference ("TEST"));
cd.IsClass = true;
nspace.Types.Add (cd);
if (Supports (provider, GeneratorSupport.ReferenceParameters)) {
// GENERATES (C#):
// public static int CallingWork(int a) {
// a = 10;
// int b;
// TEST.Work(ref a, out b);
// return (a + b);
// }
AddScenario ("CheckCallingWork");
cmm = new CodeMemberMethod ();
cmm.Name = "CallingWork";
cmm.Attributes = MemberAttributes.Public;
CodeParameterDeclarationExpression parames = new CodeParameterDeclarationExpression (typeof (int), "a");
cmm.Parameters.Add (parames);
cmm.ReturnType = new CodeTypeReference ("System.Int32");
cmm.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"),
new CodePrimitiveExpression (10)));
cmm.Statements.Add (new CodeVariableDeclarationStatement (typeof (int), "b"));
// invoke the method called "work"
CodeMethodInvokeExpression methodinvoked = new CodeMethodInvokeExpression (new CodeTypeReferenceExpression ("TEST"), "Work");
// add parameter with ref direction
CodeDirectionExpression parameter = new CodeDirectionExpression (FieldDirection.Ref,
new CodeArgumentReferenceExpression ("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 CodeArgumentReferenceExpression ("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression ("b"))));
cd.Members.Add (cmm);
}
// ***** declare a private method with value return type ******
// GENERATES (C#):
// private static int PrivateMethod() {
// return 5;
// }
cmm = new CodeMemberMethod ();
cmm.Name = "PrivateMethod";
cmm.Attributes = MemberAttributes.Private | MemberAttributes.Static;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (5)));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cd.Members.Add (cmm);
// declare a method to test the private method
// GENERATES (C#):
// public static int CallPrivateMethod(int a) {
// return (a + PrivateMethod());
// }
AddScenario ("CheckCallPrivateMethod");
cmm = new CodeMemberMethod ();
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Name = "CallPrivateMethod";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public;
meth = new CodeMethodReferenceExpression ();
meth.TargetObject = new CodeTypeReferenceExpression("TEST2");
meth.MethodName = "PrivateMethod";
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("a"),
CodeBinaryOperatorType.Add, new CodeMethodInvokeExpression (meth))));
cd.Members.Add (cmm);
// ********* pass by value using a protected static method ******
// this class needs to inherit from the first class so that we can call the protected method from here and call the
// public method that calls the protected method from that class
// declare a method to test the protected method
// GENERATES (C#):
// public static int CallProtectedAndPublic(int a) {
// return (CallProtected(a) + ProtectedMethod(a));
// }
AddScenario ("CheckCallProtectedAndPublic");
cmm = new CodeMemberMethod ();
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Name = "CallProtectedAndPublic";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public;
meth = new CodeMethodReferenceExpression ();
meth.MethodName = "ProtectedMethod";
meth.TargetObject = new CodeTypeReferenceExpression("TEST2");
CodeMethodReferenceExpression meth2 = new CodeMethodReferenceExpression ();
meth2.MethodName = "CallProtected";
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (new CodeMethodInvokeExpression (meth2,
new CodeArgumentReferenceExpression ("a")),
CodeBinaryOperatorType.Add, new CodeMethodInvokeExpression (meth,
new CodeArgumentReferenceExpression ("a")))));
cd.Members.Add (cmm);
if (Supports (provider, GeneratorSupport.DeclareInterfaces)) {
// ******** implement a single public interface ***********
// declare an interface
// GENERATES (C#):
// public interface TEST3 {
// int InterfaceMethod(int a);
// }
cd = new CodeTypeDeclaration ("TEST3");
cd.IsInterface = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cd.Members.Add (cmm);
// implement the interface
// GENERATES (C#):
// public class TEST3b : object, TEST3 {
// public virtual int InterfaceMethod(int a) {
// return a;
// }
// }
cd = new CodeTypeDeclaration ("TEST3b");
cd.BaseTypes.Add (new CodeTypeReference ("System.Object"));
cd.BaseTypes.Add (new CodeTypeReference ("TEST3"));
cd.IsClass = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.ImplementationTypes.Add (new CodeTypeReference ("TEST3"));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
cd.Members.Add (cmm);
// ********implement two interfaces with overloading method name*******
// declare the second interface
// GENERATES (C#):
// public interface TEST4 {
// int InterfaceMethod(int a);
// }
cd = new CodeTypeDeclaration ("TEST4");
cd.IsInterface = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cd.Members.Add (cmm);
// implement both of the interfaces
// GENERATES (C#):
// public class TEST4b : object, TEST3, TEST4 {
// public int InterfaceMethod(int a) {
// return a;
// }
// }
cd = new CodeTypeDeclaration ("TEST4b");
cd.BaseTypes.Add (new CodeTypeReference ("System.Object"));
cd.BaseTypes.Add (new CodeTypeReference ("TEST3"));
cd.BaseTypes.Add (new CodeTypeReference ("TEST4"));
cd.IsClass = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "InterfaceMethod";
cmm.ImplementationTypes.Add (new CodeTypeReference ("TEST3"));
cmm.ImplementationTypes.Add (new CodeTypeReference ("TEST4"));
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 CodeArgumentReferenceExpression ("a")));
cd.Members.Add (cmm);
}
// create a class which will have a method to call the method name that was overloaded
// this class will also call a method in the class that implements the private implements testcase
cd = new CodeTypeDeclaration ("TEST5");
cd.IsClass = true;
nspace.Types.Add (cd);
if (Supports (provider, GeneratorSupport.DeclareInterfaces)) {
// GENERATES (C#):
// public static int TestMultipleInterfaces(int i) {
// TEST4b t = new TEST4b();
// TEST3 TEST3 = ((TEST3)(t));
// TEST4 TEST4 = ((TEST4)(t));
// return (TEST3.InterfaceMethod(i) - TEST4.InterfaceMethod(i));
// }
AddScenario ("CheckTestMultipleInterfaces");
cmm = new CodeMemberMethod ();
cmm.Name = "TestMultipleInterfaces";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement ("TEST4b", "t", new CodeObjectCreateExpression ("TEST4b")));
cmm.Statements.Add (new CodeVariableDeclarationStatement ("TEST3", "TEST3", new CodeCastExpression ("TEST3",
new CodeVariableReferenceExpression ("t"))));
cmm.Statements.Add (new CodeVariableDeclarationStatement ("TEST4", "TEST4", new CodeCastExpression ("TEST4",
new CodeVariableReferenceExpression ("t"))));
CodeMethodInvokeExpression methodinvoking = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("TEST3")
, "InterfaceMethod");
methodinvoking.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
CodeMethodInvokeExpression methodinvoking2 = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("TEST4")
, "InterfaceMethod");
methodinvoking2.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
methodinvoking, CodeBinaryOperatorType.Subtract, methodinvoking2)));
cd.Members.Add (cmm);
// GENERATES (C#):
// public static int PrivateImplements(int i) {
// TEST6 t = new TEST6();
// TEST3 TEST3 = ((TEST3)(t));
// TEST4 TEST4 = ((TEST4)(t));
// return (TEST3.InterfaceMethod(i) - TEST4.InterfaceMethod(i));
// }
AddScenario ("CheckPrivateImplements");
cmm = new CodeMemberMethod ();
cmm.Name = "PrivateImplements";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement ("TEST6", "t", new CodeObjectCreateExpression ("TEST6")));
cmm.Statements.Add (new CodeVariableDeclarationStatement ("TEST3", "TEST3", new CodeCastExpression ("TEST3",
new CodeVariableReferenceExpression ("t"))));
cmm.Statements.Add (new CodeVariableDeclarationStatement ("TEST4", "TEST4", new CodeCastExpression ("TEST4",
new CodeVariableReferenceExpression ("t"))));
methodinvoking = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("TEST3")
, "InterfaceMethod");
methodinvoking.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
methodinvoking2 = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("TEST4")
, "InterfaceMethod");
methodinvoking2.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
methodinvoking, CodeBinaryOperatorType.Subtract, methodinvoking2)));
cd.Members.Add (cmm);
//******************* private implements ***************************
// implement both of the interfaces
// GENERATES (C#):
// public class TEST6 : object, TEST3, TEST4 {
// int TEST3.InterfaceMethod(int a) {
// return a;
// }
// int TEST4.InterfaceMethod(int a) {
// return (5 * a);
// }
// }
CodeTypeDeclaration ctd = new CodeTypeDeclaration ("TEST6");
ctd.BaseTypes.Add (new CodeTypeReference ("System.Object"));
ctd.BaseTypes.Add (new CodeTypeReference ("TEST3"));
ctd.BaseTypes.Add (new CodeTypeReference ("TEST4"));
ctd.IsClass = true;
nspace.Types.Add (ctd);
// make a seperate implementation for each base
// first for TEST3 base
cmm = new CodeMemberMethod ();
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 CodeArgumentReferenceExpression ("a")));
cmm.PrivateImplementationType = new CodeTypeReference ("TEST3");
ctd.Members.Add (cmm);
// now implement for TEST4 base
cmm = new CodeMemberMethod ();
cmm = new CodeMemberMethod ();
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.PrivateImplementationType = new CodeTypeReference ("TEST4");
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (new
CodePrimitiveExpression (5), CodeBinaryOperatorType.Multiply, new
CodeArgumentReferenceExpression ("a"))));
ctd.Members.Add (cmm);
}
// method to test the 'new' scenario by calling the 'new' method
// GENERATES (C#):
// public int CallingNewScenario(int i) {
// ClassWVirtualMethod t = new ClassWNewMethod();
// return (((ClassWNewMethod)(t)).VirtualMethod(i) - t.VirtualMethod(i));
// }
CodeMethodInvokeExpression methodinvoke;
#if !FSHARP
AddScenario ("CheckCallingNewScenario");
cmm = new CodeMemberMethod ();
cmm.Name = "CallingNewScenario";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement ("ClassWVirtualMethod", "t", new CodeCastExpression(new CodeTypeReference("ClassWVirtualMethod"), new CodeObjectCreateExpression ("ClassWNewMethod"))));
CodeMethodInvokeExpression methodinvoke = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("t"), "VirtualMethod");
methodinvoke.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
CodeMethodInvokeExpression methodinvoke2 = new CodeMethodInvokeExpression (new CodeCastExpression ("ClassWNewMethod", new
CodeVariableReferenceExpression ("t")), "VirtualMethod");
methodinvoke2.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
methodinvoke2, CodeBinaryOperatorType.Subtract, methodinvoke)));
cd.Members.Add (cmm);
#endif
// similar to the 'new' test, write a method to complete testing of the 'override' scenario
// GENERATES (C#):
// public static int CallingOverrideScenario(int i) {
// ClassWVirtualMethod t = new ClassWOverrideMethod();
// return t.VirtualMethod(i);
// }
AddScenario ("CheckCallingOverrideScenario");
cmm = new CodeMemberMethod ();
cmm.Name = "CallingOverrideScenario";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add(new CodeVariableDeclarationStatement("ClassWVirtualMethod", "t", new CodeCastExpression(new CodeTypeReference("ClassWVirtualMethod"), new CodeObjectCreateExpression("ClassWOverrideMethod"))));
methodinvoke = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("t"), "VirtualMethod");
methodinvoke.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
cmm.Statements.Add (new CodeMethodReturnStatement (methodinvoke));
cd.Members.Add (cmm);
//*************** overload member function ****************
// new class which will include both functions
// GENERATES (C#):
// public class TEST7 {
// public static int OverloadedMethod(int a) {
// return a;
// }
// public static int OverloadedMethod(int a, int b) {
// return (b + a);
// }
// public static int CallingOverloadedMethods(int i) {
// return (OverloadedMethod(i, i) - OverloadedMethod(i));
// }
// }
cd = new CodeTypeDeclaration ("TEST7");
cd.IsClass = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "OverloadedMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
cd.Members.Add (cmm);
cmm = new CodeMemberMethod ();
cmm.Name = "OverloadedMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "b"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("b"), CodeBinaryOperatorType.Add,
new CodeArgumentReferenceExpression ("a"))));
cd.Members.Add (cmm);
// declare a method that will call both OverloadedMethod functions
AddScenario ("CheckCallingOverloadedMethods");
cmm = new CodeMemberMethod ();
cmm.Name = "CallingOverloadedMethods";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.Attributes = MemberAttributes.Public;
CodeMethodReferenceExpression methodref = new CodeMethodReferenceExpression ();
methodref.MethodName = "OverloadedMethod";
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
new CodeMethodInvokeExpression (methodref, new
CodeArgumentReferenceExpression ("i"), new CodeArgumentReferenceExpression ("i"))
, CodeBinaryOperatorType.Subtract, new CodeMethodInvokeExpression (methodref, new
CodeArgumentReferenceExpression ("i")))));
cd.Members.Add (cmm);
// ***************** declare method using new ******************
// first declare a class with a virtual method in it
// GENERATES (C#):
// public class ClassWVirtualMethod {
// public virtual int VirtualMethod(int a) {
// return a;
// }
// }
cd = new CodeTypeDeclaration ("ClassWVirtualMethod");
cd.IsClass = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "VirtualMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
cd.Members.Add (cmm);
#if !FSHARP
// now declare a class that inherits from the previous class and has a 'new' method with the
// name VirtualMethod
// GENERATES (C#):
// public class ClassWNewMethod : ClassWVirtualMethod {
// public new virtual int VirtualMethod(int a) {
// return (2 * a);
// }
// }
cd = new CodeTypeDeclaration ("ClassWNewMethod");
cd.BaseTypes.Add (new CodeTypeReference ("ClassWVirtualMethod"));
cd.IsClass = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "VirtualMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.New;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
new CodePrimitiveExpression (2), CodeBinaryOperatorType.Multiply
, new CodeArgumentReferenceExpression ("a"))));
cd.Members.Add (cmm);
#endif
// *************** declare a method using override ******************
// now declare a class that inherits from the previous class and has a 'new' method with the
// name VirtualMethod
// GENERATES (C#):
// public class ClassWOverrideMethod : ClassWVirtualMethod {
// public override int VirtualMethod(int a) {
// return (2 * a);
// }
// }
cd = new CodeTypeDeclaration ("ClassWOverrideMethod");
cd.BaseTypes.Add (new CodeTypeReference ("ClassWVirtualMethod"));
cd.IsClass = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "VirtualMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
new CodePrimitiveExpression (2), CodeBinaryOperatorType.Multiply
, new CodeArgumentReferenceExpression ("a"))));
cd.Members.Add (cmm);
}
private static void PrintExpression(TextWriter output, CodeExpression expression)
{
if (expression is CodeMethodInvokeExpression)
{
CodeMethodInvokeExpression cmi = (CodeMethodInvokeExpression)expression;
if (cmi.Method.TargetObject == null)
{
output.Write("defaultscope");
}
else
{
PrintExpression(output, cmi.Method.TargetObject);
}
output.Write('.');
output.Write(cmi.Method.MethodName);
output.Write('(');
for (int i = 0; i < cmi.Parameters.Count; ++i)
{
if (i > 0)
{
output.Write(", ");
}
PrintExpression(output, cmi.Parameters[i]);
}
output.Write(')');
return;
}
if (expression is CodeDelegateInvokeExpression)
{
CodeDelegateInvokeExpression die = (CodeDelegateInvokeExpression)expression;
output.Write("delegatecall(");
PrintExpression(output, die.TargetObject);
output.Write(')');
output.Write('(');
for (int i = 0; i < die.Parameters.Count; ++i)
{
if (i > 0)
{
output.Write(", ");
}
PrintExpression(output, die.Parameters[i]);
}
output.Write(')');
return;
}
if (expression is CodePropertyReferenceExpression)
{
CodePropertyReferenceExpression cpre = (CodePropertyReferenceExpression)expression;
if (cpre.TargetObject == null)
{
output.Write("defaultscope");
}
else
{
PrintExpression(output, cpre.TargetObject);
}
output.Write('.');
output.Write(cpre.PropertyName);
return;
}
if (expression is CodeFieldReferenceExpression)
{
CodeFieldReferenceExpression cpre = (CodeFieldReferenceExpression)expression;
if (cpre.TargetObject == null)
{
output.Write("defaultscope");
}
else
{
PrintExpression(output, cpre.TargetObject);
}
output.Write('.');
output.Write(cpre.FieldName);
output.Write('$');
return;
}
if (expression is CodePrimitiveExpression)
{
object value = ((CodePrimitiveExpression)expression).Value;
if (value == null)
{
output.Write("null");
}
else if (value.Equals(true))
{
output.Write("true");
}
else if (value.Equals(false))
{
output.Write("false");
}
else if (value is string)
{
output.Write("'{0}'", value.ToString().Replace("'", "\\'"));
}
else
{
output.Write("{0}", value);
}
return;
}
if (expression is CodeThisReferenceExpression)
{
output.Write("this");
return;
}
if (expression is CodeBaseReferenceExpression)
{
output.Write("base");
return;
}
if (expression is CodeArgumentReferenceExpression)
{
output.Write("arg({0})", ((CodeArgumentReferenceExpression)expression).ParameterName);
return;
}
if (expression is CodeVariableReferenceExpression)
{
output.Write("var({0})", ((CodeVariableReferenceExpression)expression).VariableName);
return;
}
if (expression is CodeTypeReferenceExpression)
{
output.Write("typeref(");
CodeTypeReferenceExpression ctr = (CodeTypeReferenceExpression)expression;
PrintTypeReference(output, ctr.Type);
output.Write(')');
return;
}
if (expression is CodeCastExpression)
{
CodeCastExpression cce = expression as CodeCastExpression;
output.Write("cast(");
PrintTypeReference(output, cce.TargetType);
output.Write(", ");
PrintExpression(output, cce.Expression);
output.Write(')');
return;
}
if (expression is CodeTypeOfExpression)
{
CodeTypeOfExpression ctoe = (CodeTypeOfExpression)expression;
output.Write("typeof(");
PrintTypeReference(output, ctoe.Type);
output.Write(')');
return;
}
if (expression is CodeObjectCreateExpression)
{
CodeObjectCreateExpression coce = (CodeObjectCreateExpression)expression;
output.Write("new ");
PrintTypeReference(output, coce.CreateType);
output.Write('(');
for (int i = 0; i < coce.Parameters.Count; ++i)
{
if (i > 0)
{
output.Write(", ");
}
PrintExpression(output, coce.Parameters[i]);
}
output.Write(')');
return;
}
if (expression is CodeArrayIndexerExpression)
{
CodeArrayIndexerExpression caie = (CodeArrayIndexerExpression)expression;
output.Write("arrayitem(");
PrintExpression(output, caie.TargetObject);
for (int i = 0; i < caie.Indices.Count; ++i)
{
output.Write(", ");
PrintExpression(output, caie.Indices[i]);
}
output.Write(')');
return;
}
if (expression is CodeArrayCreateExpression)
{
CodeArrayCreateExpression cace = (CodeArrayCreateExpression)expression;
output.Write("newarray(");
PrintTypeReference(output, cace.CreateType);
output.Write(',');
PrintExpression(output, cace.SizeExpression);
output.Write(')');
return;
}
if (expression is CodeBinaryOperatorExpression)
{
CodeBinaryOperatorExpression cboe = (CodeBinaryOperatorExpression)expression;
switch (cboe.Operator)
{
case CodeBinaryOperatorType.ValueEquality:
output.Write("equals");
break;
case CodeBinaryOperatorType.IdentityEquality:
output.Write("refequal");
break;
case CodeBinaryOperatorType.IdentityInequality:
output.Write("refnotequal");
break;
case CodeBinaryOperatorType.Add:
output.Write("add");
break;
default:
output.Write("UNKNOWN CBOE: {0}", cboe.Operator);
break;
}
output.Write('(');
PrintExpression(output, cboe.Left);
output.Write(", ");
PrintExpression(output, cboe.Right);
output.Write(')');
return;
}
if (expression is CodePropertySetValueReferenceExpression)
{
output.Write("setvalue");
return;
}
if (expression is CodeDirectionExpression)
{
switch (((CodeDirectionExpression)expression).Direction)
{
case FieldDirection.In:
PrintExpression(output, ((CodeDirectionExpression)expression).Expression);
break;
case FieldDirection.Out:
output.Write("out(");
PrintExpression(output, ((CodeDirectionExpression)expression).Expression);
output.Write(')');
break;
case FieldDirection.Ref:
output.Write("ref(");
PrintExpression(output, ((CodeDirectionExpression)expression).Expression);
output.Write(')');
break;
}
return;
}
output.Write("*** UNKNOWN EXPRESSION:" + expression.GetType() + " ***");
}
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 ("TEST");
cd.IsClass = true;
nspace.Types.Add (cd);
if (Supports (provider, GeneratorSupport.ReferenceParameters)) {
// GENERATE (C#):
// void Work(ref int i, out int j) {
// i = (i + 4);
// j = 5;
// }
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "Work";
cmm.ReturnType = new CodeTypeReference ("System.Void");
// 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);
// add a method that calls method work to verify that ref and out are working properly
// GENERATE (C#):
// public int CallingWork(int a) {
// a = 10;
// int b;
// Work(ref a, out b);
// return (a + b);
// }
AddScenario ("CheckCallingWork", "Check the return value of CallingWork().");
cmm = new CodeMemberMethod ();
cmm.Name = "CallingWork";
cmm.Attributes = MemberAttributes.Public;
CodeParameterDeclarationExpression parames = new CodeParameterDeclarationExpression (typeof (int), "a");
cmm.Parameters.Add (parames);
cmm.ReturnType = new CodeTypeReference ("System.Int32");
cmm.Statements.Add (new CodeAssignStatement (new CodeArgumentReferenceExpression ("a"),
new CodePrimitiveExpression (10)));
cmm.Statements.Add (new CodeVariableDeclarationStatement (typeof (int), "b"));
// invoke the method called "work"
CodeMethodInvokeExpression methodinvoked = new CodeMethodInvokeExpression (new CodeMethodReferenceExpression (null,
"Work"));
// add parameter with ref direction
CodeDirectionExpression parameter = new CodeDirectionExpression (FieldDirection.Ref,
new CodeArgumentReferenceExpression ("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 CodeArgumentReferenceExpression ("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression ("b"))));
cd.Members.Add (cmm);
}
}
public override void Transform(IClass scope, IReference reference, CodeMemberProperty property, Transformations.Core.ITransformationContext context)
{
var baseTypes = Layering <IClass> .CreateLayers(scope, c => c.BaseTypes).Select(c => c.Single()).ToList();
if (!baseTypes.Contains((IClass)reference.DeclaringType))
{
throw new InvalidOperationException(string.Format("The reference {0} cannot be refined in the scope of class {1} because {1} does not inherit from its declaring class.", reference.Name, scope.Name));
}
var classDeclaration = context.Trace.ResolveIn(Rule <Type2Type>(), scope);
var originalReference = context.Trace.ResolveIn(Rule <Reference2Property>(), reference);
property.Attributes = MemberAttributes.Private;
property.Name = originalReference.Name;
property.PrivateImplementationType = CreateReference(reference.DeclaringType, false, context);
property.Type = originalReference.Type;
lock (classDeclaration)
{
classDeclaration.Shadows(true).Add(originalReference);
classDeclaration.DependentMembers(true).Add(property);
}
var implementations = baseTypes.SelectMany(s => s.References).Where(r => r.Refines == reference).ToList();
var constraints = baseTypes.SelectMany(s => s.ReferenceConstraints).Where(rc => rc.Constrains == reference);
foreach (var declClass in implementations.Select(a => a.DeclaringType).OfType <IClass>().Concat(constraints.Select(c => c.DeclaringType)).Distinct())
{
if (declClass != scope)
{
var refinedReference = context.Trace.ResolveIn(this, declClass, reference);
if (refinedReference != null)
{
property.Shadows(true).Add(refinedReference);
}
}
}
if (implementations.Count == 0 && !constraints.Any())
{
throw new InvalidOperationException(
string.Format("The reference {0} can not be refined in the scope of class {1} because no reference refines it. ", reference, scope)
);
}
var referenceType = CreateReference(reference.Type, true, context);
if (reference.UpperBound == 1)
{
var nullRef = new CodePrimitiveExpression(null);
if (!constraints.Any())
{
var castedThisVariable = new CodeVariableDeclarationStatement(classDeclaration.GetReferenceForType(), "_this", new CodeThisReferenceExpression());
var castedThisVariableRef = new CodeVariableReferenceExpression("_this");
property.GetStatements.Add(castedThisVariable);
property.SetStatements.Add(castedThisVariable);
var setRef = new CodePropertySetValueReferenceExpression();
var ifNull = new CodeConditionStatement();
ifNull.Condition = new CodeBinaryOperatorExpression(setRef, CodeBinaryOperatorType.IdentityInequality, nullRef);
var foundMatch = false;
foreach (var implementation in implementations)
{
var implementationRef = new CodePropertyReferenceExpression(castedThisVariableRef, context.Trace.ResolveIn(Rule <Reference2Property>(), implementation).Name);
if (implementation.Type == reference.Type)
{
property.GetStatements.Add(new CodeMethodReturnStatement(implementationRef));
property.SetStatements.Add(new CodeAssignStatement(implementationRef, setRef));
foundMatch = true;
break;
}
else
{
var getIfStmt = new CodeConditionStatement();
getIfStmt.Condition = new CodeBinaryOperatorExpression(implementationRef, CodeBinaryOperatorType.IdentityInequality, nullRef);
getIfStmt.TrueStatements.Add(new CodeMethodReturnStatement(implementationRef));
property.GetStatements.Add(getIfStmt);
var implementationType = CreateReference(implementation.Type, true, context);
var asRef = new CodeMethodReferenceExpression(setRef, "As", implementationType);
var localVar = new CodeVariableDeclarationStatement(implementationType, "__" + implementation.Name, new CodeMethodInvokeExpression(asRef));
var localVarRef = new CodeVariableReferenceExpression(localVar.Name);
var setIfStmt = new CodeConditionStatement();
setIfStmt.Condition = new CodeBinaryOperatorExpression(localVarRef, CodeBinaryOperatorType.IdentityInequality, nullRef);
setIfStmt.TrueStatements.Add(new CodeAssignStatement(implementationRef, localVarRef));
setIfStmt.TrueStatements.Add(new CodeMethodReturnStatement());
ifNull.TrueStatements.Add(localVar);
ifNull.TrueStatements.Add(setIfStmt);
ifNull.FalseStatements.Add(new CodeAssignStatement(implementationRef, nullRef));
}
}
ifNull.FalseStatements.Add(new CodeMethodReturnStatement());
if (ifNull.TrueStatements.Count > 0)
{
property.SetStatements.Add(ifNull);
}
if (!foundMatch)
{
property.GetStatements.Add(new CodeMethodReturnStatement(nullRef));
property.SetStatements.Add(new CodeThrowExceptionStatement(new CodeObjectCreateExpression(typeof(System.ArgumentException), new CodePrimitiveExpression("There was no suitable refining reference found for this object"))));
}
}
else
{
var constraint = constraints.Last();
var ifNotDefault = new CodeConditionStatement();
ifNotDefault.TrueStatements.Add(new CodeThrowExceptionStatement(new CodeObjectCreateExpression(typeof(System.NotSupportedException))));
CodeExpression value;
if (constraint.References.Count == 0)
{
value = nullRef;
}
else
{
var refEl = constraint.References[0];
var uri = refEl.AbsoluteUri;
if (uri == null)
{
throw new System.InvalidOperationException();
}
var metaRepositoryInstance = new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(MetaRepository)), "Instance");
var refElExpression = new CodeMethodInvokeExpression(metaRepositoryInstance, "Resolve", new CodePrimitiveExpression(uri.AbsoluteUri));
refElExpression = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(refElExpression, "As", property.Type));
var staticField = new CodeMemberField(property.Type, "_" + reference.Name.ToPascalCase());
staticField.Attributes = MemberAttributes.Private | MemberAttributes.Static;
staticField.InitExpression = refElExpression;
property.DependentMembers(true).Add(staticField);
value = new CodeFieldReferenceExpression(null, staticField.Name);
}
property.GetStatements.Add(new CodeMethodReturnStatement(value));
ifNotDefault.Condition = new CodeBinaryOperatorExpression(new CodePropertySetValueReferenceExpression(), CodeBinaryOperatorType.IdentityInequality, value);
property.SetStatements.Add(ifNotDefault);
}
CreateChangeEvent(property, implementations, context, "Changed");
CreateChangeEvent(property, implementations, context, "Changing");
}
else
{
if (reference.IsUnique)
{
throw new System.InvalidOperationException("Unique references must not be refined!");
}
if (implementations.Count > 0 || constraints.Any(c => c.References.Any()))
{
var collectionType = context.Trace.ResolveIn(Rule <RefinedReferenceCollectionClassGenerator>(), scope, reference);
property.GetStatements.Add(new CodeMethodReturnStatement(new CodeObjectCreateExpression(collectionType.GetReferenceForType(), new CodeThisReferenceExpression())));
property.DependentTypes(true).Add(collectionType);
}
else
{
property.GetStatements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(new CodeTypeReference(typeof(EmptyList <>).Name, referenceType)), "Instance")));
}
}
}
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");
}
/// <summary>
/// Creates the appropriate code objects needed to create the entry method for the
/// current request.
/// </summary>
/// <param name="part">
/// The <see cref="OpenXmlPart"/> object and relationship id to build code for.
/// </param>
/// <param name="settings">
/// The <see cref="ISerializeSettings"/> to use during the code generation
/// process.
/// </param>
/// /// <param name="typeCounts">
/// A lookup <see cref="IDictionary{TKey, TValue}"/> object containing the
/// number of times a given type was referenced. This is used for variable naming
/// purposes.
/// </param>
/// <param name="namespaces">
/// Collection <see cref="ISet{T}"/> used to keep track of all openxml namespaces
/// used during the process.
/// </param>
/// <param name="blueprints">
/// The collection of <see cref="OpenXmlPartBluePrint"/> objects that have already been
/// visited.
/// </param>
/// <param name="rootVar">
/// The root variable name and <see cref="Type"/> to use when building code
/// statements to create new <see cref="OpenXmlPart"/> objects.
/// </param>
/// <returns>
/// A collection of code statements and expressions that could be used to generate
/// a new <paramref name="part"/> object from code.
/// </returns>
public static CodeStatementCollection BuildEntryMethodCodeStatements(
IdPartPair part,
ISerializeSettings settings,
IDictionary <string, int> typeCounts,
ISet <string> namespaces,
OpenXmlPartBluePrintCollection blueprints,
KeyValuePair <string, Type> rootVar)
{
// Argument validation
if (part is null)
{
throw new ArgumentNullException(nameof(part));
}
if (settings is null)
{
throw new ArgumentNullException(nameof(settings));
}
if (blueprints is null)
{
throw new ArgumentNullException(nameof(blueprints));
}
if (String.IsNullOrWhiteSpace(rootVar.Key))
{
throw new ArgumentNullException(nameof(rootVar.Key));
}
bool hasHandlers = settings?.Handlers != null;
// Use the custom handler methods if present and provide actual code
if (hasHandlers && settings.Handlers.TryGetValue(part.OpenXmlPart.GetType(), out IOpenXmlHandler h))
{
if (h is IOpenXmlPartHandler partHandler)
{
var customStatements = partHandler.BuildEntryMethodCodeStatements(
part, settings, typeCounts, namespaces, blueprints, rootVar);
if (customStatements != null)
{
return(customStatements);
}
}
}
var result = new CodeStatementCollection();
var partType = part.OpenXmlPart.GetType();
var partTypeName = partType.Name;
var partTypeFullName = partType.FullName;
string varName = partType.Name.ToCamelCase();
bool customAddNewPartRequired = CheckForCustomAddNewPartMethod(partType, rootVar.Value, out string addNewPartName);
#pragma warning disable IDE0018 // Inline variable declaration
OpenXmlPartBluePrint bpTemp;
#pragma warning restore IDE0018 // Inline variable declaration
CodeMethodReferenceExpression referenceExpression;
CodeMethodInvokeExpression invokeExpression;
CodeMethodReferenceExpression methodReference;
// Make sure that the namespace for the current part is captured
namespaces.Add(partType.Namespace);
// If the URI of the current part has already been included into
// the blue prints collection, build the AddPart invocation
// code statement and exit current method iteration.
if (blueprints.TryGetValue(part.OpenXmlPart.Uri, out bpTemp))
{
// Surround this snippet with blank lines to make it
// stand out in the current section of code.
result.AddBlankLine();
referenceExpression = new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression(rootVar.Key), "AddPart",
new CodeTypeReference(part.OpenXmlPart.GetType().Name));
invokeExpression = new CodeMethodInvokeExpression(referenceExpression,
new CodeVariableReferenceExpression(bpTemp.VariableName),
new CodePrimitiveExpression(part.RelationshipId));
result.Add(invokeExpression);
result.AddBlankLine();
return(result);
}
// Assign the appropriate variable name
if (typeCounts.ContainsKey(partTypeFullName))
{
varName = String.Concat(varName, typeCounts[partTypeFullName]++);
}
else
{
typeCounts.Add(partTypeFullName, 1);
}
// Setup the blueprint
bpTemp = new OpenXmlPartBluePrint(part.OpenXmlPart, varName);
// Need to evaluate the current OpenXmlPart type first to make sure the
// correct "Add" statement is used as not all Parts can be initialized
// using the "AddNewPart" method
// Check for image part methods
if (customAddNewPartRequired)
{
referenceExpression = new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression(rootVar.Key), addNewPartName);
}
else
{
// Setup the add new part statement for the current OpenXmlPart object
referenceExpression = new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression(rootVar.Key), "AddNewPart",
new CodeTypeReference(partTypeName));
}
// Create the invoke expression
invokeExpression = new CodeMethodInvokeExpression(referenceExpression);
// Add content type to invoke method for embeddedpackage and image parts.
if (part.OpenXmlPart is EmbeddedPackagePart || customAddNewPartRequired)
{
invokeExpression.Parameters.Add(
new CodePrimitiveExpression(part.OpenXmlPart.ContentType));
}
else if (!customAddNewPartRequired)
{
invokeExpression.Parameters.Add(
new CodePrimitiveExpression(part.RelationshipId));
}
result.Add(new CodeVariableDeclarationStatement(partTypeName, varName, invokeExpression));
// Because the custom AddNewPart methods don't consistently take in a string relId
// as a parameter, the id needs to be assigned after it is created.
if (customAddNewPartRequired)
{
methodReference = new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression(rootVar.Key), "ChangeIdOfPart");
result.Add(new CodeMethodInvokeExpression(methodReference,
new CodeVariableReferenceExpression(varName),
new CodePrimitiveExpression(part.RelationshipId)));
}
// Add the call to the method to populate the current OpenXmlPart object
methodReference = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), bpTemp.MethodName);
result.Add(new CodeMethodInvokeExpression(methodReference,
new CodeDirectionExpression(FieldDirection.Ref,
new CodeVariableReferenceExpression(varName))));
// Add the appropriate code statements if the current part
// contains any hyperlink relationships
if (part.OpenXmlPart.HyperlinkRelationships.Count() > 0)
{
// Add a line break first for easier reading
result.AddBlankLine();
result.AddRange(
part.OpenXmlPart.HyperlinkRelationships.BuildHyperlinkRelationshipStatements(varName));
}
// Add the appropriate code statements if the current part
// contains any non-hyperlink external relationships
if (part.OpenXmlPart.ExternalRelationships.Count() > 0)
{
// Add a line break first for easier reading
result.AddBlankLine();
result.AddRange(
part.OpenXmlPart.ExternalRelationships.BuildExternalRelationshipStatements(varName));
}
// put a line break before going through the child parts
result.AddBlankLine();
// Add the current blueprint to the collection
blueprints.Add(bpTemp);
// Now check to see if there are any child parts for the current OpenXmlPart object.
if (bpTemp.Part.Parts != null)
{
OpenXmlPartBluePrint childBluePrint;
foreach (var p in bpTemp.Part.Parts)
{
// If the current child object has already been created, simply add a reference to
// said object using the AddPart method.
if (blueprints.Contains(p.OpenXmlPart.Uri))
{
childBluePrint = blueprints[p.OpenXmlPart.Uri];
referenceExpression = new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression(varName), "AddPart",
new CodeTypeReference(p.OpenXmlPart.GetType().Name));
invokeExpression = new CodeMethodInvokeExpression(referenceExpression,
new CodeVariableReferenceExpression(childBluePrint.VariableName),
new CodePrimitiveExpression(p.RelationshipId));
result.Add(invokeExpression);
continue;
}
// If this is a new part, call this method with the current part's details
result.AddRange(BuildEntryMethodCodeStatements(p, settings, typeCounts, namespaces, blueprints,
new KeyValuePair <string, Type>(varName, partType)));
}
}
return(result);
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
if (!(provider is JScriptCodeProvider)) {
// GENERATES (C#):
// namespace Foo {
// public class Foo {
//
// public int _verifyGlobalGeneration1 = 2147483647;
//
// public int System {
// get { return 42; }
// }
//
// public int Property {
// get { return 2147483647; }
// }
//
// public int GlobalTestProperty1 {
// get {
// return _verifyGlobalGeneration1;
// }
// set {
// _verifyGlobalGeneration1 = value;
// }
// }
//
// public global::System.Nullable<int> GlobalTestProperty2 {
// get {
// return _verifyGlobalGeneration2;
// }
// set {
// _verifyGlobalGeneration2 = value;
// }
// }
//
//
// public int TestMethod02() {
// int iReturn;
// iReturn = global::Foo.Foo.Property;
// return iReturn;
// }
//
// public int TestMethod03() {
// int iReturn;
// iReturn = global::System.Math.Abs(-1);
// return iReturn;
// }
//
// public int TestMethod04() {
// int iReturn;
// iReturn = System;
// return iReturn;
// }
// }
CodeNamespace ns = new CodeNamespace ("Foo");
ns.Comments.Add (new CodeCommentStatement ("Foo namespace"));
cu.Namespaces.Add (ns);
CodeTypeDeclaration cd = new CodeTypeDeclaration ("Foo");
ns.Types.Add (cd);
CodeMemberProperty property = new CodeMemberProperty ();
property.Name = "System";
property.Attributes = MemberAttributes.Public;
property.Attributes = (property.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Private | MemberAttributes.Static;
property.Type = new CodeTypeReference (typeof (int));
property.GetStatements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (42)));
cd.Members.Add (property);
property = new CodeMemberProperty ();
property.Name = "Property";
property.Attributes = (property.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Private | MemberAttributes.Static;
property.Type = new CodeTypeReference (typeof (int));
property.GetStatements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (Int32.MaxValue)));
cd.Members.Add (property);
AddScenario ("CallTestMethod02", "Call Foo.Foo.TestMethod02.");
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"));
CodePropertyReferenceExpression cpr = new CodePropertyReferenceExpression (
new CodeTypeReferenceExpression (new CodeTypeReference ("Foo.Foo",
CodeTypeReferenceOptions.GlobalReference)), "Property");
CodeAssignStatement cas = new CodeAssignStatement (new CodeVariableReferenceExpression ("iReturn"), cpr);
method2.Statements.Add (cas);
method2.Statements.Add (new CodeMethodReturnStatement (new CodeVariableReferenceExpression ("iReturn")));
cd.Members.Add (method2);
AddScenario ("CallTestMethod03", "Call Foo.Foo.TestMethod02.");
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);
CodeMethodInvokeExpression 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);
AddScenario ("CallTestMethod04", "Call Foo.Foo.TestMethod04.");
CodeMemberMethod method4 = new CodeMemberMethod ();
method4.Name = "TestMethod04";
method4.Attributes = (method4.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
method4.ReturnType = new CodeTypeReference (typeof (int));
method4.Statements.Add (new CodeVariableDeclarationStatement (typeof (int), "iReturn"));
cpr = new CodePropertyReferenceExpression (null, "System");
cas = new CodeAssignStatement (new CodeVariableReferenceExpression ("iReturn"), cpr);
method4.Statements.Add (cas);
method4.Statements.Add (new CodeMethodReturnStatement (new CodeVariableReferenceExpression ("iReturn")));
cd.Members.Add (method4);
// Verify that what CodeTypeReferenceOptions are correctly set.
// Basically this check gives the code coverage for the get property
AddScenario ("CTR_GetGlobalRefCheck", "Check that CodeTypeReference.Options gives the proper value.");
if (ctr.Options == CodeTypeReferenceOptions.GlobalReference)
VerifyScenario ("CTR_GetGlobalRefCheck");
// one-off generate statements
StringWriter sw = new StringWriter ();
// global shouldn't be generated in this instance
CodeTypeReference variableType = new CodeTypeReference (typeof (System.String), CodeTypeReferenceOptions.GlobalReference);
CodeVariableDeclarationStatement variable = new CodeVariableDeclarationStatement (variableType, "myVariable");
provider.GenerateCodeFromStatement (variable, sw, null);
// global should be generated in this instance
CodeTypeReference variableType2 = new CodeTypeReference (typeof (System.Array), CodeTypeReferenceOptions.GlobalReference);
CodeVariableDeclarationStatement variable2 = new CodeVariableDeclarationStatement (variableType2, "myVariable2");
provider.GenerateCodeFromStatement (variable2, sw, null);
AddScenario ("GlobalKeywordShouldExist", "When an array is referred to, a global qualifier should be generated on it.");
if (sw.ToString ().IndexOf ("global") != -1 && sw.ToString ().IndexOf ("Global") != -1) {
LogMessage ("Global keyword does not exist in statement: " + sw.ToString ());
}
else
VerifyScenario ("GlobalKeywordShouldExist");
}
}
internal /*public*/ static CodeExpression GenerateExpressionForValue(PropertyInfo propertyInfo, object value, Type valueType)
{
#if DEBUG
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("GenerateExpressionForValue() {");
Debug.Indent();
}
#endif // DEBUG
CodeExpression rightExpr = null;
if (valueType == null)
{
throw new ArgumentNullException("valueType");
}
PropertyDescriptor pd = null;
if (propertyInfo != null)
{
pd = TypeDescriptor.GetProperties(propertyInfo.ReflectedType)[propertyInfo.Name];
}
if (valueType == typeof(string) && value is string)
{
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("simple string");
}
rightExpr = new CodePrimitiveExpression((string)value);
}
else if (valueType.IsPrimitive)
{
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("primitive");
}
rightExpr = new CodePrimitiveExpression(value);
}
else if (valueType.IsArray)
{
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("array");
}
Array array = (Array)value;
CodeArrayCreateExpression exp = new CodeArrayCreateExpression();
exp.CreateType = new CodeTypeReference(valueType.GetElementType());
if (array != null)
{
foreach (object o in array)
{
exp.Initializers.Add(GenerateExpressionForValue(null, o, valueType.GetElementType()));
}
}
rightExpr = exp;
}
else
{
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("other");
}
TypeConverter converter = null;
if (pd != null)
{
converter = pd.Converter;
}
else
{
converter = TypeDescriptor.GetConverter(valueType);
}
bool added = false;
if (converter != null)
{
InstanceDescriptor desc = null;
if (converter.CanConvertTo(typeof(InstanceDescriptor)))
{
desc = (InstanceDescriptor)converter.ConvertTo(value, typeof(InstanceDescriptor));
}
if (desc != null)
{
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("has converter with instance descriptor");
}
// static field ref...
//
if (desc.MemberInfo is FieldInfo)
{
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("persistinfo is a field ref");
}
CodeFieldReferenceExpression fieldRef = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
rightExpr = fieldRef;
added = true;
}
// static property ref
else if (desc.MemberInfo is PropertyInfo)
{
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("persistinfo is a property ref");
}
CodePropertyReferenceExpression propRef = new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
rightExpr = propRef;
added = true;
}
// static method invoke
//
else
{
object[] args = new object[desc.Arguments.Count];
desc.Arguments.CopyTo(args, 0);
CodeExpression[] expressions = new CodeExpression[args.Length];
if (desc.MemberInfo is MethodInfo)
{
MethodInfo mi = (MethodInfo)desc.MemberInfo;
ParameterInfo[] parameters = mi.GetParameters();
for (int i = 0; i < args.Length; i++)
{
expressions[i] = GenerateExpressionForValue(null, args[i], parameters[i].ParameterType);
}
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("persistinfo is a method invoke");
}
CodeMethodInvokeExpression methCall = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
foreach (CodeExpression e in expressions)
{
methCall.Parameters.Add(e);
}
rightExpr = methCall;
added = true;
}
else if (desc.MemberInfo is ConstructorInfo)
{
ConstructorInfo ci = (ConstructorInfo)desc.MemberInfo;
ParameterInfo[] parameters = ci.GetParameters();
for (int i = 0; i < args.Length; i++)
{
expressions[i] = GenerateExpressionForValue(null, args[i], parameters[i].ParameterType);
}
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("persistinfo is a constructor call");
}
CodeObjectCreateExpression objectCreate = new CodeObjectCreateExpression(desc.MemberInfo.DeclaringType.FullName);
foreach (CodeExpression e in expressions)
{
objectCreate.Parameters.Add(e);
}
rightExpr = objectCreate;
added = true;
}
}
}
}
if (!added)
{
#if DEBUG
if (WebFormsCompilation.Enabled)
{
Debug.WriteLine("unabled to determine type, attempting Parse");
Debug.Indent();
Debug.WriteLine("value.GetType == " + value.GetType().FullName);
Debug.WriteLine("value.ToString == " + value.ToString());
Debug.WriteLine("valueType == " + valueType.FullName);
if (propertyInfo != null)
{
Debug.WriteLine("propertyInfo == " + propertyInfo.ReflectedType.FullName + "." + propertyInfo.Name + " : " + propertyInfo.PropertyType.FullName);
}
else
{
Debug.WriteLine("propertyInfo == (null)");
}
Debug.Unindent();
}
#endif // DEBUG
// Not a known type: try calling Parse
// If possible, pass it an InvariantCulture (ASURT 79412)
if (valueType.GetMethod("Parse", new Type[] { typeof(string), typeof(CultureInfo) }) != null)
{
CodeMethodInvokeExpression methCall = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(valueType.FullName), "Parse");
// Convert the object to a string.
// If we have a type converter, use it to convert to a string in a culture
// invariant way (ASURT 87094)
string s;
if (converter != null)
{
s = converter.ConvertToInvariantString(value);
}
else
{
s = value.ToString();
}
methCall.Parameters.Add(new CodePrimitiveExpression(s));
methCall.Parameters.Add(new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(CultureInfo)), "InvariantCulture"));
rightExpr = methCall;
}
else if (valueType.GetMethod("Parse", new Type[] { typeof(string) }) != null)
{
// Otherwise, settle for passing just the string
CodeMethodInvokeExpression methCall = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(valueType.FullName), "Parse");
methCall.Parameters.Add(new CodePrimitiveExpression(value.ToString()));
rightExpr = methCall;
}
else
{
throw new HttpException(SR.GetString(SR.CantGenPropertySet, propertyInfo.Name, valueType.FullName));
}
}
}
#if DEBUG
if (WebFormsCompilation.Enabled)
{
Debug.Unindent();
Debug.WriteLine("}");
}
#endif // DEBUG
return(rightExpr);
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
CodeNamespace nspace = new CodeNamespace ("NSPC");
nspace.Imports.Add (new CodeNamespaceImport ("System"));
cu.Namespaces.Add (nspace);
cu.ReferencedAssemblies.Add ("System.Windows.Forms.dll");
CodeTypeDeclaration cd = new CodeTypeDeclaration ("TestingClass");
cd.IsClass = true;
nspace.Types.Add (cd);
CodeMemberMethod cmm;
CodeMethodInvokeExpression methodinvoke;
// GENERATES (C#):
// public int CallingPublicNestedScenario(int i) {
// PublicNestedClassA.PublicNestedClassB2.PublicNestedClassC t =
// new PublicNestedClassA.PublicNestedClassB2.PublicNestedClassC();
// return t.publicNestedClassesMethod(i);
// }
if (Supports (provider, GeneratorSupport.NestedTypes)) {
AddScenario ("CheckCallingPublicNestedScenario");
cmm = new CodeMemberMethod ();
cmm.Name = "CallingPublicNestedScenario";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
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 CodeArgumentReferenceExpression ("i"))));
cd.Members.Add (cmm);
AddScenario ("CheckCallingPrivateNestedScenario");
cmm = new CodeMemberMethod ();
cmm.Name = "CallingPrivateNestedScenario";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference
("PrivateNestedClassA"), "t",
new CodeObjectCreateExpression (new CodeTypeReference ("PrivateNestedClassA"))));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("t"),
"TestPrivateNestedClass",
new CodeArgumentReferenceExpression ("i"))));
cd.Members.Add (cmm);
}
// GENERATES (C#):
// public int CallingAbstractScenario(int i) {
// InheritAbstractClass t = new InheritAbstractClass();
// return t.AbstractMethod(i);
// }
AddScenario ("CheckCallingAbstractScenario");
cmm = new CodeMemberMethod ();
cmm.Name = "CallingAbstractScenario";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement ("InheritAbstractClass", "t", new CodeObjectCreateExpression ("InheritAbstractClass")));
methodinvoke = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("t"), "AbstractMethod");
methodinvoke.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
cmm.Statements.Add (new CodeMethodReturnStatement (methodinvoke));
cd.Members.Add (cmm);
if (Supports (provider, GeneratorSupport.DeclareInterfaces)) {
// testing multiple interface implementation class
// GENERATES (C#):
// public int TestMultipleInterfaces(int i) {
// TestMultipleInterfaceImp t = new TestMultipleInterfaceImp();
// InterfaceA interfaceAobject = ((InterfaceA)(t));
// InterfaceB interfaceBobject = ((InterfaceB)(t));
// return (interfaceAobject.InterfaceMethod(i) - interfaceBobject.InterfaceMethod(i));
// }
if (Supports (provider, GeneratorSupport.MultipleInterfaceMembers)) {
cmm = new CodeMemberMethod();
cmm.Name = "TestMultipleInterfaces";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
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 CodeArgumentReferenceExpression("i"));
CodeMethodInvokeExpression methodinvoke2 = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("interfaceBobject")
, "InterfaceMethod");
methodinvoke2.Parameters.Add(new CodeArgumentReferenceExpression("i"));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
methodinvoke ,
CodeBinaryOperatorType.Subtract, methodinvoke2)));
cd.Members.Add(cmm);
}
// testing single interface implementation
// GENERATES (C#):
// public int TestSingleInterface(int i) {
// TestMultipleInterfaceImp t = new TestMultipleInterfaceImp();
// return t.InterfaceMethod(i);
// }
AddScenario ("CheckTestSingleInterface");
cmm = new CodeMemberMethod ();
cmm.Name = "TestSingleInterface";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement ("TestSingleInterfaceImp", "t", new CodeObjectCreateExpression ("TestSingleInterfaceImp")));
methodinvoke = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("t")
, "InterfaceMethod");
methodinvoke.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
cmm.Statements.Add (new CodeMethodReturnStatement (methodinvoke));
cd.Members.Add (cmm);
}
// similar to the 'new' test, write a method to complete testing of the 'override' scenario
// GENERATES (C#):
// public int CallingOverrideScenario(int i) {
// ClassWVirtualMethod t = new ClassWOverrideMethod();
// return t.VirtualMethod(i);
// }
AddScenario ("CheckCallingOverrideScenario");
cmm = new CodeMemberMethod ();
cmm.Name = "CallingOverrideScenario";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement ("ClassWVirtualMethod", "t", new CodeCastExpression(new CodeTypeReference("ClassWVirtualMethod"), new CodeObjectCreateExpression ("ClassWOverrideMethod"))));
methodinvoke = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("t"), "VirtualMethod");
methodinvoke.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
cmm.Statements.Add (new CodeMethodReturnStatement (methodinvoke));
cd.Members.Add (cmm);
// declare a base class
// GENERATES (C#):
// public class ClassWVirtualMethod {
// public virtual int VirtualMethod(int a) {
// return a;
// }
// }
cd = new CodeTypeDeclaration ("ClassWVirtualMethod");
cd.IsClass = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "VirtualMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
cd.Members.Add (cmm);
// inherit the base class
// GENERATES (C#):
// public class ClassWMethod : ClassWVirtualMethod {
// }
cd = new CodeTypeDeclaration ("ClassWMethod");
cd.BaseTypes.Add (new CodeTypeReference ("ClassWVirtualMethod"));
cd.IsClass = true;
nspace.Types.Add (cd);
// inheritance the base class with override method
// GENERATES (C#):
// public class ClassWOverrideMethod : ClassWVirtualMethod {
// public override int VirtualMethod(int a) {
// return (2 * a);
// }
// }
cd = new CodeTypeDeclaration ("ClassWOverrideMethod");
cd.BaseTypes.Add (new CodeTypeReference ("ClassWVirtualMethod"));
cd.IsClass = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "VirtualMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
new CodePrimitiveExpression (2), CodeBinaryOperatorType.Multiply
, new CodeArgumentReferenceExpression ("a"))));
cd.Members.Add (cmm);
if (Supports (provider, GeneratorSupport.DeclareInterfaces)) {
// ******** implement a single public interface ***********
// declare an interface
// GENERATES (C#):
// public interface InterfaceA {
// int InterfaceMethod(int a);
// }
cd = new CodeTypeDeclaration ("InterfaceA");
cd.IsInterface = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Attributes = MemberAttributes.Public;
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cd.Members.Add (cmm);
// implement the interface
// GENERATES (C#):
// public class TestSingleInterfaceImp : InterfaceA {
// public virtual int InterfaceMethod(int a) {
// return a;
// }
// }
cd = new CodeTypeDeclaration ("TestSingleInterfaceImp");
cd.BaseTypes.Add (new CodeTypeReference ("System.Object"));
cd.BaseTypes.Add (new CodeTypeReference ("InterfaceA"));
cd.IsClass = true;
nspace.Types.Add (cd);
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 CodeArgumentReferenceExpression ("a")));
cd.Members.Add (cmm);
// ********implement two interfaces with overloading method name*******
// declare the second interface
// GENERATES (C#):
// public interface InterfaceB {
// int InterfaceMethod(int a);
// }
cd = new CodeTypeDeclaration ("InterfaceB");
cd.IsInterface = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "InterfaceMethod";
cmm.Attributes = MemberAttributes.Public;
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cd.Members.Add (cmm);
// implement both of the interfaces
// GENERATES (C#):
// public class TestMultipleInterfaceImp : InterfaceB, InterfaceA {
// public int InterfaceMethod(int a) {
// return a;
// }
// }
if (Supports (provider, GeneratorSupport.MultipleInterfaceMembers)) {
AddScenario ("CheckTestMultipleInterfaces");
cd = new CodeTypeDeclaration ("TestMultipleInterfaceImp");
cd.BaseTypes.Add (new CodeTypeReference ("System.Object"));
cd.BaseTypes.Add (new CodeTypeReference ("InterfaceB"));
cd.BaseTypes.Add (new CodeTypeReference ("InterfaceA"));
cd.IsClass = true;
nspace.Types.Add (cd);
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 CodeArgumentReferenceExpression ("a")));
cd.Members.Add (cmm);
}
}
if (Supports (provider, GeneratorSupport.NestedTypes)) {
// *********** public nested classes *************************
// GENERATES (C#):
// public class PublicNestedClassA {
// public class PublicNestedClassB1 {
// }
// public class PublicNestedClassB2 {
// public class PublicNestedClassC {
// public int publicNestedClassesMethod(int a) {
// return a;
// }
// }
// }
// }
cd = new CodeTypeDeclaration ("PublicNestedClassA");
cd.IsClass = true;
nspace.Types.Add (cd);
CodeTypeDeclaration nestedClass = new CodeTypeDeclaration ("PublicNestedClassB1");
nestedClass.IsClass = true;
nestedClass.TypeAttributes = TypeAttributes.NestedPublic;
cd.Members.Add (nestedClass);
nestedClass = new CodeTypeDeclaration ("PublicNestedClassB2");
nestedClass.TypeAttributes = TypeAttributes.NestedPublic;
nestedClass.IsClass = true;
cd.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 CodeArgumentReferenceExpression ("a")));
innerNestedClass.Members.Add (cmm);
// *********** private nested classes *************************
// GENERATES (C#):
// public class PrivateNestedClassA {
// public int TestPrivateNestedClass(int i) {
// return PrivateNestedClassB.PrivateNestedClassesMethod(i);
// }
// private class PrivateNestedClassB {
// public int PrivateNestedClassesMethod(int a) {
// return a;
// }
// }
// }
cd = new CodeTypeDeclaration ("PrivateNestedClassA");
cd.IsClass = true;
nspace.Types.Add (cd);
AddScenario ("CantFindPrivateNestedClass");
nestedClass = new CodeTypeDeclaration ("PrivateNestedClassB");
nestedClass.IsClass = true;
nestedClass.TypeAttributes = TypeAttributes.NestedPrivate;
cd.Members.Add (nestedClass);
cmm = new CodeMemberMethod ();
cmm.Name = "PrivateNestedClassesMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
nestedClass.Members.Add (cmm);
// test private, nested classes
cmm = new CodeMemberMethod ();
cmm.Name = "TestPrivateNestedClass";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference ("PrivateNestedClassB"),
"objB"));
cmm.Statements.Add (new CodeAssignStatement (new CodeVariableReferenceExpression ("objB"),
new CodeObjectCreateExpression (new CodeTypeReference ("PrivateNestedClassB"))));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeMethodInvokeExpression (new
CodeVariableReferenceExpression ("objB"), "PrivateNestedClassesMethod", new
CodeArgumentReferenceExpression ("i"))));
cd.Members.Add (cmm);
}
// ************ abstract class ***************
// GENERATES (C#):
// public abstract class AbstractClass {
// public abstract int AbstractMethod(int i);
// }
// public class InheritAbstractClass : AbstractClass {
//
// public override int AbstractMethod(int i) {
// return i;
// }
// }
AddScenario ("TestAbstractAttributes");
cd = new CodeTypeDeclaration ("AbstractClass");
cd.TypeAttributes = TypeAttributes.Abstract | TypeAttributes.Public;
cd.IsClass = true;
nspace.Types.Add (cd);
CodeTypeDeclaration inheritAbstractClass = new CodeTypeDeclaration ("InheritAbstractClass");
inheritAbstractClass.IsClass = true;
inheritAbstractClass.BaseTypes.Add (new CodeTypeReference ("AbstractClass"));
nspace.Types.Add (inheritAbstractClass);
cmm = new CodeMemberMethod ();
cmm.Name = "AbstractMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Abstract;
cd.Members.Add (cmm);
cmm = new CodeMemberMethod ();
cmm.Name = "AbstractMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("i")));
inheritAbstractClass.Members.Add (cmm);
// ************ sealed class *****************
// GENERATES (C#):
// sealed class SealedClass {
// public int SealedClassMethod(int i) {
// return i;
// }
// }
AddScenario ("TestSealedAttributes");
cd = new CodeTypeDeclaration ("SealedClass");
cd.IsClass = true;
cd.TypeAttributes = TypeAttributes.Sealed;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "SealedClassMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("i")));
cd.Members.Add (cmm);
// ************* class with custom attributes ********************
// GENERATES (C#):
// [System.Obsolete("Don\'t use this Class")]
// [System.Windows.Forms.AxHost.ClsidAttribute("Class.ID")]
// public class ClassWCustomAttributes {
// }
cd = new CodeTypeDeclaration ("ClassWCustomAttributes");
cd.IsClass = true;
AddScenario ("FindObsoleteAttribute");
cd.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Class"))));
AddScenario ("FindOtherAttribute");
cd.CustomAttributes.Add (new CodeAttributeDeclaration (typeof (System.Windows.Forms.AxHost.ClsidAttribute).FullName,
new CodeAttributeArgument (new CodePrimitiveExpression ("Class.ID"))));
nspace.Types.Add (cd);
}
CodeMemberMethod GenerateMethod(CodeIdentifiers memberIds, SoapOperationBinding soapOper, SoapBodyBinding bodyBinding, XmlMembersMapping inputMembers, XmlMembersMapping outputMembers)
{
CodeIdentifiers pids = new CodeIdentifiers();
CodeMemberMethod method = new CodeMemberMethod();
CodeMemberMethod methodBegin = new CodeMemberMethod();
CodeMemberMethod methodEnd = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public | MemberAttributes.Final;
methodBegin.Attributes = MemberAttributes.Public | MemberAttributes.Final;
methodEnd.Attributes = MemberAttributes.Public | MemberAttributes.Final;
SoapBindingStyle style = soapOper.Style != SoapBindingStyle.Default ? soapOper.Style : soapBinding.Style;
// Find unique names for temporary variables
for (int n = 0; n < inputMembers.Count; n++)
{
pids.AddUnique(inputMembers[n].MemberName, inputMembers[n]);
}
if (outputMembers != null)
{
for (int n = 0; n < outputMembers.Count; n++)
{
pids.AddUnique(outputMembers[n].MemberName, outputMembers[n]);
}
}
string varAsyncResult = pids.AddUnique("asyncResult", "asyncResult");
string varResults = pids.AddUnique("results", "results");
string varCallback = pids.AddUnique("callback", "callback");
string varAsyncState = pids.AddUnique("asyncState", "asyncState");
string messageName = memberIds.AddUnique(CodeIdentifier.MakeValid(Operation.Name), method);
method.Name = CodeIdentifier.MakeValid(Operation.Name);
if (method.Name == ClassName)
{
method.Name += "1";
}
methodBegin.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("Begin" + method.Name), method);
methodEnd.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("End" + method.Name), method);
method.ReturnType = new CodeTypeReference(typeof(void));
methodEnd.ReturnType = new CodeTypeReference(typeof(void));
methodEnd.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IAsyncResult), varAsyncResult));
CodeExpression[] paramArray = new CodeExpression [inputMembers.Count];
CodeParameterDeclarationExpression[] outParams = new CodeParameterDeclarationExpression [outputMembers != null ? outputMembers.Count : 0];
for (int n = 0; n < inputMembers.Count; n++)
{
CodeParameterDeclarationExpression param = GenerateParameter(inputMembers[n], FieldDirection.In);
method.Parameters.Add(param);
GenerateMemberAttributes(inputMembers, inputMembers[n], bodyBinding.Use, param);
methodBegin.Parameters.Add(GenerateParameter(inputMembers[n], FieldDirection.In));
paramArray [n] = new CodeVariableReferenceExpression(param.Name);
}
if (outputMembers != null)
{
bool hasReturn = false;
for (int n = 0; n < outputMembers.Count; n++)
{
CodeParameterDeclarationExpression cpd = GenerateParameter(outputMembers[n], FieldDirection.Out);
outParams [n] = cpd;
bool found = false;
foreach (CodeParameterDeclarationExpression ip in method.Parameters)
{
if (ip.Name == cpd.Name && ip.Type.BaseType == cpd.Type.BaseType)
{
ip.Direction = FieldDirection.Ref;
methodEnd.Parameters.Add(GenerateParameter(outputMembers[n], FieldDirection.Out));
found = true;
break;
}
}
if (found)
{
continue;
}
if (!hasReturn)
{
hasReturn = true;
method.ReturnType = cpd.Type;
methodEnd.ReturnType = cpd.Type;
GenerateReturnAttributes(outputMembers, outputMembers[n], bodyBinding.Use, method);
outParams [n] = null;
continue;
}
method.Parameters.Add(cpd);
GenerateMemberAttributes(outputMembers, outputMembers[n], bodyBinding.Use, cpd);
methodEnd.Parameters.Add(GenerateParameter(outputMembers[n], FieldDirection.Out));
}
}
methodBegin.Parameters.Add(new CodeParameterDeclarationExpression(typeof(AsyncCallback), varCallback));
methodBegin.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), varAsyncState));
methodBegin.ReturnType = new CodeTypeReference(typeof(IAsyncResult));
// Array of input parameters
CodeArrayCreateExpression methodParams;
if (paramArray.Length > 0)
{
methodParams = new CodeArrayCreateExpression(typeof(object), paramArray);
}
else
{
methodParams = new CodeArrayCreateExpression(typeof(object), 0);
}
// Assignment of output parameters
CodeStatementCollection outAssign = new CodeStatementCollection();
CodeVariableReferenceExpression arrVar = new CodeVariableReferenceExpression(varResults);
for (int n = 0; n < outParams.Length; n++)
{
CodeExpression index = new CodePrimitiveExpression(n);
if (outParams[n] == null)
{
CodeExpression res = new CodeCastExpression(method.ReturnType, new CodeArrayIndexerExpression(arrVar, index));
outAssign.Add(new CodeMethodReturnStatement(res));
}
else
{
CodeExpression res = new CodeCastExpression(outParams[n].Type, new CodeArrayIndexerExpression(arrVar, index));
CodeExpression var = new CodeVariableReferenceExpression(outParams[n].Name);
outAssign.Insert(0, new CodeAssignStatement(var, res));
}
}
if (Style == ServiceDescriptionImportStyle.Client)
{
// Invoke call
CodeThisReferenceExpression ethis = new CodeThisReferenceExpression();
CodePrimitiveExpression varMsgName = new CodePrimitiveExpression(messageName);
CodeMethodInvokeExpression inv;
CodeVariableDeclarationStatement dec;
inv = new CodeMethodInvokeExpression(ethis, "Invoke", varMsgName, methodParams);
if (outputMembers != null && outputMembers.Count > 0)
{
dec = new CodeVariableDeclarationStatement(typeof(object[]), varResults, inv);
method.Statements.Add(dec);
method.Statements.AddRange(outAssign);
}
else
{
method.Statements.Add(inv);
}
// Begin Invoke Call
CodeExpression expCallb = new CodeVariableReferenceExpression(varCallback);
CodeExpression expAsyncs = new CodeVariableReferenceExpression(varAsyncState);
inv = new CodeMethodInvokeExpression(ethis, "BeginInvoke", varMsgName, methodParams, expCallb, expAsyncs);
methodBegin.Statements.Add(new CodeMethodReturnStatement(inv));
// End Invoke call
CodeExpression varAsyncr = new CodeVariableReferenceExpression(varAsyncResult);
inv = new CodeMethodInvokeExpression(ethis, "EndInvoke", varAsyncr);
if (outputMembers != null && outputMembers.Count > 0)
{
dec = new CodeVariableDeclarationStatement(typeof(object[]), varResults, inv);
methodEnd.Statements.Add(dec);
methodEnd.Statements.AddRange(outAssign);
}
else
{
methodEnd.Statements.Add(inv);
}
}
else
{
method.Attributes = MemberAttributes.Public | MemberAttributes.Abstract;
}
// Attributes
ImportHeaders(method);
CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Web.Services.WebMethodAttribute");
if (messageName != method.Name)
{
att.Arguments.Add(GetArg("MessageName", messageName));
}
AddCustomAttribute(method, att, (Style == ServiceDescriptionImportStyle.Server));
if (style == SoapBindingStyle.Rpc)
{
att = new CodeAttributeDeclaration("System.Web.Services.Protocols.SoapRpcMethodAttribute");
att.Arguments.Add(GetArg(soapOper.SoapAction));
if (inputMembers.ElementName != method.Name)
{
att.Arguments.Add(GetArg("RequestElementName", inputMembers.ElementName));
}
if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response"))
{
att.Arguments.Add(GetArg("ResponseElementName", outputMembers.ElementName));
}
att.Arguments.Add(GetArg("RequestNamespace", inputMembers.Namespace));
if (outputMembers != null)
{
att.Arguments.Add(GetArg("ResponseNamespace", outputMembers.Namespace));
}
if (outputMembers == null)
{
att.Arguments.Add(GetArg("OneWay", true));
}
}
else
{
if (outputMembers != null && (inputMembers.ElementName == "" && outputMembers.ElementName != "" ||
inputMembers.ElementName != "" && outputMembers.ElementName == ""))
{
throw new InvalidOperationException("Parameter style is not the same for the input message and output message");
}
att = new CodeAttributeDeclaration("System.Web.Services.Protocols.SoapDocumentMethodAttribute");
att.Arguments.Add(GetArg(soapOper.SoapAction));
if (inputMembers.ElementName != "")
{
if (inputMembers.ElementName != method.Name)
{
att.Arguments.Add(GetArg("RequestElementName", inputMembers.ElementName));
}
if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response"))
{
att.Arguments.Add(GetArg("ResponseElementName", outputMembers.ElementName));
}
att.Arguments.Add(GetArg("RequestNamespace", inputMembers.Namespace));
if (outputMembers != null)
{
att.Arguments.Add(GetArg("ResponseNamespace", outputMembers.Namespace));
}
att.Arguments.Add(GetEnumArg("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Wrapped"));
}
else
{
att.Arguments.Add(GetEnumArg("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Bare"));
}
if (outputMembers == null)
{
att.Arguments.Add(GetArg("OneWay", true));
}
att.Arguments.Add(GetEnumArg("Use", "System.Web.Services.Description.SoapBindingUse", bodyBinding.Use.ToString()));
}
AddCustomAttribute(method, att, true);
CodeTypeDeclaration.Members.Add(method);
if (Style == ServiceDescriptionImportStyle.Client)
{
CodeTypeDeclaration.Members.Add(methodBegin);
CodeTypeDeclaration.Members.Add(methodEnd);
}
return(method);
}
private static CodeMemberMethod CreateEventAsyncMethod(ServiceContractGenerationContext context, CodeTypeDeclaration clientType, string syncMethodName, CodeMemberMethod beginMethod, CodeMemberField beginOperationDelegate, CodeMemberMethod beginOperationMethod, CodeMemberField endOperationDelegate, CodeMemberMethod endOperationMethod, CodeMemberField operationCompletedDelegate, CodeMemberMethod operationCompletedMethod)
{
CodeMemberMethod nameCollection = new CodeMemberMethod();
nameCollection.Name = NamingHelper.GetUniqueName(GetEventAsyncMethodName(syncMethodName), new NamingHelper.DoesNameExist(ClientClassGenerator.DoesMethodNameExist), context.Operations);
nameCollection.Attributes = MemberAttributes.Public | MemberAttributes.Final;
nameCollection.ReturnType = new CodeTypeReference(voidType);
CodeArrayCreateExpression expression = new CodeArrayCreateExpression(new CodeTypeReference(objectArrayType), new CodeExpression[0]);
for (int i = 0; i < (beginMethod.Parameters.Count - 2); i++)
{
CodeParameterDeclarationExpression expression2 = beginMethod.Parameters[i];
CodeParameterDeclarationExpression expression3 = new CodeParameterDeclarationExpression(expression2.Type, expression2.Name);
expression3.Direction = FieldDirection.In;
nameCollection.Parameters.Add(expression3);
expression.Initializers.Add(new CodeVariableReferenceExpression(expression3.Name));
}
string name = NamingHelper.GetUniqueName("userState", new NamingHelper.DoesNameExist(ClientClassGenerator.DoesParameterNameExist), nameCollection);
nameCollection.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(objectType), name));
nameCollection.Statements.Add(CreateDelegateIfNotNull(beginOperationDelegate, beginOperationMethod));
nameCollection.Statements.Add(CreateDelegateIfNotNull(endOperationDelegate, endOperationMethod));
nameCollection.Statements.Add(CreateDelegateIfNotNull(operationCompletedDelegate, operationCompletedMethod));
CodeMethodInvokeExpression expression4 = new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), invokeAsyncMethodName, new CodeExpression[0]);
expression4.Parameters.Add(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), beginOperationDelegate.Name));
if (expression.Initializers.Count > 0)
{
expression4.Parameters.Add(expression);
}
else
{
expression4.Parameters.Add(new CodePrimitiveExpression(null));
}
expression4.Parameters.Add(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), endOperationDelegate.Name));
expression4.Parameters.Add(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), operationCompletedDelegate.Name));
expression4.Parameters.Add(new CodeVariableReferenceExpression(name));
nameCollection.Statements.Add(new CodeExpressionStatement(expression4));
clientType.Members.Add(nameCollection);
return nameCollection;
}
public virtual CodeMemberMethod WriteHandlerFilter(TemplateContext ctx, CodeMemberMethod handlerMethod)
{
var handlerFilterMethod = ctx.CurrentDeclaration.protected_func(typeof(void), HandlerFilterMethodName);
if (!IsSystemEvent) // No event data for system events
{
handlerFilterMethod.Parameters.Add(new CodeParameterDeclarationExpression(EventType, "data"));
}
ctx.PushStatements(handlerFilterMethod.Statements);
if (!IsLoop)
{
var handlerInvoker = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), HandlerMethodName);
//
if (!IsSystemEvent)
{
handlerInvoker.Parameters.Add(new CodeSnippetExpression("data"));
}
foreach (var item in FilterInputs)
{
var filter = item.FilterNode;
if (filter == null)
{
continue;
}
handlerInvoker.Parameters.Add(new CodeSnippetExpression(filter.GetContextItemName(item.Name)));
ctx._("var {0} = {1}", filter.GetContextItemName(item.Name),
filter.MatchAndSelect("data." + item.MappingId));
ctx._if("{0} == null", filter.GetContextItemName(item.Name)).TrueStatements._("return");
ctx._if("!{0}.Enabled", filter.GetContextItemName(item.Name)).TrueStatements._("return");
}
WriteHandlerInvoker(handlerInvoker, handlerFilterMethod);
ctx.CurrentStatements.Add(handlerInvoker);
}
else
{
var handlerInvoker = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), HandlerMethodName);
if (!IsSystemEvent)
{
handlerInvoker.Parameters.Add(new CodeSnippetExpression("data"));
}
if (this.EntityGroup.Item != null)
{
var item = this.BeginWriteLoop(ctx, this.EntityGroup.Item);
ctx._if("!{0}.Enabled", item).TrueStatements._("continue");
handlerInvoker.Parameters.Add(new CodeSnippetExpression(item));
ctx.CurrentStatements.Add(handlerInvoker);
this.EndWriteLoop(ctx);
}
else
{
ctx.CurrentStatements.Add(handlerInvoker);
}
}
ctx.PopStatements();
return(handlerFilterMethod);
}
private static CodeMemberMethod GenerateHelperMethod(CodeTypeReference ifaceType, CodeMemberMethod method)
{
CodeMemberMethod helperMethod = new CodeMemberMethod();
helperMethod.Name = method.Name;
helperMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeCastExpression(ifaceType, new CodeThisReferenceExpression()), method.Name), new CodeExpression[0]);
bool flag = false;
foreach (CodeParameterDeclarationExpression expression2 in method.Parameters)
{
CodeTypeDeclaration codeType = ServiceContractGenerator.NamespaceHelper.GetCodeType(expression2.Type);
if (codeType != null)
{
flag = true;
CodeVariableReferenceExpression expression3 = new CodeVariableReferenceExpression("inValue");
helperMethod.Statements.Add(new CodeVariableDeclarationStatement(expression2.Type, expression3.VariableName, new CodeObjectCreateExpression(expression2.Type, new CodeExpression[0])));
expression.Parameters.Add(expression3);
GenerateParameters(helperMethod, codeType, expression3, FieldDirection.In);
}
else
{
helperMethod.Parameters.Add(new CodeParameterDeclarationExpression(expression2.Type, expression2.Name));
expression.Parameters.Add(new CodeArgumentReferenceExpression(expression2.Name));
}
}
if (method.ReturnType.BaseType == voidTypeRef.BaseType)
{
helperMethod.Statements.Add(expression);
}
else
{
CodeTypeDeclaration codeTypeDeclaration = ServiceContractGenerator.NamespaceHelper.GetCodeType(method.ReturnType);
if (codeTypeDeclaration != null)
{
flag = true;
CodeVariableReferenceExpression target = new CodeVariableReferenceExpression("retVal");
helperMethod.Statements.Add(new CodeVariableDeclarationStatement(method.ReturnType, target.VariableName, expression));
CodeMethodReturnStatement statement = GenerateParameters(helperMethod, codeTypeDeclaration, target, FieldDirection.Out);
if (statement != null)
{
helperMethod.Statements.Add(statement);
}
}
else
{
helperMethod.Statements.Add(new CodeMethodReturnStatement(expression));
helperMethod.ReturnType = method.ReturnType;
}
}
if (flag)
{
method.PrivateImplementationType = ifaceType;
}
if (!flag)
{
return null;
}
return helperMethod;
}
protected virtual void WriteHandlerInvoker(CodeMethodInvokeExpression handlerInvoker, CodeMemberMethod handlerFilterMethod)
{
// If its a system event then there isn't any event data
}
private static CodeMemberMethod CreateBeginOperationMethod(ServiceContractGenerationContext context, CodeTypeDeclaration clientType, string syncMethodName, CodeMemberMethod beginMethod)
{
CodeMemberMethod method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Private;
method.ReturnType = new CodeTypeReference(asyncResultType);
method.Name = NamingHelper.GetUniqueName(GetBeginOperationMethodName(syncMethodName), new NamingHelper.DoesNameExist(ClientClassGenerator.DoesMethodNameExist), context.Operations);
CodeParameterDeclarationExpression expression = new CodeParameterDeclarationExpression();
expression.Type = new CodeTypeReference(objectArrayType);
expression.Name = NamingHelper.GetUniqueName("inValues", new NamingHelper.DoesNameExist(ClientClassGenerator.DoesParameterNameExist), beginMethod);
method.Parameters.Add(expression);
CodeMethodInvokeExpression expression2 = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), beginMethod.Name, new CodeExpression[0]);
CodeExpression targetObject = new CodeVariableReferenceExpression(expression.Name);
for (int i = 0; i < (beginMethod.Parameters.Count - 2); i++)
{
CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement();
statement.Type = beginMethod.Parameters[i].Type;
statement.Name = beginMethod.Parameters[i].Name;
statement.InitExpression = new CodeCastExpression(statement.Type, new CodeArrayIndexerExpression(targetObject, new CodeExpression[] { new CodePrimitiveExpression(i) }));
method.Statements.Add(statement);
expression2.Parameters.Add(new CodeDirectionExpression(beginMethod.Parameters[i].Direction, new CodeVariableReferenceExpression(statement.Name)));
}
for (int j = beginMethod.Parameters.Count - 2; j < beginMethod.Parameters.Count; j++)
{
method.Parameters.Add(new CodeParameterDeclarationExpression(beginMethod.Parameters[j].Type, beginMethod.Parameters[j].Name));
expression2.Parameters.Add(new CodeVariableReferenceExpression(beginMethod.Parameters[j].Name));
}
method.Statements.Add(new CodeMethodReturnStatement(expression2));
clientType.Members.Add(method);
return method;
}
public override void BuildTree(CodeDomProvider provider, CodeCompileUnit cu)
{
CodeNamespace nspace = new CodeNamespace("NSPC");
cu.Namespaces.Add(nspace);
CodeTypeDeclaration class1 = new CodeTypeDeclaration("ClassWithField");
class1.IsClass = true;
nspace.Types.Add(class1);
// internal modifier
// public class ClassWithField {
// /*FamANDAssem*/ internal static int InternalField = 0;
// }
CodeMemberField field = new CodeMemberField();
field.Name = "InternalField";
field.Attributes = MemberAttributes.Assembly | MemberAttributes.Static;
field.Type = new CodeTypeReference(typeof(int));
field.InitExpression = new CodePrimitiveExpression(0);
class1.Members.Add(field);
class1 = new CodeTypeDeclaration("ClassToTest");
class1.IsClass = true;
nspace.Types.Add(class1);
// test internal field
// public static int UseInternalField(int i) {
// ClassWithField.InternalField = i;
// return ClassWithField.InternalField;
// }
AddScenario("CheckUseInternalField");
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = "UseInternalField";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i"));
cmm.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new
CodeTypeReferenceExpression("ClassWithField"), "InternalField"),
new CodeArgumentReferenceExpression("i")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new
CodeTypeReferenceExpression("ClassWithField"), "InternalField")));
class1.Members.Add(cmm);
// nested array reference
// public int MoreArrayTests(int i) {
// int[][] arrayOfArrays = new int[][] {
// new int[] {
// 3,
// 4},
// new int[1],
// new int[0]};
// return (arrayOfArrays[0][1] + i);
// }
// VB code provider doesn't support array of array initialization
if (Supports(provider, GeneratorSupport.ArraysOfArrays) && !(provider is VBCodeProvider))
{
AddScenario("CheckMoreArrayTests");
CodeMemberMethod secondMethod = new CodeMemberMethod();
secondMethod.Name = "MoreArrayTests";
secondMethod.Attributes = (secondMethod.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
secondMethod.ReturnType = new CodeTypeReference(typeof(int));
secondMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
// array of arrays
secondMethod.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 CodePrimitiveExpression(1)), new CodeArrayCreateExpression(typeof(int[])))));
secondMethod.Statements.Add(new CodeMethodReturnStatement(
new CodeBinaryOperatorExpression(new CodeArrayIndexerExpression(
new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("arrayOfArrays"), new CodePrimitiveExpression(0))
, new CodePrimitiveExpression(1)),
CodeBinaryOperatorType.Add, new CodeArgumentReferenceExpression("i"))));
class1.Members.Add(secondMethod);
}
// value and reference
if (Supports(provider, GeneratorSupport.ReferenceParameters))
{
// GENERATE (C#):
// static void Work(ref int i, out int j) {
// i = (i + 4);
// j = 5;
// }
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)));
class1.Members.Add(cmm);
// add a method that calls method work to verify that ref and out are working properly
// GENERATE (C#):
// public static int CallingWork(int a) {
// a = 10;
// int b;
// TEST.Work(ref a, out b);
// return (a + b);
// }
AddScenario("CheckCallingWork");
cmm = new CodeMemberMethod();
cmm.Name = "CallingWork";
cmm.Attributes = MemberAttributes.Public;
CodeParameterDeclarationExpression parames = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(parames);
cmm.ReturnType = new CodeTypeReference("System.Int32");
cmm.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("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("ClassToTest"), "Work"));
// add parameter with ref direction
CodeDirectionExpression parameter = new CodeDirectionExpression(FieldDirection.Ref,
new CodeArgumentReferenceExpression("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 CodeArgumentReferenceExpression("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression("b"))));
class1.Members.Add(cmm);
}
}
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 ("TEST");
cd.IsClass = true;
nspace.Types.Add (cd);
// GENERATES (C#):
// public int CallingOverrideScenario(int i) {
// ClassWVirtualMethod t = new ClassWOverrideMethod();
// return t.VirtualMethod(i);
// }
AddScenario ("Check1CallingOverrideScenario", "Check an overridden method.");
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "CallingOverrideScenario";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement ("ClassWVirtualMethod", "t", new CodeCastExpression(new CodeTypeReference("ClassWVirtualMethod"), new CodeObjectCreateExpression ("ClassWOverrideMethod"))));
CodeMethodInvokeExpression methodinvoke = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("t"), "VirtualMethod");
methodinvoke.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
cmm.Statements.Add (new CodeMethodReturnStatement (methodinvoke));
cd.Members.Add (cmm);
// declare a method without parameters
cmm = new CodeMemberMethod ();
cmm.Name = "NoParamsMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (16)));
cd.Members.Add (cmm);
// declare a method with multiple parameters
cmm = new CodeMemberMethod ();
cmm.Name = "MultipleParamsMethod";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "b"));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (new
CodeArgumentReferenceExpression ("a"), CodeBinaryOperatorType.Add,
new CodeArgumentReferenceExpression ("b"))));
cd.Members.Add (cmm);
// call method with no parameters, call a method with multiple parameters,
// and call a method from a method call
// public virtual int CallParamsMethods() {
// TEST t = new TEST();
// int val;
// val = t.NoParamsMethod ();
// return t.MultipleParamsMethod(78, val);
// }
AddScenario ("CheckCallParamsMethod", "Check CheckCallParamsMethod.");
cmm = new CodeMemberMethod ();
cmm.Name = "CallParamsMethods";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference ("TEST"), "t", new CodeObjectCreateExpression ("TEST")));
CodeVariableReferenceExpression cvre = new CodeVariableReferenceExpression (); //To increase code coverage
cvre.VariableName = "t";
CodeVariableReferenceExpression valCVRE = new CodeVariableReferenceExpression ();
valCVRE.VariableName = "val";
cmm.Statements.Add (new CodeVariableDeclarationStatement (typeof (int), "val"));
cmm.Statements.Add (new CodeAssignStatement (valCVRE,
CDHelper.CreateMethodInvoke (new CodeVariableReferenceExpression ("t"), "NoParamsMethod")));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeMethodInvokeExpression (cvre,
"MultipleParamsMethod", new CodePrimitiveExpression (78), valCVRE)));
cd.Members.Add (cmm);
// method to test the 'new' scenario by calling the 'new' method
// GENERATES (C#):
// public int CallingNewScenario(int i) {
// ClassWVirtualMethod t = new ClassWNewMethod();
// int x1;
// int x2;
// x1 = ((ClassWNewMethod)(t)).VirtualMethod(i);
// x2 = t.VirtualMethod(i);
// return (x1 - x2);
// }
AddScenario ("CheckCallingNewScenario", "Check CheckCallingNewScenario.");
cmm = new CodeMemberMethod ();
cmm.Name = "CallingNewScenario";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement ("ClassWVirtualMethod", "t", new CodeCastExpression(new CodeTypeReference("ClassWVirtualMethod"), new CodeObjectCreateExpression ("ClassWNewMethod"))));
cmm.Statements.Add (new CodeVariableDeclarationStatement (typeof (int), "x1"));
cmm.Statements.Add (new CodeVariableDeclarationStatement (typeof (int), "x2"));
methodinvoke = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("t"), "VirtualMethod");
methodinvoke.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
CodeMethodInvokeExpression methodinvoke2 = new CodeMethodInvokeExpression (new CodeCastExpression ("ClassWNewMethod", new
CodeVariableReferenceExpression ("t")), "VirtualMethod");
methodinvoke2.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
cmm.Statements.Add (new CodeAssignStatement (new CodeVariableReferenceExpression ("x1"),
methodinvoke2));
cmm.Statements.Add (new CodeAssignStatement (new CodeVariableReferenceExpression ("x2"),
methodinvoke));
cmm.Statements.Add (new CodeMethodReturnStatement (
CDHelper.CreateBinaryOperatorExpression ("x1", CodeBinaryOperatorType.Subtract, "x2")));
cd.Members.Add (cmm);
// ***************** declare method using new ******************
// first declare a class with a virtual method in it
// GENERATES (C#):
// public class ClassWVirtualMethod {
// public virtual int VirtualMethod(int a) {
// return a;
// }
// }
cd = new CodeTypeDeclaration ("ClassWVirtualMethod");
cd.IsClass = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "VirtualMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
cd.Members.Add (cmm);
// now declare a class that inherits from the previous class and has a 'new' method with the
// name VirtualMethod
// GENERATES (C#):
// public class ClassWNewMethod : ClassWVirtualMethod {
// public new virtual int VirtualMethod(int a) {
// return (2 * a);
// }
// }
cd = new CodeTypeDeclaration ("ClassWNewMethod");
cd.BaseTypes.Add (new CodeTypeReference ("ClassWVirtualMethod"));
cd.IsClass = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "VirtualMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.New;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
new CodePrimitiveExpression (2), CodeBinaryOperatorType.Multiply
, new CodeArgumentReferenceExpression ("a"))));
cd.Members.Add (cmm);
// now declare a class that inherits from the previous class and has a 'new' method with the
// name VirtualMethod
// GENERATES (C#):
// public class ClassWOverrideMethod : ClassWVirtualMethod {
// public override int VirtualMethod(int a) {
// return (2 * a);
// }
// }
cd = new CodeTypeDeclaration ("ClassWOverrideMethod");
cd.BaseTypes.Add (new CodeTypeReference ("ClassWVirtualMethod"));
cd.IsClass = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "VirtualMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
new CodePrimitiveExpression (2), CodeBinaryOperatorType.Multiply
, new CodeArgumentReferenceExpression ("a"))));
cd.Members.Add (cmm);
//*************** overload member function ****************
// new class which will include both functions
// GENERATES (C#):
// public class TEST7 {
// public int OverloadedMethod(int a) {
// return a;
// }
// public int OverloadedMethod(int a, int b) {
// return (b + a);
// }
// public int CallingOverloadedMethods(int i) {
// int one = OverloadedMethod(i, i);
// int two = OverloadedMethod(i);
// return (one - two);
// }
// }
AddScenario ("CheckTEST7.CallingOverloadedMethods", "Check CallingOverloadedMethods()");
cd = new CodeTypeDeclaration ("TEST7");
cd.IsClass = true;
nspace.Types.Add (cd);
cmm = new CodeMemberMethod ();
cmm.Name = "OverloadedMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
cd.Members.Add (cmm);
cmm = new CodeMemberMethod ();
cmm.Name = "OverloadedMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "a"));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "b"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("b"), CodeBinaryOperatorType.Add,
new CodeArgumentReferenceExpression ("a"))));
cd.Members.Add (cmm);
// declare a method that will call both OverloadedMethod functions
cmm = new CodeMemberMethod ();
cmm.Name = "CallingOverloadedMethods";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.Attributes = MemberAttributes.Public;
CodeMethodReferenceExpression methodref = new CodeMethodReferenceExpression ();
methodref.MethodName = "OverloadedMethod";
cmm.Statements.Add (new CodeVariableDeclarationStatement (typeof (int), "one",
new CodeMethodInvokeExpression (methodref, new
CodeArgumentReferenceExpression ("i"), new CodeArgumentReferenceExpression ("i"))));
cmm.Statements.Add (new CodeVariableDeclarationStatement (typeof (int), "two",
new CodeMethodInvokeExpression (methodref, new
CodeArgumentReferenceExpression ("i"))));
cmm.Statements.Add (new CodeMethodReturnStatement (
CDHelper.CreateBinaryOperatorExpression ("one", CodeBinaryOperatorType.Subtract, "two")));
cd.Members.Add (cmm);
// GENERATES (C#):
//
// namespace NSPC2 {
//
//
// public class TEST {
//
// public virtual int CallingOverrideScenario(int i) {
// NSPC.ClassWVirtualMethod t = new NSPC.ClassWOverrideMethod();
// return t.VirtualMethod(i);
// }
// }
// }
nspace = new CodeNamespace ("NSPC2");
cu.Namespaces.Add (nspace);
cd = new CodeTypeDeclaration ("TEST");
cd.IsClass = true;
nspace.Types.Add (cd);
AddScenario ("Check2CallingOverrideScenario", "Check CallingOverrideScenario()");
cmm = new CodeMemberMethod ();
cmm.Name = "CallingOverrideScenario";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement ("NSPC.ClassWVirtualMethod", "t", new CodeCastExpression(new CodeTypeReference("NSPC.ClassWVirtualMethod"), new CodeObjectCreateExpression ("NSPC.ClassWOverrideMethod"))));
methodinvoke = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("t"), "VirtualMethod");
methodinvoke.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
cmm.Statements.Add (new CodeMethodReturnStatement (methodinvoke));
cd.Members.Add (cmm);
}
private static void AddCreateTypeInstanceStatement(string typeToCreate, CodeCompileUnit ccu, CodeStatementCollection statements)
{
if (BinaryCompatibility.Current.TargetsAtLeastFramework472 && ccu != null)
{
/* Generate code like below
*
* IServiceProvider __activator = HttpRuntime.WebObjectActivator;
*
* //-- Generate code like this if default c-tor exists
* if (activator != null) {
* return activator.GetService(ctrlType);
* }
*
* // if default c-tor exists
* else {
* _ctrl = new ....
* }
* // if no default c-tor
* else {
* throw new InvalidOperationException(SR.GetString(SR.Could_not_create_type_instance, ctrlType))
* }
*
* //-- if default c-tor doesn't exist, assume dev wants to use DI.
* // if there is no default c-tor, you will get compilation error on framework 4.7.1 and below.
*/
var webObjectActivatorExpr = new CodePropertyReferenceExpression(new CodeTypeReferenceExpression("System.Web.HttpRuntime"), "WebObjectActivator");
statements.Add(new CodeVariableDeclarationStatement(typeof(IServiceProvider), "__activator"));
var activatorRefExpr = new CodeVariableReferenceExpression("__activator");
statements.Add(new CodeAssignStatement(activatorRefExpr, webObjectActivatorExpr));
var getServiceExpr = new CodeMethodInvokeExpression(activatorRefExpr, "GetService", new CodeTypeOfExpression(typeToCreate));
var createObjectStatement = new CodeConditionStatement()
{
Condition = new CodeBinaryOperatorExpression(activatorRefExpr,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null))
};
createObjectStatement.TrueStatements.Add(new CodeMethodReturnStatement(getServiceExpr));
// If default c-tor exists
if (DoesGeneratedCodeHaveDefaultCtor(typeToCreate, ccu))
{
var newObjectExpr = new CodeObjectCreateExpression(typeToCreate);
createObjectStatement.FalseStatements.Add(new CodeMethodReturnStatement(newObjectExpr));
}
else
{
var throwExceptionStatement = new CodeThrowExceptionStatement(new CodeObjectCreateExpression(
new CodeTypeReference(typeof(System.InvalidOperationException)),
new CodeExpression[] { new CodePrimitiveExpression(SR.GetString(SR.Could_not_create_type_instance, typeToCreate)) }));
createObjectStatement.FalseStatements.Add(throwExceptionStatement);
}
statements.Add(createObjectStatement);
}
else
{
// Generate new typeToCreate()
var newObjectExpression = new CodeObjectCreateExpression(typeToCreate);
statements.Add(new CodeMethodReturnStatement(newObjectExpression));
}
}
static void BuildState (State s, CodeMemberMethod method)
{
string methodName = String.Format ("State_{0}", stateCounter++);
CodeMemberMethod stateMethod = new CodeMemberMethod ();
stateMethod.Name = methodName;
MainClass.Members.Add (stateMethod);
CodeAssignStatement stateAssign = new CodeAssignStatement ();
stateAssign.Left = curState;
stateAssign.Right = new CodeCastExpression (stateType, curCountryLocation);
stateMethod.Statements.Add (stateAssign);
CodeMethodInvokeExpression methodCall = new CodeMethodInvokeExpression (
thisref,
methodName
);
method.Statements.Add (methodCall);
methodCall = new CodeMethodInvokeExpression (
curState,
"Add",
new CodeExpression[] {curStateLocation}
);
CodeMethodInvokeExpression locationAddDirect;
CodeObjectCreateExpression expr;
foreach (Element e in s.Locations) {
expr = BuildStateLocation (e, stateMethod);
if (expr == null)
stateMethod.Statements.Add (methodCall);
else {
locationAddDirect = new CodeMethodInvokeExpression (
curState,
"Add",
new CodeExpression[] {expr});
stateMethod.Statements.Add (locationAddDirect);
}
}
}
static CodeMemberMethod CreateMethod(string methodName, string defineName, ParameterInfo[] arguments, Type returnType) {
var callMethod = new CodeMemberMethod();
callMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
callMethod.Name = methodName;
callMethod.Parameters.AddRange(arguments.Select(a => new CodeParameterDeclarationExpression(a.ParameterType, a.Name)).ToArray());
callMethod.ReturnType = new CodeTypeReference(returnType);
var tcpClientRef = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), NameOfClientField);
var symbolNameRef = new CodeObjectCreateExpression(typeof(Symbol), new CodePrimitiveExpression(defineName));
var listBuilderParams = new List<CodeExpression>();
listBuilderParams.Add(symbolNameRef);
foreach (var arg in arguments) {
//**************************************************
//** TODO AT THIS LINE SHOULD BE THE SERIALIZER **
//**************************************************
if (BinFormater.IsPrimitive(arg.ParameterType) || IsNullablePrimitive(arg.ParameterType)) {
listBuilderParams.Add(new CodeArgumentReferenceExpression(arg.Name));
}
else {
listBuilderParams.Add(
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression(typeof(OSerializer))
, nameof(OSerializer.SerializeWithQuote))
, new CodeArgumentReferenceExpression(arg.Name)));
}
}
var consLst = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(Cons)), nameof(Cons.List), listBuilderParams.ToArray());
var invoke = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(tcpClientRef, nameof(ISomeClient.Call)), consLst);
// IS VOID METHOD
if (returnType == typeof(void)) {
callMethod.Statements.Add(invoke);
}
else {
const string requestResultVarName = "requestResult";
callMethod.Statements.Add(
new CodeVariableDeclarationStatement(typeof(object), requestResultVarName, invoke));
var requestResultRef = new CodeVariableReferenceExpression(requestResultVarName);
var eql = new CodeBinaryOperatorExpression(requestResultRef, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(null));
//****************************************************
//** TODO AT THIS LINE SHOULD BE THE DESERIALIZER **
//****************************************************
CodeExpression prepareResult = null;
if (BinFormater.IsPrimitive(returnType) || IsNullablePrimitive(returnType)) {
prepareResult = requestResultRef;
}
else {
prepareResult = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(OSerializer))
, nameof(OSerializer.Deserialize)
, new CodeCastExpression (typeof(Cons), requestResultRef)
, new CodeTypeOfExpression(returnType));
}
var castType = new CodeCastExpression(returnType, prepareResult);
CodeStatement returnDefaultValue = null;
if (returnType.IsValueType && Nullable.GetUnderlyingType(returnType) == null) {
returnDefaultValue = new CodeMethodReturnStatement(new CodeObjectCreateExpression(returnType));
}
else {
returnDefaultValue = new CodeMethodReturnStatement(new CodePrimitiveExpression(null));
}
var conditionalStatement = new CodeConditionStatement(eql, new[] {returnDefaultValue},
new[] {new CodeMethodReturnStatement(castType)});
callMethod.Statements.Add(conditionalStatement);
}
return callMethod;
}
static void BuildRegion (Region r, CodeMemberMethod method)
{
CodeObjectCreateExpression region =
new CodeObjectCreateExpression (regionType,
new CodeExpression[] {
new CodePrimitiveExpression (r.Name),
new CodePrimitiveExpression (r.Countries.Count)
});
string methodName = String.Format ("Region_{0}", regionCounter++);
CodeMemberMethod regionMethod = new CodeMemberMethod ();
regionMethod.Name = methodName;
MainClass.Members.Add (regionMethod);
CodeMethodInvokeExpression methodCall = new CodeMethodInvokeExpression (
thisref,
methodName
);
method.Statements.Add (methodCall);
CodeAssignStatement regionAssign = new CodeAssignStatement ();
regionAssign.Left = curRegion;
regionAssign.Right = region;
regionMethod.Statements.Add (regionAssign);
methodCall = new CodeMethodInvokeExpression (
new CodeFieldReferenceExpression (thisref, "regions"),
"Add",
new CodeExpression[] {curRegion}
);
regionMethod.Statements.Add (methodCall);
methodCall = new CodeMethodInvokeExpression (
curRegion,
"Add",
new CodeExpression[] {curCountry}
);
foreach (Country c in r.Countries) {
BuildCountry (c, regionMethod);
regionMethod.Statements.Add (methodCall);
}
}
public void ComplexExample()
{
string code = @"class A {
Button closeButton;
void M() {
System.Windows.Forms.Panel panel1;
closeButton = new System.Windows.Forms.Button();
panel1 = new System.Windows.Forms.Panel();
panel1.SuspendLayout();
panel1.Controls.Add(this.closeButton);
closeButton.BackColor = System.Drawing.Color.FromArgb();
panel1.BackColor = System.Drawing.SystemColors.Info;
}
}";
TypeDeclaration decl = Ast.ParseUtilCSharp.ParseGlobal <TypeDeclaration>(code);
CompilationUnit cu = new CompilationUnit();
cu.AddChild(decl);
CodeNamespace ns = (CodeNamespace)cu.AcceptVisitor(new CodeDomVisitor(), null);
Assert.AreEqual("A", ns.Types[0].Name);
Assert.AreEqual("closeButton", ns.Types[0].Members[0].Name);
Assert.AreEqual("M", ns.Types[0].Members[1].Name);
CodeMemberMethod m = (CodeMemberMethod)ns.Types[0].Members[1];
CodeVariableDeclarationStatement s0 = (CodeVariableDeclarationStatement)m.Statements[0];
Assert.AreEqual("panel1", s0.Name);
Assert.AreEqual("System.Windows.Forms.Panel", s0.Type.BaseType);
CodeAssignStatement cas = (CodeAssignStatement)m.Statements[1];
Assert.AreEqual("closeButton", ((CodeFieldReferenceExpression)cas.Left).FieldName);
cas = (CodeAssignStatement)m.Statements[2];
Assert.AreEqual("panel1", ((CodeVariableReferenceExpression)cas.Left).VariableName);
CodeExpressionStatement ces = (CodeExpressionStatement)m.Statements[3];
CodeMethodInvokeExpression mie = (CodeMethodInvokeExpression)ces.Expression;
Assert.AreEqual("SuspendLayout", mie.Method.MethodName);
Assert.AreEqual("panel1", ((CodeVariableReferenceExpression)mie.Method.TargetObject).VariableName);
ces = (CodeExpressionStatement)m.Statements[4];
mie = (CodeMethodInvokeExpression)ces.Expression;
Assert.AreEqual("Add", mie.Method.MethodName);
CodePropertyReferenceExpression pre = (CodePropertyReferenceExpression)mie.Method.TargetObject;
Assert.AreEqual("Controls", pre.PropertyName);
Assert.AreEqual("panel1", ((CodeVariableReferenceExpression)pre.TargetObject).VariableName);
cas = (CodeAssignStatement)m.Statements[5];
pre = (CodePropertyReferenceExpression)cas.Left;
Assert.AreEqual("BackColor", pre.PropertyName);
Assert.AreEqual("closeButton", ((CodeFieldReferenceExpression)pre.TargetObject).FieldName);
mie = (CodeMethodInvokeExpression)cas.Right;
Assert.AreEqual("FromArgb", mie.Method.MethodName);
Assert.IsTrue(mie.Method.TargetObject is CodeTypeReferenceExpression);
Assert.AreEqual("System.Drawing.Color", (mie.Method.TargetObject as CodeTypeReferenceExpression).Type.BaseType);
cas = (CodeAssignStatement)m.Statements[6];
pre = (CodePropertyReferenceExpression)cas.Left;
Assert.AreEqual("BackColor", pre.PropertyName);
Assert.AreEqual("panel1", ((CodeVariableReferenceExpression)pre.TargetObject).VariableName);
pre = (CodePropertyReferenceExpression)cas.Right;
Assert.AreEqual("Info", pre.PropertyName);
Assert.IsTrue(pre.TargetObject is CodeTypeReferenceExpression);
Assert.AreEqual("System.Drawing.SystemColors", (pre.TargetObject as CodeTypeReferenceExpression).Type.BaseType);
}
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;
}
}
}");
}
/// <summary>
/// Generates a c# tag block class from a struct node.
/// </summary>
protected CodeTypeDeclaration GenerateBlockClass(XmlNode node)
{
// Setup the class type declaration.
string nameOfClass = node.Attributes["name"].InnerText + "Block";
CodeTypeDeclaration classType = new CodeTypeDeclaration(nameOfClass);
classType.IsClass = true;
classType.TypeAttributes = TypeAttributes.Public;
classType.BaseTypes.Add("IBlock");
// Append the private members.
XmlNodeList fieldList = node.SelectNodes("value");
foreach (XmlNode fieldNode in fieldList)
{
try
{
if (fieldNode.Attributes["type"].InnerText == "Custom")
{
continue;
}
classType.Members.Add(GeneratePrivateMember(fieldNode));
}
catch (Exception ex)
{
throw new Exception(fieldNode.Attributes["type"].InnerText + " - GeneratePrivateMember on " + fieldNode.Attributes["name"].InnerText + " : " + ex.Message);
}
}
// Generate the constructor.
CodeConstructor constructor = new CodeConstructor();
constructor.Attributes = MemberAttributes.Public;
classType.Members.Add(constructor);
foreach (XmlNode fieldNode in fieldList)
{
try
{
if (fieldNode.Attributes["type"].InnerText == "Custom")
{
continue;
}
if (fieldNode.Attributes["type"].InnerText == "Block")
{
string blockName = fieldNode.Attributes["struct"].InnerText + "Block";
string collectionName = blockName + "Collection";
string linkName = GlobalMethods.MakePrivateName(fieldNode.Attributes["name"].InnerText);
string memberName = linkName + "Collection";
//fix underscore problem
//string publicName = linkName.Substring(0, 1).ToUpper() + linkName.Substring(1);
string publicName = linkName.Substring(1, 1).ToUpper() + linkName.Substring(2);
// Add the block collection.
classType.Members.Add(GenerateBlockCollection(blockName));
classType.Members.Add(new CodeMemberField(collectionName, memberName));
constructor.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), memberName),
new CodeObjectCreateExpression(collectionName, new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(), linkName))));
// Generate the public collection accessor.
CodeMemberProperty collectionAccessor = new CodeMemberProperty();
collectionAccessor.Name = publicName;
collectionAccessor.Type = new CodeTypeReference(collectionName);
collectionAccessor.Attributes = MemberAttributes.Public | MemberAttributes.Final;
//collectionAccessor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "index"));
collectionAccessor.HasGet = true;
collectionAccessor.HasSet = false;
collectionAccessor.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(), memberName)));
classType.Members.Add(collectionAccessor);
}
}
catch (Exception ex)
{
throw new Exception(fieldNode.Attributes["type"].InnerText + " - GenerateBlockCollection on " + fieldNode.Attributes["name"].InnerText + " : " + ex.Message);
}
}
// Generate the other public accessors.
foreach (XmlNode fieldNode in fieldList)
{
try
{
// We don't need public accessors for pad or block fields.
if (fieldNode.Attributes["type"].InnerText == "Pad")
{
continue;
}
if (fieldNode.Attributes["type"].InnerText == "Block")
{
continue;
}
if (fieldNode.Attributes["type"].InnerText == "Custom")
{
continue;
}
if (fieldNode.Attributes["type"].InnerText == "Skip")
{
continue;
}
classType.Members.Add(GeneratePublicAccessors(fieldNode));
}
catch (Exception ex)
{
throw new Exception(fieldNode.Attributes["type"].InnerText + " - GeneratePublicAccessors on " + fieldNode.Attributes["name"].InnerText + " : " + ex.Message);
}
}
// Finish generating the constructor.
foreach (XmlNode fieldNode in fieldList)
{
try
{
if (fieldNode.Attributes["type"].InnerText == "Custom")
{
continue;
}
CodeStatement constructorStatement = GenerateConstructorLogic(fieldNode);
if (constructorStatement != null)
{
constructor.Statements.Add(constructorStatement);
}
}
catch (Exception ex)
{
throw new Exception(fieldNode.Attributes["type"].InnerText + " - GenerateConstructorLogic on " + fieldNode.Attributes["name"].InnerText + " : " + ex.Message);
}
}
// Generate the Read method.
CodeMemberMethod readMethod = new CodeMemberMethod();
readMethod.ReturnType = new CodeTypeReference(typeof(void));
readMethod.Name = "Read";
readMethod.Parameters.Add(new CodeParameterDeclarationExpression("BinaryReader", "reader"));
readMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
foreach (XmlNode fieldNode in fieldList)
{
if (fieldNode.Attributes["type"].InnerText == "Custom")
{
continue;
}
string name = GlobalMethods.MakePrivateName(fieldNode.Attributes["name"].InnerText);
// *******************************************************************************
// Language specific statement - must be changed to be cross-language compatible.
// *******************************************************************************
readMethod.Statements.Add(new CodeSnippetStatement(name + ".Read(reader);"));
}
classType.Members.Add(readMethod);
// Generate the ReadChildData method.
// This reads strings, child blocks, and data fields in the order that they appear.
CodeMemberMethod readChildDataMethod = new CodeMemberMethod();
readChildDataMethod.ReturnType = new CodeTypeReference(typeof(void));
readChildDataMethod.Name = "ReadChildData";
readChildDataMethod.Parameters.Add(new CodeParameterDeclarationExpression("BinaryReader", "reader"));
readChildDataMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
foreach (XmlNode fieldNode in fieldList)
{
if (fieldNode.Attributes["type"].InnerText == "Block")
{
readChildDataMethod.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "x", new CodePrimitiveExpression(0)));
break;
}
}
foreach (XmlNode fieldNode in fieldList)
{
string name = GlobalMethods.MakePrivateName(fieldNode.Attributes["name"].InnerText);
string type = fieldNode.Attributes["type"].InnerText;
if (type == "Block")
{
//fix underscore problem
//string blockCollection = name.Substring(0, 1).ToUpper() + name.Substring(1);
string blockCollection = name.Substring(1, 1).ToUpper() + name.Substring(2);
CodeIterationStatement forLoopRead = new CodeIterationStatement(
new CodeAssignStatement(new CodeVariableReferenceExpression("x"), new CodePrimitiveExpression(0)),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("x"),
CodeBinaryOperatorType.LessThan, new CodeFieldReferenceExpression(
new CodeVariableReferenceExpression(name), "Count")),
new CodeAssignStatement(new CodeVariableReferenceExpression("x"), new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))),
new CodeStatement[]
{
new CodeExpressionStatement(
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(blockCollection), "AddNew", new CodeExpression[] {})),
new CodeExpressionStatement(
new CodeMethodInvokeExpression(new CodeIndexerExpression(
new CodeVariableReferenceExpression(blockCollection), new CodeVariableReferenceExpression("x")), "Read",
new CodeVariableReferenceExpression("reader"))),
});
readChildDataMethod.Statements.Add(forLoopRead);
CodeIterationStatement forLoopReadChildren = new CodeIterationStatement(
new CodeAssignStatement(new CodeVariableReferenceExpression("x"), new CodePrimitiveExpression(0)),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("x"),
CodeBinaryOperatorType.LessThan, new CodeFieldReferenceExpression(
new CodeVariableReferenceExpression(name), "Count")),
new CodeAssignStatement(new CodeVariableReferenceExpression("x"), new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))),
new CodeStatement[]
{
new CodeExpressionStatement(
new CodeMethodInvokeExpression(new CodeIndexerExpression(
new CodeVariableReferenceExpression(blockCollection), new CodeVariableReferenceExpression("x")), "ReadChildData",
new CodeVariableReferenceExpression("reader"))),
});
readChildDataMethod.Statements.Add(forLoopReadChildren);
}
if (type == "TagReference")
{
CodeMethodInvokeExpression readString = new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(name), "ReadString", new CodeVariableReferenceExpression("reader"));
readChildDataMethod.Statements.Add(readString);
}
if (type == "Data")
{
CodeMethodInvokeExpression readBinary = new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(name), "ReadBinary", new CodeVariableReferenceExpression("reader"));
readChildDataMethod.Statements.Add(readBinary);
}
}
classType.Members.Add(readChildDataMethod);
// // Append the Write method.
// sb.Append("public void Write(BinaryWriter writer)\r\n");
// sb.Append("{\r\n");
// foreach (XmlNode fieldNode in fieldList)
// {
// if (fieldNode.Attributes["type"].InnerText == "Custom") continue;
// string name = "_" + GlobalMethods.MakePrivateName(fieldNode.Attributes["name"].InnerText);
// sb.Append(" " + name + ".Write(writer);\r\n");
// }
// sb.Append("}\r\n");
//
// // Append the WriteChildData method.
// // This writes strings, child blocks, and data fields in the order that they appear.
// sb.Append("public void WriteChildData(BinaryWriter writer)\r\n");
// sb.Append("{\r\n");
// foreach (XmlNode fieldNode in fieldList)
// {
// string name = "_" + GlobalMethods.MakePrivateName(fieldNode.Attributes["name"].InnerText);
// string type = fieldNode.Attributes["type"].InnerText;
// if (type == "Block")
// {
// string count = name + ".Count";
// string blockCollection = name.Substring(1, 1).ToUpper() + name.Substring(2);
// sb.Append(name + ".UpdateReflexiveOffset(writer);\r\n");
// sb.Append("for (int x=0; x<" + count + "; x++)\r\n");
// sb.Append("{\r\n");
// sb.Append(" " + blockCollection + "[x].Write(writer);\r\n");
// sb.Append("}\r\n");
// sb.Append("for (int x=0; x<" + count + "; x++)\r\n");
// sb.Append(" " + blockCollection + "[x].WriteChildData(writer);\r\n");
// }
// if (type == "TagReference")
// {
// sb.Append(name + ".WriteString(writer);\r\n");
// }
// if (type == "Data")
// {
// sb.Append(name + ".WriteBinary(writer);\r\n");
// }
// }
// sb.Append("}\r\n");
//close up the class
return(classType);
}
public void MethodWithRefParameter()
{
var cd = new CodeTypeDeclaration("TEST");
cd.IsClass = true;
var 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);
AssertEqual(cd,
@"public class TEST {
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);
}
}");
}
protected abstract void GenerateMethodInvokeExpression(CodeMethodInvokeExpression e);
public CodeMemberMethod GenerateMethod(Smoke* smoke, Smoke.Method* method, string mungedName, CodeTypeReference iface)
{
string cppSignature = smoke->GetMethodSignature(method);
CodeMemberMethod cmm = GenerateBasicMethodDefinition(smoke, method, cppSignature, iface);
if (cmm == null)
{
return null;
}
// put the method into the correct type
CodeTypeDeclaration containingType = type;
if (cmm.Name.StartsWith("operator") || cmm.Name.StartsWith("explicit "))
{
if (!data.CSharpTypeMap.TryGetValue(cmm.Parameters[0].Type.GetStringRepresentation(), out containingType))
{
if (cmm.Parameters.Count < 2 ||
!data.CSharpTypeMap.TryGetValue(cmm.Parameters[1].Type.GetStringRepresentation(), out containingType))
{
Debug.Print(" |--Can't find containing type for {0} - skipping", cppSignature);
}
return null;
}
}
// already implemented?
if (containingType.HasMethod(cmm))
{
if (iface == null || (method->flags & (uint) Smoke.MethodFlags.mf_protected) > 0)
{
// protected methods are not available in interfaces
Debug.Print(" |--Skipping already implemented method {0}", cppSignature);
return null;
}
else
{
cmm.PrivateImplementationType = iface;
}
}
if (PreMethodBodyHooks != null)
{
PreMethodBodyHooks(smoke, method, cmm, containingType);
}
// do we have pass-by-ref parameters?
bool generateInvokeForRefParams = cmm.Parameters.Cast<CodeParameterDeclarationExpression>().Any(expr => expr.Direction == FieldDirection.Ref);
// generate the SmokeMethod attribute
CodeAttributeDeclaration attr = new CodeAttributeDeclaration("SmokeMethod",
new CodeAttributeArgument(
new CodePrimitiveExpression(cppSignature)));
cmm.CustomAttributes.Add(attr);
// choose the correct 'interceptor'
CodeMethodInvokeExpression invoke;
if ((cmm.Attributes & MemberAttributes.Static) == MemberAttributes.Static)
{
invoke = new CodeMethodInvokeExpression(SmokeSupport.staticInterceptor_Invoke);
}
else
{
invoke = new CodeMethodInvokeExpression(SmokeSupport.interceptor_Invoke);
}
// first pass the munged name, then the C++ signature
invoke.Parameters.Add(new CodePrimitiveExpression(mungedName));
invoke.Parameters.Add(new CodePrimitiveExpression(cppSignature));
// retrieve the return type
CodeTypeReference returnType;
if ((method->flags & (uint) Smoke.MethodFlags.mf_dtor) > 0)
{
// destructor
returnType = new CodeTypeReference(typeof(void));
}
else if (cmm.Name.StartsWith("explicit operator "))
{
// strip 'explicit operator' from the name to get the return type
returnType = new CodeTypeReference(cmm.Name.Substring(18));
}
else
{
returnType = cmm.ReturnType;
}
// add the return type
invoke.Parameters.Add(new CodeTypeOfExpression(returnType));
invoke.Parameters.Add(new CodePrimitiveExpression(generateInvokeForRefParams));
invoke.Parameters.Add(new CodeVariableReferenceExpression("smokeArgs"));
ProcessEqualityOperators(cmm);
CodeArrayCreateExpression argsInitializer = new CodeArrayCreateExpression(typeof(object[]));
// add the parameters
foreach (CodeParameterDeclarationExpression param in cmm.Parameters)
{
argsInitializer.Initializers.Add(new CodeTypeOfExpression(param.Type));
string argReference = param.Name;
int indexOfSpace = argReference.IndexOf(' ');
if (indexOfSpace > 0)
{
argReference = argReference.Substring(0, indexOfSpace);
}
argsInitializer.Initializers.Add(new CodeArgumentReferenceExpression(argReference));
}
CodeStatement argsStatement = new CodeVariableDeclarationStatement(typeof(object[]), "smokeArgs", argsInitializer);
cmm.Statements.Add(argsStatement);
// we have to call "CreateProxy()" in constructors
if (cmm is CodeConstructor)
{
cmm.Statements.Add(
new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "CreateProxy")));
}
// add the method call statement
CodeStatement statement;
if (!generateInvokeForRefParams)
{
if (method->ret > 0 && (method->flags & (uint) Smoke.MethodFlags.mf_ctor) == 0)
{
statement = new CodeMethodReturnStatement(new CodeCastExpression(returnType, invoke));
}
else
{
statement = new CodeExpressionStatement(invoke);
}
cmm.Statements.Add(statement);
}
else
{
if (method->ret > 0 && (method->flags & (uint) Smoke.MethodFlags.mf_ctor) == 0)
{
statement = new CodeVariableDeclarationStatement(returnType, "smokeRetval",
new CodeCastExpression(returnType, invoke));
cmm.Statements.Add(statement);
}
else
{
statement = new CodeExpressionStatement(invoke);
cmm.Statements.Add(statement);
}
int i = 0;
foreach (CodeParameterDeclarationExpression param in cmm.Parameters)
{
++i;
if (param.Direction != FieldDirection.Ref)
{
continue;
}
cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(param.Name),
new CodeCastExpression(param.Type.BaseType,
new CodeArrayIndexerExpression(
new CodeVariableReferenceExpression("smokeArgs"),
new CodePrimitiveExpression(i*2 - 1)
)
)
));
}
if (method->ret > 0 && (method->flags & (uint) Smoke.MethodFlags.mf_ctor) == 0)
{
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("smokeRetval")));
}
}
containingType.Members.Add(cmm);
if ((method->flags & (uint) Smoke.MethodFlags.mf_dtor) != 0)
{
containingType.BaseTypes.Add(new CodeTypeReference(typeof(IDisposable)));
CodeMemberMethod dispose = new CodeMemberMethod();
dispose.Name = "Dispose";
dispose.Attributes = MemberAttributes.Public | MemberAttributes.New | MemberAttributes.Final;
dispose.Statements.AddRange(cmm.Statements);
dispose.Statements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("GC"), "SuppressFinalize",
new CodeThisReferenceExpression()
)));
containingType.Members.Add(dispose);
}
return cmm;
}
public abstract void WriteFilterMethod(HandlerNode handlerNode, TemplateContext ctx, CodeMemberMethod handlerFilterMethod,
CodeMethodInvokeExpression invoker);
protected override void GenerateMethodInvokeExpression
(CodeMethodInvokeExpression e)
{
GenerateMethodReferenceExpression(e.Method);
Output.Write("(");
OutputExpressionList(e.Parameters);
Output.Write(")");
}
void AddAsyncMembers(string messageName, CodeMemberMethod method)
{
CodeThisReferenceExpression ethis = new CodeThisReferenceExpression();
CodePrimitiveExpression enull = new CodePrimitiveExpression(null);
CodeMemberField codeField = new CodeMemberField(typeof(System.Threading.SendOrPostCallback), messageName + "OperationCompleted");
codeField.Attributes = MemberAttributes.Private;
CodeTypeDeclaration.Members.Add(codeField);
// Event arguments class
string argsClassName = classNames.AddUnique(messageName + "CompletedEventArgs", null);
CodeTypeDeclaration argsClass = new CodeTypeDeclaration(argsClassName);
argsClass.Attributes |= MemberAttributes.Public;
argsClass.IsPartial = true;
argsClass.BaseTypes.Add(new CodeTypeReference("System.ComponentModel.AsyncCompletedEventArgs"));
CodeMemberField resultsField = new CodeMemberField(typeof(object[]), "results");
resultsField.Attributes = MemberAttributes.Private;
argsClass.Members.Add(resultsField);
CodeConstructor cc = new CodeConstructor();
cc.Attributes = MemberAttributes.Assembly;
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object[]), "results"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(System.Exception), "exception"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(bool), "cancelled"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));
cc.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("exception"));
cc.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("cancelled"));
cc.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("userState"));
CodeExpression thisResults = new CodeFieldReferenceExpression(ethis, "results");
cc.Statements.Add(new CodeAssignStatement(thisResults, new CodeVariableReferenceExpression("results")));
argsClass.Members.Add(cc);
int ind = 0;
if (method.ReturnType.BaseType != "System.Void")
{
argsClass.Members.Add(CreateArgsProperty(method.ReturnType, "Result", ind++));
}
foreach (CodeParameterDeclarationExpression par in method.Parameters)
{
if (par.Direction == FieldDirection.Out || par.Direction == FieldDirection.Ref)
{
argsClass.Members.Add(CreateArgsProperty(par.Type, par.Name, ind++));
}
}
bool needsArgsClass = (ind > 0);
if (needsArgsClass)
{
asyncTypes.Add(argsClass);
}
else
{
argsClassName = "System.ComponentModel.AsyncCompletedEventArgs";
}
// Event delegate type
CodeTypeDelegate delegateType = new CodeTypeDelegate(messageName + "CompletedEventHandler");
delegateType.Attributes |= MemberAttributes.Public;
delegateType.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender"));
delegateType.Parameters.Add(new CodeParameterDeclarationExpression(argsClassName, "args"));
// Event member
CodeMemberEvent codeEvent = new CodeMemberEvent();
codeEvent.Attributes = codeEvent.Attributes & ~MemberAttributes.AccessMask | MemberAttributes.Public;
codeEvent.Name = messageName + "Completed";
codeEvent.Type = new CodeTypeReference(delegateType.Name);
CodeTypeDeclaration.Members.Add(codeEvent);
// Async method (without user state param)
CodeMemberMethod am = new CodeMemberMethod();
am.Attributes = MemberAttributes.Public | MemberAttributes.Final;
am.Name = method.Name + "Async";
am.ReturnType = new CodeTypeReference(typeof(void));
CodeMethodInvokeExpression inv;
inv = new CodeMethodInvokeExpression(ethis, am.Name);
am.Statements.Add(inv);
// On...Completed method
CodeMemberMethod onCompleted = new CodeMemberMethod();
onCompleted.Name = "On" + messageName + "Completed";
onCompleted.Attributes = MemberAttributes.Private | MemberAttributes.Final;
onCompleted.ReturnType = new CodeTypeReference(typeof(void));
onCompleted.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "arg"));
CodeConditionStatement anIf = new CodeConditionStatement();
CodeExpression eventField = new CodeEventReferenceExpression(ethis, codeEvent.Name);
anIf.Condition = new CodeBinaryOperatorExpression(eventField, CodeBinaryOperatorType.IdentityInequality, enull);
CodeExpression castedArg = new CodeCastExpression(typeof(System.Web.Services.Protocols.InvokeCompletedEventArgs), new CodeVariableReferenceExpression("arg"));
CodeStatement invokeArgs = new CodeVariableDeclarationStatement(typeof(System.Web.Services.Protocols.InvokeCompletedEventArgs), "invokeArgs", castedArg);
anIf.TrueStatements.Add(invokeArgs);
CodeDelegateInvokeExpression delegateInvoke = new CodeDelegateInvokeExpression();
delegateInvoke.TargetObject = eventField;
delegateInvoke.Parameters.Add(ethis);
CodeObjectCreateExpression argsInstance = new CodeObjectCreateExpression(argsClassName);
CodeExpression invokeArgsVar = new CodeVariableReferenceExpression("invokeArgs");
if (needsArgsClass)
{
argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "Results"));
}
argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "Error"));
argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "Cancelled"));
argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "UserState"));
delegateInvoke.Parameters.Add(argsInstance);
anIf.TrueStatements.Add(delegateInvoke);
onCompleted.Statements.Add(anIf);
// Async method
CodeMemberMethod asyncMethod = new CodeMemberMethod();
asyncMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
asyncMethod.Name = method.Name + "Async";
asyncMethod.ReturnType = new CodeTypeReference(typeof(void));
CodeExpression delegateField = new CodeFieldReferenceExpression(ethis, codeField.Name);
anIf = new CodeConditionStatement();
anIf.Condition = new CodeBinaryOperatorExpression(delegateField, CodeBinaryOperatorType.IdentityEquality, enull);;
CodeExpression delegateRef = new CodeMethodReferenceExpression(ethis, onCompleted.Name);
CodeExpression newDelegate = new CodeObjectCreateExpression(typeof(System.Threading.SendOrPostCallback), delegateRef);
CodeAssignStatement cas = new CodeAssignStatement(delegateField, newDelegate);
anIf.TrueStatements.Add(cas);
asyncMethod.Statements.Add(anIf);
CodeArrayCreateExpression paramsArray = new CodeArrayCreateExpression(typeof(object));
// Assign parameters
CodeIdentifiers paramsIds = new CodeIdentifiers();
foreach (CodeParameterDeclarationExpression par in method.Parameters)
{
paramsIds.Add(par.Name, null);
if (par.Direction == FieldDirection.In || par.Direction == FieldDirection.Ref)
{
CodeParameterDeclarationExpression inpar = new CodeParameterDeclarationExpression(par.Type, par.Name);
am.Parameters.Add(inpar);
asyncMethod.Parameters.Add(inpar);
inv.Parameters.Add(new CodeVariableReferenceExpression(par.Name));
paramsArray.Initializers.Add(new CodeVariableReferenceExpression(par.Name));
}
}
inv.Parameters.Add(enull);
string userStateName = paramsIds.AddUnique("userState", null);
asyncMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), userStateName));
CodeExpression userStateVar = new CodeVariableReferenceExpression(userStateName);
asyncMethod.Statements.Add(BuildInvokeAsync(messageName, paramsArray, delegateField, userStateVar));
CodeTypeDeclaration.Members.Add(am);
CodeTypeDeclaration.Members.Add(asyncMethod);
CodeTypeDeclaration.Members.Add(onCompleted);
asyncTypes.Add(delegateType);
}
protected abstract void GenerateMethodInvokeExpression(CodeMethodInvokeExpression e);
public static CodeTypeMember[] CreateOverrideProperties <T>(IEnumerable <FieldMap <T> > fields)
{
IList <CodeTypeMember> members = new List <CodeTypeMember>(fields.Count());
// 重写基类（实体对象）的属性。
foreach (var field in fields)
{
var exp = field.Expression;
string propertyName;
PropertyInfo propertyInfo = ExtractPropertyInfo <T>(exp, out propertyName);
Check.Valid(!propertyInfo.GetSetMethod().IsVirtual, "类型[{0}]中的属性[{1}]必须标记为[virtual]。", propertyInfo.PropertyType.FullName, propertyName);
//
CodeMemberProperty property = new CodeMemberProperty();
property.Name = propertyName;
property.Type = new CodeTypeReference(propertyInfo.PropertyType);
property.Attributes = MemberAttributes.Override | MemberAttributes.Public;
// 向属性的get方法增加代码
// code: return base.PropertyName;
property.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeBaseReferenceExpression(), propertyName)));
// 向属性的set方法增加代码
// code:
// if (_Importing){
// base.PropertyName == value;
// return;
// }
// if (base.PropertyName == value){
// if(value == default(type))
// this._index.SetValue(index of field);
// return;
// }
// this._index.SetValue(index of field);
// base.PropertyName = value;
property.SetStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_Importing"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(true)),
new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeBaseReferenceExpression(), propertyName),
new CodePropertySetValueReferenceExpression()
),
new CodeMethodReturnStatement()
)
);
var methodIndexerCall = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_Indexer"),
"SetValue"),
new CodePrimitiveExpression(field.Index));
var condtion1 = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodePropertySetValueReferenceExpression(),
CodeBinaryOperatorType.IdentityEquality,
new CodeDefaultValueExpression(property.Type))
);
condtion1.TrueStatements.Add(methodIndexerCall);
property.SetStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(new CodeFieldReferenceExpression(new CodeBaseReferenceExpression(), propertyName), CodeBinaryOperatorType.ValueEquality, new CodePropertySetValueReferenceExpression()),
condtion1,
new CodeMethodReturnStatement()
)
);
property.SetStatements.Add(methodIndexerCall);
property.SetStatements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeBaseReferenceExpression(), propertyName),
new CodePropertySetValueReferenceExpression()));
//
members.Add(property);
}
return(members.ToArray());
}
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");
}
private static CodeTypeMember CreatePropertyOverride(PropertyInfo pi, List<string> additionals)
{
CodeMemberProperty mp = new CodeMemberProperty();
mp.Name = pi.Name;
mp.Attributes = MemberAttributes.Override | MemberAttributes.Public;
mp.Type = new CodeTypeReference(pi.PropertyType);
mp.HasGet = mp.HasSet = true;
mp.GetStatements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression() { PropertyName = pi.Name, TargetObject = new CodeBaseReferenceExpression() }));
var conditionForNotify = new CodeMethodInvokeExpression() { Method = new CodeMethodReferenceExpression(new CodePropertyReferenceExpression() { PropertyName = pi.Name, TargetObject = new CodeBaseReferenceExpression() }, "Equals") };
conditionForNotify.Parameters.Add(new CodePropertySetValueReferenceExpression());
var setCondition = new CodeConditionStatement()
{
Condition = new CodeBinaryOperatorExpression() { Left = new CodePrimitiveExpression(false), Right = conditionForNotify, Operator = CodeBinaryOperatorType.IdentityEquality }
};
setCondition.TrueStatements.Add(new CodeAssignStatement() { Left = new CodePropertyReferenceExpression() { PropertyName = pi.Name, TargetObject = new CodeBaseReferenceExpression() }, Right = new CodePropertySetValueReferenceExpression() });
var invokeMethod = new CodeMethodInvokeExpression() { Method = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), PropertyChangedFunctionName) };
invokeMethod.Parameters.Add(new CodePrimitiveExpression(pi.Name));
setCondition.TrueStatements.Add(invokeMethod);
foreach (var additional in additionals)
{
invokeMethod = new CodeMethodInvokeExpression() { Method = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), PropertyChangedFunctionName) };
invokeMethod.Parameters.Add(new CodePrimitiveExpression(additional));
setCondition.TrueStatements.Add(invokeMethod);
}
mp.SetStatements.Add(setCondition);
return mp;
}
public void MethodWithRefParameter()
{
CodeTypeDeclaration cd = new CodeTypeDeclaration("TEST");
cd.IsClass = true;
CodeMemberMethod 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);
AssertEqual(cd,
@"Public Class TEST
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
End Class");
}
// Builds the initialize method.
private void BuildInitializeMethod()
{
CodeThisReferenceExpression thisReference =
new CodeThisReferenceExpression();
CodeMemberMethod initializeMethod = new CodeMemberMethod();
initializeMethod.Name = "Initialize";
initializeMethod.Attributes = MemberAttributes.Private;
CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression();
methodInvoke.Method.TargetObject = thisReference;
methodInvoke.Method.MethodName = "InitializeStates";
initializeMethod.Statements.Add(methodInvoke);
methodInvoke = new CodeMethodInvokeExpression();
methodInvoke.Method.TargetObject = thisReference;
methodInvoke.Method.MethodName = "InitializeGuards";
initializeMethod.Statements.Add(methodInvoke);
methodInvoke = new CodeMethodInvokeExpression();
methodInvoke.Method.TargetObject = thisReference;
methodInvoke.Method.MethodName = "InitializeActions";
initializeMethod.Statements.Add(methodInvoke);
methodInvoke = new CodeMethodInvokeExpression();
methodInvoke.Method.TargetObject = thisReference;
methodInvoke.Method.MethodName = "InitializeTransitions";
initializeMethod.Statements.Add(methodInvoke);
methodInvoke = new CodeMethodInvokeExpression();
methodInvoke.Method.TargetObject = thisReference;
methodInvoke.Method.MethodName = "InitializeRelationships";
initializeMethod.Statements.Add(methodInvoke);
methodInvoke = new CodeMethodInvokeExpression();
methodInvoke.Method.TargetObject = thisReference;
methodInvoke.Method.MethodName = "InitializeHistoryTypes";
initializeMethod.Statements.Add(methodInvoke);
methodInvoke = new CodeMethodInvokeExpression();
methodInvoke.Method.TargetObject = thisReference;
methodInvoke.Method.MethodName = "InitializeInitialStates";
initializeMethod.Statements.Add(methodInvoke);
CodeExpression[] parameters =
{
new CodeFieldReferenceExpression(thisReference,
"state" + InitialState)
};
CodeMethodInvokeExpression initializeInvoke =
new CodeMethodInvokeExpression(thisReference,
"Initialize", parameters);
initializeMethod.Statements.Add(initializeInvoke);
methods.Add(initializeMethod);
}
