public void CallingMethods()
{
var ns = new CodeNamespace("MyNamespace");
var cd = new CodeTypeDeclaration("TEST") { IsClass = true };
var 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 virtual int VirtualMethod(int a) {
return a;
}
}
public class ClassWNewMethod : ClassWVirtualMethod {
public new virtual int VirtualMethod(int a) {
return (2 * a);
}
}
public class ClassWOverrideMethod : ClassWVirtualMethod {
public override int VirtualMethod(int a) {
return (2 * a);
}
}
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));
}
}
}");
}
