public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
// GENERATES (C#):
//
// namespace NSPC {
//
// public class ClassWithMethod {
//
// public int MethodName() {
// This is a CODE SNIPPET #*$*@;
// return 3;
// }
// }
// }
AddScenario ("FindSnippet", "Find code snippet in the code.");
CodeNamespace nspace = new CodeNamespace ("NSPC");
cu.Namespaces.Add (nspace);
CodeTypeDeclaration class1 = new CodeTypeDeclaration ("ClassWithMethod");
class1.IsClass = true;
nspace.Types.Add (class1);
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "MethodName";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Statements.Add (new CodeExpressionStatement (new CodeSnippetExpression ("This is a CODE SNIPPET #*$*@")));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (3)));
class1.Members.Add (cmm);
}
public override void BuildTree(CodeDomProvider provider, CodeCompileUnit cu) {
//cu.UserData["AllowLateBound"] = true;
// GENERATES (C#):
// namespace Namespace1 {
// using System;
//
//
// public class Class1 {
//
// public virtual string Foo1(string format, [System.Runtime.InteropServices.OptionalAttribute()] params object[] array) {
// string str;
// str = format.Replace("{0}", array[0].ToString());
// str = str.Replace("{1}", array[1].ToString());
// str = str.Replace("{2}", array[2].ToString());
// return str;
// }
// }
// }
CodeNamespace ns = new CodeNamespace("Namespace1");
ns.Imports.Add(new CodeNamespaceImport("System"));
cu.Namespaces.Add(ns);
// Full Verification Objects
CodeTypeDeclaration class1 = new CodeTypeDeclaration();
class1.Name = "Class1";
ns.Types.Add(class1);
AddScenario ("CheckFoo1");
CodeMemberMethod fooMethod1 = new CodeMemberMethod();
fooMethod1.Name = "Foo1";
fooMethod1.Attributes = MemberAttributes.Public ;
fooMethod1.ReturnType = new CodeTypeReference(typeof(string));
CodeParameterDeclarationExpression parameter1 = new CodeParameterDeclarationExpression();
parameter1.Name = "format";
parameter1.Type = new CodeTypeReference(typeof(string));
fooMethod1.Parameters.Add(parameter1);
CodeParameterDeclarationExpression parameter2 = new CodeParameterDeclarationExpression();
parameter2.Name = "array";
parameter2.Type = new CodeTypeReference(typeof(object[]));
if (Supports (provider, GeneratorSupport.ParameterAttributes)) {
parameter2.CustomAttributes.Add( new CodeAttributeDeclaration("System.ParamArrayAttribute"));
parameter2.CustomAttributes.Add( new CodeAttributeDeclaration("System.Runtime.InteropServices.OptionalAttribute"));
}
fooMethod1.Parameters.Add(parameter2);
class1.Members.Add(fooMethod1);
fooMethod1.Statements.Add( new CodeVariableDeclarationStatement(typeof(string), "str"));
fooMethod1.Statements.Add(CreateStatement(new CodeArgumentReferenceExpression ("format"), 0));
fooMethod1.Statements.Add(CreateStatement(new CodeVariableReferenceExpression ("str"), 1));
fooMethod1.Statements.Add(CreateStatement(new CodeVariableReferenceExpression ("str"), 2));
fooMethod1.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("str")));
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
CodeNamespace ns = new CodeNamespace ("Namespace1");
cu.Namespaces.Add (ns);
// GENERATES (C#):
//
// namespace Namespace1 {
// public class Class1 {
// public int Method1 {
// #line 300 "LinedStatement"
// return 0;
//
// #line default
// #line hidden
// }
// }
// }
CodeTypeDeclaration class1 = new CodeTypeDeclaration ("Class1");
class1.IsClass = true;
class1.Attributes = MemberAttributes.Public;
ns.Types.Add (class1);
CodeMemberMethod method1 = new CodeMemberMethod ();
method1.ReturnType = new CodeTypeReference (typeof (int));
method1.Name = "Method1";
class1.Members.Add (method1);
AddScenario ("FindLinedStatement");
CodeMethodReturnStatement ret = new CodeMethodReturnStatement (new CodePrimitiveExpression (0));
ret.LinePragma = new CodeLinePragma ("LinedStatement", 300);
method1.Statements.Add (ret);
}
public OperationContractGenerationContext(ServiceContractGenerator serviceContractGenerator, ServiceContractGenerationContext contract,
OperationDescription operation, CodeTypeDeclaration declaringType, CodeMemberMethod method) : this(serviceContractGenerator, contract, operation, declaringType)
{
if (method == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("method"));
}
this.syncMethod = method;
this.beginMethod = null;
this.endMethod = null;
}
public static bool ParametersEqual(this CodeMemberMethod self, CodeMemberMethod method)
{
if (method.Parameters.Count != self.Parameters.Count)
return false;
for (int i = 0; i < self.Parameters.Count; i++) {
if (!self.Parameters[i].Type.TypeEquals(method.Parameters[i].Type) || self.Parameters[i].Direction != method.Parameters[i].Direction) {
return false;
}
}
return true;
}
public ItemMethod(string inName, MemberAttributes inAtt, List<string> inParameters)
{
method = new CodeMemberMethod();
method.Name = inName;
method.Attributes = inAtt;
for (int i = 0; i < inParameters.Count; i++)
{
method.Parameters.Add(new CodeParameterDeclarationExpression(inParameters[i], "inArg" + i));
}
statement = new CodeConditionStatement();
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
// GENERATES (C#):
//
// public class MyConverter : System.ComponentModel.TypeConverter {
//
// private void Foo() {
// this.Foo(null);
// }
//
// private void Foo(string s) {
// }
//
// public override bool CanConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Type sourceType) {
// return base.CanConvertFrom(context, sourceType);
// }
// }
CodeNamespace ns = new CodeNamespace ();
cu.Namespaces.Add (ns);
CodeTypeDeclaration class1 = new CodeTypeDeclaration ();
class1.Name = "MyConverter";
class1.BaseTypes.Add (new CodeTypeReference (typeof (System.ComponentModel.TypeConverter)));
ns.Types.Add (class1);
CodeMemberMethod foo1 = new CodeMemberMethod ();
foo1.Name = "Foo";
foo1.Statements.Add (new CodeMethodInvokeExpression (new CodeThisReferenceExpression (), "Foo", new CodePrimitiveExpression (null)));
class1.Members.Add (foo1);
CodeMemberMethod foo2 = new CodeMemberMethod ();
foo2.Name = "Foo";
foo2.Parameters.Add (new CodeParameterDeclarationExpression (typeof (string), "s"));
class1.Members.Add (foo2);
CodeMemberMethod convert = new CodeMemberMethod ();
convert.Name = "CanConvertFrom";
convert.Attributes = MemberAttributes.Public | MemberAttributes.Override | MemberAttributes.Overloaded;
convert.ReturnType = new CodeTypeReference (typeof (bool));
convert.Parameters.Add (new CodeParameterDeclarationExpression (typeof (System.ComponentModel.ITypeDescriptorContext), "context"));
convert.Parameters.Add (new CodeParameterDeclarationExpression (typeof (System.Type), "sourceType"));
convert.Statements.Add (
new CodeMethodReturnStatement (
new CodeMethodInvokeExpression (
new CodeBaseReferenceExpression (),
"CanConvertFrom",
new CodeArgumentReferenceExpression ("context"),
new CodeArgumentReferenceExpression ("sourceType"))));
class1.Members.Add (convert);
}
static void Main(string[] args)
{
int namespaces = 10;
int classesPerNamespace = 10;
int methodsPerClass = 10;
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
for (int i = 0; i < namespaces; ++i)
{
CodeNamespace codeNamespace = new CodeNamespace();
codeCompileUnit.Namespaces.Add(codeNamespace);
codeNamespace.Name = "Namespace" + i;
for (int j = 0; j < classesPerNamespace; ++j)
{
CodeTypeDeclaration codeTypeDeclaration = new CodeTypeDeclaration();
codeNamespace.Types.Add(codeTypeDeclaration);
codeTypeDeclaration.Name = "Class" + j;
codeTypeDeclaration.TypeAttributes = TypeAttributes.Public;
codeTypeDeclaration.Comments.Add(
new CodeCommentStatement(
"<summary>This is a summary.</summary>",
true
)
);
for (int k = 0; k < methodsPerClass; ++k)
{
CodeMemberMethod codeMemberMethod = new CodeMemberMethod();
codeTypeDeclaration.Members.Add(codeMemberMethod);
codeMemberMethod.Name = "Method" + k;
codeMemberMethod.Attributes = MemberAttributes.Public;
codeMemberMethod.Comments.Add(
new CodeCommentStatement(
"<summary>This is a summary.</summary>",
true
)
);
}
}
}
CodeDomProvider codeDomProvider = new CSharpCodeProvider();
ICodeGenerator codeGenerator = codeDomProvider.CreateGenerator();
CodeGeneratorOptions codeGeneratorOptions = new CodeGeneratorOptions();
codeGenerator.GenerateCodeFromCompileUnit(codeCompileUnit, Console.Out, codeGeneratorOptions);
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
CodeNamespace ns = new CodeNamespace ();
ns.Name = "MyNamespace";
cu.Namespaces.Add (ns);
// GENERATES (C#):
//
// namespace MyNamespace {
// public class MyClass {
// private void PrimitiveTest() {
// char var1 = 'a';
// char var2 = '\0';
// string var3 = "foo\0bar\0baz\0";
// object var4 = null;
// int var5 = 42;
// double var6 = 3.14;
// System.Console.Write(var1);
// System.Console.Write(var2);
// System.Console.Write(var3);
// System.Console.Write(var4);
// System.Console.Write(var5);
// System.Console.Write(var6);
// }
// }
// }
CodeTypeDeclaration class1 = new CodeTypeDeclaration ();
class1.Name = "MyClass";
class1.IsClass = true;
class1.Attributes = MemberAttributes.Public;
ns.Types.Add (class1);
CodeMemberMethod method = new CodeMemberMethod ();
method.Name = "PrimitiveTest";
method.Statements.Add (new CodeVariableDeclarationStatement (typeof (char), "var1", new CodePrimitiveExpression ('a')));
method.Statements.Add (new CodeVariableDeclarationStatement (typeof (char), "var2", new CodePrimitiveExpression ('\0')));
method.Statements.Add (new CodeVariableDeclarationStatement (typeof (string), "var3", new CodePrimitiveExpression ("foo\0bar\0baz\0")));
method.Statements.Add (new CodeVariableDeclarationStatement (typeof (Object), "var4", new CodePrimitiveExpression (null)));
method.Statements.Add (new CodeVariableDeclarationStatement (typeof (int), "var5", new CodePrimitiveExpression (42)));
method.Statements.Add (new CodeVariableDeclarationStatement (typeof (double), "var6", new CodePrimitiveExpression (3.14)));
method.Statements.Add (new CodeMethodInvokeExpression (new CodeTypeReferenceExpression (typeof (Console)), "Write", new CodeVariableReferenceExpression ("var1")));
method.Statements.Add (new CodeMethodInvokeExpression (new CodeTypeReferenceExpression (typeof (Console)), "Write", new CodeVariableReferenceExpression ("var2")));
method.Statements.Add (new CodeMethodInvokeExpression (new CodeTypeReferenceExpression (typeof (Console)), "Write", new CodeVariableReferenceExpression ("var3")));
method.Statements.Add (new CodeMethodInvokeExpression (new CodeTypeReferenceExpression (typeof (Console)), "Write", new CodeVariableReferenceExpression ("var4")));
method.Statements.Add (new CodeMethodInvokeExpression (new CodeTypeReferenceExpression (typeof (Console)), "Write", new CodeVariableReferenceExpression ("var5")));
method.Statements.Add (new CodeMethodInvokeExpression (new CodeTypeReferenceExpression (typeof (Console)), "Write", new CodeVariableReferenceExpression ("var6")));
class1.Members.Add (method);
}
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));
}
}
private static string GenerateCode(string expression)
{
var source = new StringBuilder();
var sw = new StringWriter(source);
var options = new CodeGeneratorOptions();
var myNamespace = new CodeNamespace("ExpressionEvaluator");
myNamespace.Imports.Add(new CodeNamespaceImport("System"));
var classDeclaration = new CodeTypeDeclaration { IsClass = true, Name = "Calculator", Attributes = MemberAttributes.Public };
var myMethod = new CodeMemberMethod { Name = "Calculate", ReturnType = new CodeTypeReference(typeof(double)), Attributes = MemberAttributes.Public };
myMethod.Statements.Add(new CodeMethodReturnStatement(new CodeSnippetExpression(expression)));
classDeclaration.Members.Add(myMethod);
myNamespace.Types.Add(classDeclaration);
provider.GenerateCodeFromNamespace(myNamespace, sw, options);
sw.Flush();
sw.Close();
return source.ToString();
}
public static bool HasMethod(this CodeTypeDeclaration self, CodeMemberMethod method)
{
foreach (CodeTypeMember member in self.Members) {
if (!(member is CodeMemberMethod) || member.Name != method.Name)
continue;
// now check the parameters
CodeMemberMethod currentMeth = (CodeMemberMethod) member;
if (currentMeth.Parameters.Count != method.Parameters.Count)
continue;
bool continueOuter = false;
for (int i = 0; i < method.Parameters.Count; i++) {
if (!method.Parameters[i].Type.TypeEquals(currentMeth.Parameters[i].Type) || method.Parameters[i].Direction != currentMeth.Parameters[i].Direction) {
continueOuter = true;
break;
}
}
if (continueOuter)
continue;
return true;
}
return false;
}
public void SetTestCategories(CodeMemberMethod memberMethod, IEnumerable<string> categories)
{
SetCategories(memberMethod.CustomAttributes, categories);
}
public void Constructor0()
{
CodeMemberMethod cmm = new CodeMemberMethod();
Assert.AreEqual(MemberAttributes.Private | MemberAttributes.Final,
cmm.Attributes, "#1");
Assert.IsNotNull(cmm.Comments, "#2");
Assert.AreEqual(0, cmm.Comments.Count, "#3");
Assert.IsNotNull(cmm.CustomAttributes, "#4");
Assert.AreEqual(0, cmm.CustomAttributes.Count, "#5");
#if NET_2_0
Assert.IsNotNull(cmm.StartDirectives, "#6");
Assert.AreEqual(0, cmm.StartDirectives.Count, "#7");
Assert.IsNotNull(cmm.EndDirectives, "#8");
Assert.AreEqual(0, cmm.EndDirectives.Count, "#9");
Assert.IsNotNull(cmm.TypeParameters, "#10");
Assert.AreEqual(0, cmm.TypeParameters.Count, "#11");
#endif
Assert.IsNull(cmm.LinePragma, "#12");
Assert.IsNotNull(cmm.Name, "#13");
Assert.AreEqual(string.Empty, cmm.Name, "#14");
Assert.IsNotNull(cmm.UserData, "#15");
Assert.AreEqual(typeof(ListDictionary), cmm.UserData.GetType(), "#16");
Assert.AreEqual(0, cmm.UserData.Count, "#17");
Assert.IsNotNull(cmm.ImplementationTypes, "#18");
Assert.AreEqual(0, cmm.ImplementationTypes.Count, "#19");
Assert.IsNotNull(cmm.Parameters, "#20");
Assert.AreEqual(0, cmm.Parameters.Count, "#21");
Assert.IsNull(cmm.PrivateImplementationType, "#22");
Assert.IsNotNull(cmm.ReturnType, "#23");
Assert.AreEqual(typeof(void).FullName, cmm.ReturnType.BaseType, "#24");
Assert.IsNotNull(cmm.ReturnTypeCustomAttributes, "#25");
Assert.AreEqual(0, cmm.ReturnTypeCustomAttributes.Count, "#26");
Assert.IsNotNull(cmm.Statements, "#27");
Assert.AreEqual(0, cmm.Statements.Count, "#28");
string name = "mono";
cmm.Name = name;
Assert.IsNotNull(cmm.Name, "#29");
Assert.AreSame(name, cmm.Name, "#30");
cmm.Name = null;
Assert.IsNotNull(cmm.Name, "#31");
Assert.AreEqual(string.Empty, cmm.Name, "#32");
CodeLinePragma clp = new CodeLinePragma("mono", 10);
cmm.LinePragma = clp;
Assert.IsNotNull(cmm.LinePragma, "#31");
Assert.AreSame(clp, cmm.LinePragma, "#32");
cmm.LinePragma = null;
Assert.IsNull(cmm.LinePragma, "#33");
}
public static void CreateTestMethod(IMathExpression result, CodeTypeDeclaration t, CodeNamespace ns, CodeMemberMethod m, AssemblyRefList imports, VariableList parameters, List <IPropertyPointer> pointerList)
{
result.GetAllImports(imports);
//
m.ReturnType = new CodeTypeReference(result.DataType.Type);
//
m.Comments.Add(new CodeCommentStatement("Variable mapping:"));
m.Comments.Add(new CodeCommentStatement("In formula: method parameter"));
//
MethodType mt = new MethodType();
mt.MethodCode = m;
result.GenerateInputVariables();
VariableList variables = result.InputVariables;
Dictionary <string, IPropertyPointer> pointers = new Dictionary <string, IPropertyPointer>();
result.GetPointers(pointers);
int n = variables.Count;
MathNode.Trace("Generate arguments from {0} input variables", n);
MathNode.IndentIncrement();
for (int k = 0; k < n; k++)
{
IVariable var = variables[k];
MathNode.Trace(k, var);
if (!(var is MathNodeVariableDummy) && !var.IsParam && !var.IsConst)
{
string paramName = "";
parameters.Add(var);
paramName = var.CodeVariableName;
CodeParameterDeclarationExpression p = new CodeParameterDeclarationExpression(new CodeTypeReference(var.VariableType.Type), paramName);
m.Parameters.Add(p);
//add comment
string sub = var.SubscriptName;
if (string.IsNullOrEmpty(sub))
{
sub = " ";
}
m.Comments.Add(new CodeCommentStatement(string.Format("{0}{1}:\t {2}", var.VariableName, sub, var.CodeVariableName)));
MathNode.IndentIncrement();
MathNode.Trace("Argument {0} {1} for {2}, {3}", var.VariableType.Type, paramName, var.TraceInfo, var.GetType());
MathNode.IndentDecrement();
//
result.AssignCodeExp(new CodeArgumentReferenceExpression(paramName), var.CodeVariableName);
}
}
MathNode.Trace("Generate arguments from {0} pointers", pointers.Count);
foreach (KeyValuePair <string, IPropertyPointer> kv in pointers)
{
string paramName = "";
pointerList.Add(kv.Value);
paramName = kv.Value.CodeName;
CodeParameterDeclarationExpression p = new CodeParameterDeclarationExpression(new CodeTypeReference(kv.Value.ObjectType), paramName);
m.Parameters.Add(p);
//add comment
m.Comments.Add(new CodeCommentStatement(string.Format("{0}:\t {1}", kv.Value.ToString(), paramName)));
MathNode.IndentIncrement();
MathNode.Trace("Argument {0} {1} for {2}", kv.Value.ObjectType, paramName, kv.Value.ToString());
MathNode.IndentDecrement();
}
MathNode.IndentDecrement();
//do the compiling
CodeExpression ce = result.ReturnCodeExpression(mt);
//
MathNode.Trace("Test method returns {0}, compiled type: {1}", result.DataType.Type, result.ActualCompileDataType.Type);
if (result.ActualCompileDataType.Type.Equals(result.DataType.Type))
{
CodeMethodReturnStatement mr = new CodeMethodReturnStatement(ce);
m.Statements.Add(mr);
}
else
{
if (result.ActualCompileDataType.IsVoid)
{
m.Statements.Add(new CodeExpressionStatement(ce));
CodeMethodReturnStatement mr = new CodeMethodReturnStatement(ValueTypeUtil.GetDefaultValueByType(result.DataType.Type));
m.Statements.Add(mr);
}
else
{
if (result.DataType.IsVoid)
{
m.Statements.Add(new CodeExpressionStatement(ce));
}
else
{
if (result.DataType.Type.Equals(typeof(string)))
{
CodeMethodReturnStatement mr = new CodeMethodReturnStatement(new CodeMethodInvokeExpression(ce, "ToString", new CodeExpression[] { }));
m.Statements.Add(mr);
}
else
{
CodeExpression mie = RaisDataType.GetConversionCode(result.ActualCompileDataType, ce, result.DataType, m.Statements);
if (mie != null)
{
CodeMethodReturnStatement mr = new CodeMethodReturnStatement(mie);
m.Statements.Add(mr);
}
}
}
}
}
}
/// <summary>Generate a text description for the specified DiscoveryClientProtocol.</summary>
/// <param name="protocol">A DiscoveryClientProtocol containing the information for the service.</param>
/// <returns>An XmlDocument containing the generated xml for the specified discovery protocol.</returns>
public static void GenerateWsdlXml(StringBuilder text, DiscoveryClientProtocol protocol)
{
// Code Namespace & Compile Unit
CodeNamespace codeNamespace = new CodeNamespace();
CodeCompileUnit codeUnit = new CodeCompileUnit();
codeUnit.Namespaces.Add(codeNamespace);
// Import and set the warning
ServiceDescriptionImporter importer = ReadServiceDescriptionImporter(protocol);
importer.Import(codeNamespace, codeUnit);
foreach (CodeTypeDeclaration type in codeNamespace.Types)
{
if (type.BaseTypes.Count == 0 || type.BaseTypes[0].BaseType != "System.Web.Services.Protocols.SoapHttpClientProtocol")
{
continue;
}
text.AppendFormat("<big><b><u>{0}</u></b></big>\n\n", type.Name);
string coms = GetCommentElements(type);
if (coms != null)
{
text.Append(coms).Append("\n\n");
}
foreach (CodeTypeMember mem in type.Members)
{
CodeMemberMethod met = mem as CodeMemberMethod;
if (met != null && !(mem is CodeConstructor))
{
// Method
// Asynch Begin & End Results
string returnType = met.ReturnType.BaseType;
if (met.Name.StartsWith("Begin") && returnType == "System.IAsyncResult")
{
continue; // BeginXXX method
}
if (met.Name.EndsWith("Async"))
{
continue;
}
if (met.Name.StartsWith("On") && met.Name.EndsWith("Completed"))
{
continue;
}
if (met.Parameters.Count > 0)
{
CodeParameterDeclarationExpression par = met.Parameters [met.Parameters.Count - 1];
if (met.Name.StartsWith("End") && par.Type.BaseType == "System.IAsyncResult")
{
continue; // EndXXX method
}
}
text.AppendFormat("<b>{0}</b> (", met.Name);
// Parameters
for (int n = 0; n < met.Parameters.Count; n++)
{
CodeParameterDeclarationExpression par = met.Parameters [n];
if (n > 0)
{
text.Append(", ");
}
text.AppendFormat("{0}: <i>{1}</i>", par.Name, par.Type.BaseType);
}
text.Append(")");
if (returnType != "System.Void")
{
text.AppendFormat(": <i>{0}</i>", returnType);
}
// Comments
coms = GetCommentElements(met);
if (coms != null)
{
text.Append("\n").Append(coms);
}
text.Append("\n\n");
}
}
}
}
/// <summary>
/// Generate CodeDom of the client API for ApiDescriptions.
/// </summary>
/// <param name="descriptions">Web Api descriptions exposed by Configuration.Services.GetApiExplorer().ApiDescriptions</param>
public void CreateCodeDom(OpenApiPaths paths, OpenApiComponents components)
{
if (paths == null && components == null)
{
return;
}
clientNamespace = new CodeNamespace(settings.ClientNamespace);
codeCompileUnit.Namespaces.Add(clientNamespace); //namespace added to Dom
ComponentsToCsTypes componentsToCsTypes = new ComponentsToCsTypes(settings, codeCompileUnit, clientNamespace);
componentsToCsTypes.CreateCodeDom(components);
if (paths == null)
{
return;
}
clientNamespace.Imports.AddRange(new CodeNamespaceImport[] {
new CodeNamespaceImport("System"),
new CodeNamespaceImport("System.Linq"),
new CodeNamespaceImport("System.Collections.Generic"),
new CodeNamespaceImport("System.Threading.Tasks"),
new CodeNamespaceImport("System.Net.Http"),
new CodeNamespaceImport("Newtonsoft.Json"),
new CodeNamespaceImport("Json = Newtonsoft.Json"),
new CodeNamespaceImport("System.IO"),
new CodeNamespaceImport("System.Threading"),
new CodeNamespaceImport("System.Net.Http.Headers")
});
if (settings.UseEnsureSuccessStatusCodeEx)
{
clientNamespace.Imports.Add(new CodeNamespaceImport("Fonlow.Net.Http"));
}
string[] containerClassNames = GetContainerClassNames(paths);
CodeTypeDeclaration[] newClassesCreated = containerClassNames.Select(d => CreateControllerClientClass(clientNamespace, d)).ToArray();
foreach (KeyValuePair <string, OpenApiPathItem> p in paths)
{
foreach (KeyValuePair <OperationType, OpenApiOperation> op in p.Value.Operations)
{
ClientApiFunctionGen apiFunctionGen = new ClientApiFunctionGen();
CodeMemberMethod apiFunction = apiFunctionGen.CreateApiFunction(settings, p.Key, op.Key, op.Value, componentsToCsTypes, true, settings.UseEnsureSuccessStatusCodeEx);
if (apiFunction == null)
{
System.Diagnostics.Trace.TraceWarning($"Not to generate C# for {p.Key} {op.Key}.");
continue;
}
string containerClassName = nameComposer.GetContainerName(op.Value, p.Key);
CodeTypeDeclaration existingClass = LookupExistingClass(containerClassName);
existingClass.Members.Add(apiFunction);
if (settings.GenerateBothAsyncAndSync)
{
ClientApiFunctionGen functionGen2 = new ClientApiFunctionGen();
existingClass.Members.Add(functionGen2.CreateApiFunction(settings, p.Key, op.Key, op.Value, componentsToCsTypes, false, settings.UseEnsureSuccessStatusCodeEx));
}
}
}
if (settings.UseEnsureSuccessStatusCodeEx)
{
CreateDummyOfEnsureSuccessStatusCodeEx();
}
}
public void SetRowTest(CodeMemberMethod memberMethod, string title)
{
SetTest(memberMethod, title);
}
public void BinaryOperators()
{
CodeNamespace ns = new CodeNamespace("Namespace1");
ns.Imports.Add(new CodeNamespaceImport("System"));
CodeTypeDeclaration class1 = new CodeTypeDeclaration();
class1.Name = "Class1";
class1.BaseTypes.Add(new CodeTypeReference(typeof(object)));
ns.Types.Add(class1);
CodeMemberMethod retMethod = new CodeMemberMethod();
retMethod.Name = "ReturnMethod";
retMethod.Attributes = (retMethod.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
retMethod.ReturnType = new CodeTypeReference(typeof(int));
retMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "intInput"));
CodeBinaryOperatorExpression cboExpression = new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(18),
CodeBinaryOperatorType.Divide,
new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(6),
CodeBinaryOperatorType.Subtract,
new CodePrimitiveExpression(4))),
CodeBinaryOperatorType.Multiply,
new CodeArgumentReferenceExpression("intInput"));
CodeVariableDeclarationStatement variableDeclaration = null;
variableDeclaration = new CodeVariableDeclarationStatement(typeof(int), "x1", cboExpression);
retMethod.Statements.Add(variableDeclaration);
retMethod.Statements.Add(
new CodeVariableDeclarationStatement(
typeof(int),
"x2",
new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(19),
CodeBinaryOperatorType.Modulus,
new CodePrimitiveExpression(8))));
retMethod.Statements.Add(
new CodeVariableDeclarationStatement(
typeof(int),
"x3",
new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(15),
CodeBinaryOperatorType.BitwiseAnd,
new CodePrimitiveExpression(35)),
CodeBinaryOperatorType.BitwiseOr,
new CodePrimitiveExpression(129))));
retMethod.Statements.Add(
new CodeVariableDeclarationStatement(
typeof(int),
"x4",
new CodePrimitiveExpression(0)));
retMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x2"),
CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(3)),
CodeBinaryOperatorType.BooleanOr,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x3"),
CodeBinaryOperatorType.LessThan,
new CodePrimitiveExpression(129))),
new CodeStatement[] { CreateVariableIncrementExpression("x4", 1) },
new CodeStatement[] { CreateVariableIncrementExpression("x4", 2) }));
retMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x2"),
CodeBinaryOperatorType.GreaterThan,
new CodePrimitiveExpression(-1)),
CodeBinaryOperatorType.BooleanAnd,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x3"),
CodeBinaryOperatorType.GreaterThanOrEqual,
new CodePrimitiveExpression(5000))),
new CodeStatement[] { CreateVariableIncrementExpression("x4", 4) },
new CodeStatement[] { CreateVariableIncrementExpression("x4", 8) }));
retMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x2"),
CodeBinaryOperatorType.LessThanOrEqual,
new CodePrimitiveExpression(3)),
CodeBinaryOperatorType.BooleanAnd,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x3"),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(1))),
new CodeStatement[] { CreateVariableIncrementExpression("x4", 16) },
new CodeStatement[] { CreateVariableIncrementExpression("x4", 32) }));
retMethod.Statements.Add(
new CodeMethodReturnStatement(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x1"),
CodeBinaryOperatorType.Add,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x2"),
CodeBinaryOperatorType.Add,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x3"),
CodeBinaryOperatorType.Add,
new CodeVariableReferenceExpression("x4"))))));
class1.Members.Add(retMethod);
retMethod = new CodeMemberMethod();
retMethod.Name = "SecondReturnMethod";
retMethod.Attributes = (retMethod.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
retMethod.ReturnType = new CodeTypeReference(typeof(int));
retMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "intInput"));
retMethod.Statements.Add(new CodeCommentStatement("To test CodeBinaryOperatorType.IdentiEquality operator"));
retMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(new CodeCastExpression("Object",
new CodeVariableReferenceExpression("intInput")),
CodeBinaryOperatorType.IdentityEquality, new CodeCastExpression("Object",
new CodePrimitiveExpression(5))),
new CodeStatement[] { new CodeMethodReturnStatement(new
CodePrimitiveExpression(5)) }, new CodeStatement[] { new
CodeMethodReturnStatement(new CodePrimitiveExpression(4))}));
class1.Members.Add(retMethod);
AssertEqual(ns,
@"Imports System
Namespace Namespace1
Public Class Class1
Inherits Object
Public Function ReturnMethod(ByVal intInput As Integer) As Integer
Dim x1 As Integer = ((18 _
/ (6 - 4)) _
* intInput)
Dim x2 As Integer = (19 Mod 8)
Dim x3 As Integer = ((15 And 35) _
Or 129)
Dim x4 As Integer = 0
If ((x2 = 3) _
OrElse (x3 < 129)) Then
x4 = (x4 + 1)
Else
x4 = (x4 + 2)
End If
If ((x2 > -1) _
AndAlso (x3 >= 5000)) Then
x4 = (x4 + 4)
Else
x4 = (x4 + 8)
End If
If ((x2 <= 3) _
AndAlso (x3 <> 1)) Then
x4 = (x4 + 16)
Else
x4 = (x4 + 32)
End If
Return (x1 _
+ (x2 _
+ (x3 + x4)))
End Function
Public Function SecondReturnMethod(ByVal intInput As Integer) As Integer
'To test CodeBinaryOperatorType.IdentiEquality operator
If (CType(intInput,[Object]) Is CType(5,[Object])) Then
Return 5
Else
Return 4
End If
End Function
End Class
End Namespace");
}
/// <summary>
/// Gets the full source code by applying an appropriate template based on the current <see cref="RoslynCodeTaskFactoryCodeType"/>.
/// </summary>
internal static string GetSourceCode(RoslynCodeTaskFactoryTaskInfo taskInfo, ICollection <TaskPropertyInfo> parameters)
{
if (taskInfo.CodeType == RoslynCodeTaskFactoryCodeType.Class)
{
return(taskInfo.SourceCode);
}
CodeTypeDeclaration codeTypeDeclaration = new CodeTypeDeclaration
{
IsClass = true,
Name = taskInfo.Name,
TypeAttributes = TypeAttributes.Public,
Attributes = MemberAttributes.Final
};
codeTypeDeclaration.BaseTypes.Add("Microsoft.Build.Utilities.Task");
foreach (TaskPropertyInfo propertyInfo in parameters)
{
CreateProperty(codeTypeDeclaration, propertyInfo.Name, propertyInfo.PropertyType);
}
if (taskInfo.CodeType == RoslynCodeTaskFactoryCodeType.Fragment)
{
CodeMemberProperty successProperty = CreateProperty(codeTypeDeclaration, "Success", typeof(bool), true);
CodeMemberMethod executeMethod = new CodeMemberMethod
{
Name = "Execute",
// ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
Attributes = MemberAttributes.Override | MemberAttributes.Public,
ReturnType = new CodeTypeReference(typeof(Boolean))
};
executeMethod.Statements.Add(new CodeSnippetStatement(taskInfo.SourceCode));
executeMethod.Statements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(null, successProperty.Name)));
codeTypeDeclaration.Members.Add(executeMethod);
}
else
{
codeTypeDeclaration.Members.Add(new CodeSnippetTypeMember(taskInfo.SourceCode));
}
CodeNamespace codeNamespace = new CodeNamespace("InlineCode");
codeNamespace.Imports.AddRange(DefaultNamespaces.Union(taskInfo.Namespaces, StringComparer.OrdinalIgnoreCase).Select(i => new CodeNamespaceImport(i)).ToArray());
codeNamespace.Types.Add(codeTypeDeclaration);
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(codeNamespace);
using (CodeDomProvider provider = CodeDomProvider.CreateProvider(taskInfo.CodeLanguage))
{
using (StringWriter writer = new StringWriter(new StringBuilder(), CultureInfo.CurrentCulture))
{
provider.GenerateCodeFromCompileUnit(codeCompileUnit, writer, new CodeGeneratorOptions
{
BlankLinesBetweenMembers = true,
VerbatimOrder = true
});
return(writer.ToString());
}
}
}
public override void OnExportClientServerCode(ActionBranch previousAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, CodeMemberMethod method, CodeStatementCollection statements,
StringCollection jsCode, StringCollection methodCode, JsMethodCompiler data)
{
}
public override bool OnExportCode(ActionBranch previousAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, CodeMemberMethod method, CodeStatementCollection statements)
{
bool bRet;
if (_actionData == null)
{
_actionData = (ActionSubMethod)this.Method.GetActionInstance(_actId.ActionId); // (ActionSubMethod)compiler.ActionEventList.GetAction(_actId);
}
SubMethodInfoPointer smi = _actionData.ActionMethod as SubMethodInfoPointer;
SubMethodInfo mi = smi.MethodInformation as SubMethodInfo;
if (mi.IsForeach)
{
ParameterClassSubMethod p = mi.GetParameterType(0, smi, this);
StringBuilder sb = new StringBuilder();
string s1 = smi.Owner.CodeName;
CustomMethodParameterPointer cmpp = smi.Owner.Owner as CustomMethodParameterPointer;
if (cmpp == null)
{
IObjectPointer op = smi.Owner;
sb.Append(s1);
while (!(op is ILocalvariable) && op.Owner != null && !(op.Owner is MethodClass) && op.Owner.Owner != null)
{
if (string.CompareOrdinal(s1, op.Owner.CodeName) != 0)
{
s1 = op.Owner.CodeName;
sb.Insert(0, ".");
sb.Insert(0, s1);
}
op = op.Owner;
}
s1 = sb.ToString();
}
string itemTypeString = null;
if (mi.ItemType.IsGenericParameter)
{
CollectionPointer cp = smi.Owner as CollectionPointer;
if (cp != null)
{
CustomPropertyPointer cpp = cp.Owner as CustomPropertyPointer;
if (cpp != null)
{
DataTypePointer dtp = cpp.GetConcreteType(mi.ItemType);
if (dtp != null)
{
itemTypeString = dtp.TypeString;
}
}
}
}
if (string.IsNullOrEmpty(itemTypeString))
{
itemTypeString = VPLUtil.GetTypeCSharpName(mi.ItemType);
}
string s0 = string.Format(System.Globalization.CultureInfo.InvariantCulture,
"{0}foreach({1} {2} in {3}) {{", Indentation.GetIndent(), itemTypeString, p.CodeName, s1);
CodeStatement cis0 = new CodeSnippetStatement(s0);
statements.Add(cis0);
//
if (_iconList != null)
{
foreach (ComponentIcon ci in _iconList)
{
ComponentIconLocal cil = ci as ComponentIconLocal;
if (cil != null && cil.ScopeGroupId == this.BranchId)
{
cil.LocalPointer.AddVariableDeclaration(statements);
}
}
}
//
CodeStatementCollection sc = new CodeStatementCollection();
Method.SubMethod.Push(this); //smi);
CompilerUtil.AddSubMethod(method, this);
bRet = base.OnExportCode(previousAction, nextAction, compiler, method, sc);
Method.SubMethod.Pop();
bRet = CompilerUtil.FinishSubMethod(method, this, sc, bRet);
statements.AddRange(sc);
//
statements.Add(new CodeSnippetStatement(string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}}}", Indentation.GetIndent())));
}
else
{
CodeIterationStatement cis = new CodeIterationStatement();
cis.TestExpression = mi.GetTestExpression(smi, compiler, this.Method, method, statements, this.BranchId);
cis.InitStatement = mi.GetInitStatement(smi, compiler, this.Method, method, statements, this.BranchId);
cis.IncrementStatement = mi.GetIncrementalStatement(smi, compiler, this.Method, method, statements, this.BranchId);
//
Method.SubMethod.Push(this); //smi);
CompilerUtil.AddSubMethod(method, this);
if (_iconList != null)
{
foreach (ComponentIcon ci in _iconList)
{
ComponentIconLocal cil = ci as ComponentIconLocal;
if (cil != null && cil.ScopeGroupId == this.BranchId)
{
cil.LocalPointer.AddVariableDeclaration(cis.Statements);
}
}
}
bRet = base.OnExportCode(previousAction, nextAction, compiler, method, cis.Statements);
Method.SubMethod.Pop();
bRet = CompilerUtil.FinishSubMethod(method, this, cis.Statements, bRet);
//
//
statements.Add(cis);
}
return(bRet);
}
public override void ProcessGeneratedCode(CodeCompileUnit codeCompileUnit, CodeNamespace generatedNamespace, CodeTypeDeclaration generatedClass, CodeMemberMethod executeMethod)
{
if (_visibility.Equals("Public", StringComparison.OrdinalIgnoreCase))
{
generatedClass.TypeAttributes = generatedClass.TypeAttributes & ~TypeAttributes.VisibilityMask | TypeAttributes.Public;
}
else if (_visibility.Equals("Internal", StringComparison.OrdinalIgnoreCase))
{
generatedClass.TypeAttributes = generatedClass.TypeAttributes & ~TypeAttributes.VisibilityMask | TypeAttributes.NestedFamANDAssem;
}
}
public string GenerateInitializeComponentMethodBody(IDesignerHost host, IDesignerSerializationManager serializationManager, string rootNamespace, int initialIndent)
{
CodeMemberMethod method = FindInitializeComponentMethod(host, serializationManager);
return(GenerateMethodBody(host.RootComponent, method, serializationManager, rootNamespace, initialIndent));
}
private void GenEntityEx(CodeNamespace ns, Type type, int outLang)
{
CodeTypeDeclaration entity;
StringBuilder sb = new StringBuilder();
entity = new CodeTypeDeclaration(type.Name);
ns.Types.Add(entity);
entity.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(System.SerializableAttribute).Name));
entity.IsClass = true;
entity.IsPartial = true;
Type[] interfaces = GetContractInterfaceTypes(type);
bool findNonEntityBaseEntity = false;
string entityBaseTypeName = null;
foreach (Type item in interfaces)
{
if (typeof(IEntity).IsAssignableFrom(item) && (typeof(IEntity) != item))
{
entityBaseTypeName = item.Name;
entity.BaseTypes.Add(entityBaseTypeName);
findNonEntityBaseEntity = true;
break;
}
}
if (!findNonEntityBaseEntity)
{
entity.BaseTypes.Add(typeof(Entity));
}
string tableName = GetTableName(type);
DescriptionAttribute ca = GetEntityAttribute <DescriptionAttribute>(type);
#region 获取主键列
StringBuilder sbKey = new StringBuilder();
List <string> listKey = new List <string>();
GenGetPrimaryKeyFieldListEx(sbKey, type, listKey, outLang);
#endregion
if (ca != null)
{
//sb.Append("\t/// <summary>\r\n");
//sb.Append("\t/// ");
//sb.Append(ca.Description.Replace("\n", "\n\t/// "));
//sb.Append("\r\n\t/// </summary>\r\n");
entity.Comments.Add(new CodeCommentStatement("<summary>", true));
entity.Comments.Add(new CodeCommentStatement(ca.Description + string.Format(" - 表名：{0} 主键列：{1}", tableName, string.Join(",", listKey.ToArray())), true));
entity.Comments.Add(new CodeCommentStatement("</summary>", true));
}
else
{
entity.Comments.Add(new CodeCommentStatement("<summary>", true));
entity.Comments.Add(new CodeCommentStatement(string.Format("表名：{0} 主键列：{1}", tableName, string.Join(",", listKey.ToArray())), true));
entity.Comments.Add(new CodeCommentStatement("</summary>", true));
}
bool isReadonly = false;
ReadOnlyAttribute read = GetEntityAttribute <ReadOnlyAttribute>(type);
if (read != null)
{
isReadonly = true;
}
//generate properties
CodeStatementCollection reloadQueryStatements = new CodeStatementCollection();
GenPropertiesEx(entity, reloadQueryStatements, type, isReadonly, outLang);
List <string> generatedProperties = new List <string>();
CodeMemberMethod method;
CodeExpression[] arrayInit;
StringBuilder sbPropertyValuesList;
string[] fieldsList;
#region 实现重载的信息
#region 重载获取表名和只读
CodeTypeReference reference = new CodeTypeReference(typeof(Table).FullName, new CodeTypeReference(type.Name, CodeTypeReferenceOptions.GenericTypeParameter));
CodeExpression codeExpression = new CodeObjectCreateExpression(reference, new CodeExpression[] { new CodePrimitiveExpression(tableName) });
//生成重载的方法
method = new CodeMemberMethod();
method.Name = "GetTable";
method.Attributes = MemberAttributes.Family | MemberAttributes.Override;
method.ReturnType = new CodeTypeReference(typeof(Table));
//添加注释
method.Comments.Add(new CodeCommentStatement("<summary>", true));
method.Comments.Add(new CodeCommentStatement("获取实体对应的表名", true));
method.Comments.Add(new CodeCommentStatement("</summary>", true));
//CodeAssignStatement ass = new CodeAssignStatement();
//ass.Left = new CodeSnippetExpression("mappingTable");
//ass.Right = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeSnippetExpression("EntityConfig"), "GetTable"), new CodePrimitiveExpression(tableName));
//CodeConditionStatement condition = new CodeConditionStatement();
//condition.Condition = new CodeBinaryOperatorExpression(new CodePrimitiveExpression(null), CodeBinaryOperatorType.IdentityEquality, new CodeSnippetExpression("mappingTable"));
//condition.TrueStatements.Add(ass);
//method.Statements.Add(condition);
//method.Statements.Add(new CodeMethodReturnStatement(new CodeSnippetExpression("mappingTable")));
//entity.Members.Add(method);
//new CodeTypeReference(type.Name,
method.Statements.Add(new CodeMethodReturnStatement(codeExpression));
entity.Members.Add(method);
if (isReadonly)
{
method = new CodeMemberMethod();
method.Name = "GetReadOnly";
method.Attributes = MemberAttributes.Family | MemberAttributes.Override;
method.ReturnType = new CodeTypeReference(typeof(bool));
//添加注释
method.Comments.Add(new CodeCommentStatement("<summary>", true));
method.Comments.Add(new CodeCommentStatement("获取实体是否只读", true));
method.Comments.Add(new CodeCommentStatement("</summary>", true));
method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(true)));
entity.Members.Add(method);
}
SequenceAttribute auto = GetEntityAttribute <SequenceAttribute>(type);
if (auto != null)
{
method = new CodeMemberMethod();
method.Name = "GetSequence";
method.Attributes = MemberAttributes.Family | MemberAttributes.Override;
method.ReturnType = new CodeTypeReference(typeof(string));
//添加注释
method.Comments.Add(new CodeCommentStatement("<summary>", true));
method.Comments.Add(new CodeCommentStatement("获取自增长列的名称", true));
method.Comments.Add(new CodeCommentStatement("</summary>", true));
method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(auto.Name)));
entity.Members.Add(method);
}
#endregion
sbPropertyValuesList = new StringBuilder();
generatedProperties.Clear();
//sb.Append("\t\tpublic override object[] GetPropertyValues()\r\n\t\t{\r\n");
//sb.Append("\t\t\treturn new object[] { ");
GenGetIdentityFieldEx(sbPropertyValuesList, type, generatedProperties, outLang);
//sb.Append(sbPropertyValuesList.ToString().TrimEnd(' ', ','));
//sb.Append(" };\r\n\t\t}\r\n\r\n");
fieldsList = sbPropertyValuesList.ToString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (generatedProperties.Count > 0)
{
method = new CodeMemberMethod();
method.Name = "GetIdentityField";
method.Attributes = MemberAttributes.Family | MemberAttributes.Override;
method.ReturnType = new CodeTypeReference(typeof(Field));
//添加注释
method.Comments.Add(new CodeCommentStatement("<summary>", true));
method.Comments.Add(new CodeCommentStatement("获取实体中的标识列", true));
method.Comments.Add(new CodeCommentStatement("</summary>", true));
method.Statements.Add(new CodeMethodReturnStatement(new CodeSnippetExpression(fieldsList[0].Trim())));
entity.Members.Add(method);
}
sbPropertyValuesList = new StringBuilder();
generatedProperties.Clear();
//sb.Append("\t\tpublic override object[] GetPropertyValues()\r\n\t\t{\r\n");
//sb.Append("\t\t\treturn new object[] { ");
GenGetPrimaryKeyFieldListEx(sbPropertyValuesList, type, generatedProperties, outLang);
//sb.Append(sbPropertyValuesList.ToString().TrimEnd(' ', ','));
//sb.Append(" };\r\n\t\t}\r\n\r\n");
fieldsList = sbPropertyValuesList.ToString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
arrayInit = new CodeExpression[fieldsList.Length];
for (int i = 0; i < fieldsList.Length; i++)
{
arrayInit[i] = new CodeSnippetExpression(fieldsList[i].Trim());
}
if (arrayInit.Length > 0)
{
method = new CodeMemberMethod();
method.Name = "GetPrimaryKeyFields";
method.Attributes = MemberAttributes.Family | MemberAttributes.Override;
method.ReturnType = new CodeTypeReference(new CodeTypeReference(typeof(Field)), 1);
//添加注释
method.Comments.Add(new CodeCommentStatement("<summary>", true));
method.Comments.Add(new CodeCommentStatement("获取实体中的主键列", true));
method.Comments.Add(new CodeCommentStatement("</summary>", true));
method.Statements.Add(new CodeMethodReturnStatement(new CodeArrayCreateExpression(typeof(Field), arrayInit)));
entity.Members.Add(method);
}
method = new CodeMemberMethod();
method.Name = "GetFields";
method.Attributes = MemberAttributes.Family | MemberAttributes.Override;
method.ReturnType = new CodeTypeReference(new CodeTypeReference(typeof(Field)), 1);
sbPropertyValuesList = new StringBuilder();
generatedProperties.Clear();
//sb.Append("\t\tpublic override object[] GetPropertyValues()\r\n\t\t{\r\n");
//sb.Append("\t\t\treturn new object[] { ");
GenGetFieldListEx(sbPropertyValuesList, type, generatedProperties, outLang);
//sb.Append(sbPropertyValuesList.ToString().TrimEnd(' ', ','));
//sb.Append(" };\r\n\t\t}\r\n\r\n");
fieldsList = sbPropertyValuesList.ToString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
arrayInit = new CodeExpression[generatedProperties.Count];
for (int i = 0; i < generatedProperties.Count; i++)
{
arrayInit[i] = new CodeSnippetExpression(fieldsList[i].Trim());
}
if (arrayInit.Length > 0)
{
//添加注释
method.Comments.Add(new CodeCommentStatement("<summary>", true));
method.Comments.Add(new CodeCommentStatement(string.Format("获取列信息"), true));
method.Comments.Add(new CodeCommentStatement("</summary>", true));
method.Statements.Add(new CodeMethodReturnStatement(new CodeArrayCreateExpression(typeof(Field), arrayInit)));
entity.Members.Add(method);
}
#endregion
method = new CodeMemberMethod();
method.Name = "GetValues";
method.Attributes = MemberAttributes.Family | MemberAttributes.Override;
method.ReturnType = new CodeTypeReference(new CodeTypeReference(typeof(object)), 1);
sbPropertyValuesList = new StringBuilder();
generatedProperties.Clear();
//sb.Append("\t\tpublic override object[] GetPropertyValues()\r\n\t\t{\r\n");
//sb.Append("\t\t\treturn new object[] { ");
GenGetPropertyValues(sbPropertyValuesList, type, generatedProperties);
//sb.Append(sbPropertyValuesList.ToString().TrimEnd(' ', ','));
//sb.Append(" };\r\n\t\t}\r\n\r\n");
fieldsList = sbPropertyValuesList.ToString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
arrayInit = new CodeExpression[generatedProperties.Count];
for (int i = 0; i < generatedProperties.Count; i++)
{
arrayInit[i] = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), fieldsList[i].Trim());
}
if (arrayInit.Length > 0)
{
//添加注释
method.Comments.Add(new CodeCommentStatement("<summary>", true));
method.Comments.Add(new CodeCommentStatement(string.Format("获取列数据"), true));
method.Comments.Add(new CodeCommentStatement("</summary>", true));
method.Statements.Add(new CodeMethodReturnStatement(new CodeArrayCreateExpression(typeof(object), arrayInit)));
entity.Members.Add(method);
}
else
{
method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
entity.Members.Add(method);
}
method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Family | MemberAttributes.Override;
method.Name = "SetValues";
method.ReturnType = null;
//添加注释
method.Comments.Add(new CodeCommentStatement("<summary>", true));
method.Comments.Add(new CodeCommentStatement("给当前实体赋值", true));
method.Comments.Add(new CodeCommentStatement("</summary>", true));
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IRowReader), "reader"));
//sb.Append("\t\tpublic override void SetPropertyValues(System.Data.IDataReader reader)\r\n\t\t{\r\n");
generatedProperties.Clear();
GenSetPropertyValuesFromReaderEx(method.Statements, type, generatedProperties, outLang);
entity.Members.Add(method);
//outNs + "." +
string entityOutputTypeName = type.Name;
//, CodeTypeReferenceOptions.GlobalReference
CodeTypeReference entityOutputTypeNameRef = new CodeTypeReference(entityOutputTypeName);
//sb.Append("\t\tpublic override int GetHashCode() { return base.GetHashCode(); }\r\n\r\n");
method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.Name = "GetHashCode";
method.ReturnType = new CodeTypeReference(typeof(int));
method.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), "GetHashCode", new CodeExpression[] { })));
entity.Members.Add(method);
//sb.Append("\t\tpublic override bool Equals(object obj)\r\n\t\t{\r\n\t\t\treturn obj == null || (!(obj is " + entityOutputTypeName + ")) ? false : ((object)this) == ((object)obj) ? true : this.isAttached && ((" + entityOutputTypeName + ")obj).isAttached");
method = new CodeMemberMethod();
method.Name = "Equals";
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.ReturnType = new CodeTypeReference(typeof(bool));
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "obj"));
//if (obj == null) return false;
//if ((obj is global::Entities.LocalUser) == false) return false;
//if (((object)this) == ((object)obj)) return true;
//return this.isAttached && ((global::Entities.LocalUser)obj).isAttached && this.ID == ((global::Entities.LocalUser)obj).ID;
method.Statements.Add(new CodeConditionStatement(new CodeBinaryOperatorExpression(new CodeArgumentReferenceExpression("obj"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)), new CodeStatement[] { new CodeMethodReturnStatement(new CodePrimitiveExpression(false)) }));
method.Statements.Add(new CodeConditionStatement(new CodeBinaryOperatorExpression(new CodePrimitiveExpression(false), CodeBinaryOperatorType.ValueEquality, new CodeMethodInvokeExpression(new CodeTypeOfExpression(entityOutputTypeNameRef), "IsAssignableFrom", new CodeExpression[] { new CodeMethodInvokeExpression(new CodeArgumentReferenceExpression("obj"), "GetType", new CodeExpression[] { }) })), new CodeStatement[] { new CodeMethodReturnStatement(new CodePrimitiveExpression(false)) }));
method.Statements.Add(new CodeConditionStatement(new CodeBinaryOperatorExpression(new CodeCastExpression(typeof(object), new CodeThisReferenceExpression()), CodeBinaryOperatorType.IdentityEquality, new CodeCastExpression(typeof(object), new CodeArgumentReferenceExpression("obj"))), new CodeStatement[] { new CodeMethodReturnStatement(new CodePrimitiveExpression(true)) }));
method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(false)));
//sb.Append(";\r\n\t\t}\r\n");
entity.Members.Add(method);
//sb.Append("\r\n\t\t#endregion\r\n\r\n");
CodeTypeDeclaration queryClass = new CodeTypeDeclaration();
queryClass.IsClass = true;
queryClass.Name = outLang == 0 ? "_" : "__";
queryClass.Attributes = MemberAttributes.Public | MemberAttributes.Static;
if (findNonEntityBaseEntity)
{
queryClass.Attributes |= MemberAttributes.New;
}
entity.Members.Add(queryClass);
generatedProperties.Clear();
#region 添加All字段
if (interfaces.Length == 0)
{
CodeMemberField field = new CodeMemberField();
field.Name = "All";
field.Attributes = MemberAttributes.Public | MemberAttributes.Static;
field.Type = new CodeTypeReference(typeof(AllField));
//new CodeTypeReference(type.Name,
reference = new CodeTypeReference(typeof(AllField).FullName, new CodeTypeReference(type.Name, CodeTypeReferenceOptions.GenericTypeParameter));
field.InitExpression = new CodeObjectCreateExpression(reference);
//添加注释
field.Comments.Add(new CodeCommentStatement("<summary>", true));
field.Comments.Add(new CodeCommentStatement("表示选择所有列，与*等同", true));
field.Comments.Add(new CodeCommentStatement("</summary>", true));
queryClass.Members.Add(field);
}
#endregion
GenPropertyQueryCodeEx(queryClass, type, generatedProperties, isReadonly);
}
public static CodeGenerationResult GenerateProjectCode(GenerationOptions options, ProjectBackend[] projects)
{
ArrayList warningList = new ArrayList();
List <SteticCompilationUnit> units = new List <SteticCompilationUnit> ();
SteticCompilationUnit globalUnit = new SteticCompilationUnit("");
units.Add(globalUnit);
if (options == null)
{
options = new GenerationOptions();
}
CodeNamespace globalNs = new CodeNamespace(options.GlobalNamespace);
globalUnit.Namespaces.Add(globalNs);
// Global class
CodeTypeDeclaration globalType = new CodeTypeDeclaration("Gui");
globalType.Attributes = MemberAttributes.Private;
globalType.TypeAttributes = TypeAttributes.NestedAssembly;
globalNs.Types.Add(globalType);
// Create the project initialization method
// This method will only be added at the end if there
// is actually something to initialize
CodeMemberMethod initMethod = new CodeMemberMethod();
initMethod.Name = "Initialize";
initMethod.ReturnType = new CodeTypeReference(typeof(void));
initMethod.Attributes = MemberAttributes.Assembly | MemberAttributes.Static;
initMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Gtk.Widget), "iconRenderer"));
GeneratorContext initContext = new ProjectGeneratorContext(globalNs, globalType, initMethod.Statements, options);
initContext.RootObject = new CodeArgumentReferenceExpression("iconRenderer");
// Generate icon factory creation
foreach (ProjectBackend gp in projects)
{
if (gp.IconFactory.Icons.Count > 0)
{
gp.IconFactory.GenerateBuildCode(initContext);
}
}
warningList.AddRange(initContext.Warnings);
// Generate the code
if (options.UsePartialClasses)
{
CodeGeneratorPartialClass.GenerateProjectGuiCode(globalUnit, globalNs, globalType, options, units, projects, warningList);
}
else
{
CodeGeneratorInternalClass.GenerateProjectGuiCode(globalUnit, globalNs, globalType, options, units, projects, warningList);
}
GenerateProjectActionsCode(globalNs, options, projects);
// Final step. If there is some initialization code, add all needed infrastructure
globalType.Members.Add(initMethod);
CodeMemberField initField = new CodeMemberField(typeof(bool), "initialized");
initField.Attributes = MemberAttributes.Private | MemberAttributes.Static;
globalType.Members.Add(initField);
CodeFieldReferenceExpression initVar = new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(globalNs.Name + ".Gui"),
"initialized"
);
CodeConditionStatement initCondition = new CodeConditionStatement();
initCondition.Condition = new CodeBinaryOperatorExpression(
initVar,
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(false)
);
initCondition.TrueStatements.Add(new CodeAssignStatement(
initVar,
new CodePrimitiveExpression(true)
));
initCondition.TrueStatements.AddRange(initMethod.Statements);
initMethod.Statements.Clear();
initMethod.Statements.Add(initCondition);
return(new CodeGenerationResult(units.ToArray(), (string[])warningList.ToArray(typeof(string))));
}
public void AccessingFields()
{
var cd = new CodeTypeDeclaration("ClassWithFields") { IsClass = true };
var field = new CodeMemberField("System.String", "Microsoft");
field.Attributes = MemberAttributes.Public | MemberAttributes.Static;
field.InitExpression = new CodePrimitiveExpression("hi");
cd.Members.Add(field);
field = new CodeMemberField();
field.Name = "StaticPublicField";
field.Attributes = MemberAttributes.Public | MemberAttributes.Static;
field.Type = new CodeTypeReference(typeof(int));
field.InitExpression = new CodePrimitiveExpression(5);
cd.Members.Add(field);
field = new CodeMemberField();
field.Name = "NonStaticPublicField";
field.Attributes = MemberAttributes.Public | MemberAttributes.Final;
field.Type = new CodeTypeReference(typeof(int));
field.InitExpression = new CodePrimitiveExpression(6);
cd.Members.Add(field);
field = new CodeMemberField();
field.Name = "PrivateField";
field.Attributes = MemberAttributes.Private | MemberAttributes.Final;
field.Type = new CodeTypeReference(typeof(int));
field.InitExpression = new CodePrimitiveExpression(7);
cd.Members.Add(field);
var cmm = new CodeMemberMethod();
cmm.Name = "UsePrivateField";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i"));
cmm.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "PrivateField"), new CodeVariableReferenceExpression("i")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "PrivateField")));
cd.Members.Add(cmm);
AssertEqual(cd,
@"Public Class ClassWithFields
Public Shared Microsoft As String = ""hi""
Public Shared StaticPublicField As Integer = 5
Public NonStaticPublicField As Integer = 6
Private PrivateField As Integer = 7
Public Function UsePrivateField(ByVal i As Integer) As Integer
Me.PrivateField = i
Return Me.PrivateField
End Function
End Class");
}
CodeMemberMethod GenerateOperationMethod(CodeTypeDeclaration type, ContractDescription cd, OperationDescription od, bool async, out CodeTypeReference returnType)
{
CodeMemberMethod cm = new CodeMemberMethod();
if (od.Behaviors.Find <XmlSerializerMappingBehavior> () != null)
{
cm.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlSerializerFormatAttribute))));
}
if (async)
{
cm.Name = "Begin" + od.Name;
}
else
{
cm.Name = od.Name;
}
if (od.SyncMethod != null)
{
ExportParameters(cm, od.SyncMethod.GetParameters());
if (async)
{
AddBeginAsyncArgs(cm);
cm.ReturnType = new CodeTypeReference(typeof(IAsyncResult));
}
else
{
cm.ReturnType = new CodeTypeReference(od.SyncMethod.ReturnType);
}
returnType = new CodeTypeReference(od.SyncMethod.ReturnType);
}
else
{
ExportMessages(od.Messages, cm, false);
returnType = cm.ReturnType;
if (async)
{
AddBeginAsyncArgs(cm);
cm.ReturnType = new CodeTypeReference(typeof(IAsyncResult));
}
}
// [OperationContract (Action = "...", ReplyAction = "..")]
var ad = new CodeAttributeDeclaration(new CodeTypeReference(typeof(OperationContractAttribute)));
foreach (MessageDescription md in od.Messages)
{
if (md.Direction == MessageDirection.Input)
{
ad.Arguments.Add(new CodeAttributeArgument("Action", new CodePrimitiveExpression(md.Action)));
}
else
{
ad.Arguments.Add(new CodeAttributeArgument("ReplyAction", new CodePrimitiveExpression(md.Action)));
}
}
if (async)
{
ad.Arguments.Add(new CodeAttributeArgument("AsyncPattern", new CodePrimitiveExpression(true)));
}
cm.CustomAttributes.Add(ad);
return(cm);
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
CodeNamespace nspace = new CodeNamespace ("NSPC");
nspace.Imports.Add (new CodeNamespaceImport ("System"));
cu.Namespaces.Add (nspace);
CodeTypeDeclaration cd = new CodeTypeDeclaration ("TestingStructs");
cd.IsClass = true;
nspace.Types.Add (cd);
if (Supports (provider, GeneratorSupport.DeclareValueTypes)) {
// GENERATES (C#):
// public int CallingStructMethod(int i) {
// StructImplementation o = new StructImplementation ();
// return o.StructMethod(i);
// }
AddScenario ("CheckCallingStructMethod");
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "CallingStructMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i"));
cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference ("StructImplementation"), "o", new
CodeObjectCreateExpression (new CodeTypeReference ("StructImplementation"))));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeMethodInvokeExpression (new CodeMethodReferenceExpression (
new CodeVariableReferenceExpression ("o"),
"StructMethod"), new CodeArgumentReferenceExpression ("i"))));
cd.Members.Add (cmm);
// GENERATES (C#):
// public int UsingValueStruct(int i) {
// ValueStruct StructObject = new ValueStruct();
// StructObject.x = i;
// return StructObject.x;
// }
AddScenario ("CheckUsingValueStruct");
cmm = new CodeMemberMethod ();
cmm.Name = "UsingValueStruct";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i"));
cmm.Statements.Add (new CodeVariableDeclarationStatement ("ValueStruct", "StructObject", new
CodeObjectCreateExpression ("ValueStruct")));
cmm.Statements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression (new CodeVariableReferenceExpression ("StructObject"), "x"),
new CodeArgumentReferenceExpression ("i")));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeFieldReferenceExpression (new
CodeVariableReferenceExpression ("StructObject"), "x")));
cd.Members.Add (cmm);
// GENERATES (C#):
// public int UsingStructProperty(int i) {
// StructImplementation StructObject = new StructImplementation();
// StructObject.UseIField = i;
// return StructObject.UseIField;
// }
AddScenario ("CheckUsingStructProperty");
cmm = new CodeMemberMethod ();
cmm.Name = "UsingStructProperty";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i"));
cmm.Statements.Add (new CodeVariableDeclarationStatement ("StructImplementation", "StructObject", new
CodeObjectCreateExpression ("StructImplementation")));
cmm.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (
new CodeVariableReferenceExpression ("StructObject"), "UseIField"),
new CodeArgumentReferenceExpression ("i")));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodePropertyReferenceExpression (new
CodeVariableReferenceExpression ("StructObject"), "UseIField")));
cd.Members.Add (cmm);
// GENERATES (C#):
// public int UsingInterfaceStruct(int i) {
// ImplementInterfaceStruct IStructObject = new ImplementInterfaceStruct();
// return IStructObject.InterfaceMethod(i);
// }
if (Supports (provider, GeneratorSupport.DeclareInterfaces)) {
AddScenario ("CheckUsingInterfaceStruct");
// method to test struct implementing interfaces
cmm = new CodeMemberMethod ();
cmm.Name = "UsingInterfaceStruct";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i"));
cmm.Statements.Add (new CodeVariableDeclarationStatement ("ImplementInterfaceStruct", "IStructObject", new
CodeObjectCreateExpression ("ImplementInterfaceStruct")));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeMethodInvokeExpression (
new CodeVariableReferenceExpression ("IStructObject"), "InterfaceMethod",
new CodeArgumentReferenceExpression ("i"))));
cd.Members.Add (cmm);
}
// GENERATES (C#):
// public struct StructImplementation {
// int i;
// public int UseIField {
// get {
// return i;
// }
// set {
// i = value;
// }
// }
// public int StructMethod(int i) {
// return (5 + i);
// }
// }
cd = new CodeTypeDeclaration ("StructImplementation");
cd.IsStruct = true;
nspace.Types.Add (cd);
// declare an integer field
CodeMemberField field = new CodeMemberField (new CodeTypeReference (typeof (int)), "i");
field.Attributes = MemberAttributes.Public;
cd.Members.Add (field);
CodeMemberProperty prop = new CodeMemberProperty ();
prop.Name = "UseIField";
prop.Type = new CodeTypeReference (typeof (int));
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
CodeFieldReferenceExpression fref = new CodeFieldReferenceExpression ();
fref.FieldName = "i";
prop.GetStatements.Add (new CodeMethodReturnStatement (fref));
prop.SetStatements.Add (new CodeAssignStatement (fref,
new CodePropertySetValueReferenceExpression ()));
cd.Members.Add (prop);
cmm = new CodeMemberMethod ();
cmm.Name = "StructMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = (cmm.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i"));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
new CodePrimitiveExpression (5), CodeBinaryOperatorType.Add, new CodeArgumentReferenceExpression ("i"))));
cd.Members.Add (cmm);
// GENERATES (C#):
// public struct ValueStruct {
// public int x;
// }
cd = new CodeTypeDeclaration ("ValueStruct");
cd.IsStruct = true;
nspace.Types.Add (cd);
// declare an integer field
field = new CodeMemberField (new CodeTypeReference (typeof (int)), "x");
field.Attributes = MemberAttributes.Public;
cd.Members.Add (field);
if (Supports (provider, GeneratorSupport.DeclareInterfaces)) {
// interface to be implemented
// GENERATES (C#):
// public interface InterfaceStruct {
// int InterfaceMethod(int i);
// }
cd = new CodeTypeDeclaration ("InterfaceStruct");
cd.IsInterface = true;
nspace.Types.Add (cd);
// method in the interface
cmm = new CodeMemberMethod ();
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i"));
cd.Members.Add (cmm);
// struct to implement an interface
// GENERATES (C#):
// public struct ImplementInterfaceStruct : InterfaceStruct {
// public int InterfaceMethod(int i) {
// return (8 + i);
// }
// }
cd = new CodeTypeDeclaration ("ImplementInterfaceStruct");
cd.BaseTypes.Add (new CodeTypeReference ("InterfaceStruct"));
cd.IsStruct = true;
nspace.Types.Add (cd);
field = new CodeMemberField (new CodeTypeReference (typeof (int)), "i");
field.Attributes = MemberAttributes.Public;
cd.Members.Add (field);
// implement interface method
cmm = new CodeMemberMethod ();
cmm.Name = "InterfaceMethod";
cmm.ImplementationTypes.Add (new CodeTypeReference ("InterfaceStruct"));
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (new CodePrimitiveExpression (8),
CodeBinaryOperatorType.Add,
new CodeArgumentReferenceExpression ("i"))));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i"));
cd.Members.Add (cmm);
}
}
}
CodeMemberMethod GenerateImplementationClientMethod(CodeTypeDeclaration type, ContractDescription cd, OperationDescription od, bool async, out CodeTypeReference returnTypeFromMessageContract)
{
CodeMemberMethod cm = new CodeMemberMethod();
if (async)
{
cm.Name = "Begin" + od.Name;
}
else
{
cm.Name = od.Name;
}
cm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
returnTypeFromMessageContract = null;
List <CodeExpression> args = new List <CodeExpression> ();
if (od.SyncMethod != null)
{
ParameterInfo [] pars = od.SyncMethod.GetParameters();
ExportParameters(cm, pars);
cm.ReturnType = new CodeTypeReference(od.SyncMethod.ReturnType);
int i = 0;
foreach (ParameterInfo pi in pars)
{
args.Add(new CodeArgumentReferenceExpression(pi.Name));
}
}
else
{
args.AddRange(ExportMessages(od.Messages, cm, true));
returnTypeFromMessageContract = cm.ReturnType;
if (async)
{
AddBeginAsyncArgs(cm);
cm.ReturnType = new CodeTypeReference(typeof(IAsyncResult));
}
}
if (async)
{
args.Add(new CodeArgumentReferenceExpression("asyncCallback"));
args.Add(new CodeArgumentReferenceExpression("userState"));
}
CodeExpression call = new CodeMethodInvokeExpression(
new CodePropertyReferenceExpression(
new CodeBaseReferenceExpression(),
"Channel"),
cm.Name,
args.ToArray());
if (cm.ReturnType.BaseType == "System.Void")
{
cm.Statements.Add(new CodeExpressionStatement(call));
}
else
{
cm.Statements.Add(new CodeMethodReturnStatement(call));
}
return(cm);
}
protected override void GenerateMethod(CodeMemberMethod e, CodeTypeDeclaration c)
{
}
public void DocComments()
{
CodeNamespace ns = new CodeNamespace("System");
ns.Comments.Add(new CodeCommentStatement("Some comment on a namespace"));
CodeTypeDeclaration cd = new CodeTypeDeclaration("MyType");
cd.Comments.Add(new CodeCommentStatement("<summary>Insightful comment</summary>", docComment: true));
ns.Types.Add(cd);
CodeMemberMethod cmm = new CodeMemberMethod() { Name = "SomeMethod" };
cmm.Comments.Add(new CodeCommentStatement("<summary>Another insightful comment</summary>", docComment: true));
cd.Members.Add(cmm);
AssertEqual(ns,
@"'Some comment on a namespace
Namespace System
'''<summary>Insightful comment</summary>
Public Class MyType
'''<summary>Another insightful comment</summary>
Private Sub SomeMethod()
End Sub
End Class
End Namespace");
}
public void ForLoops()
{
CodeNamespace nspace = new CodeNamespace("NSPC");
CodeTypeDeclaration class1 = new CodeTypeDeclaration("ClassWithMethod");
class1.IsClass = true;
nspace.Types.Add(class1);
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = "TestBasicIterationStatement";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "i"));
cmm.Statements.Add(new CodeIterationStatement(new CodeAssignStatement(new
CodeVariableReferenceExpression("i"), new CodePrimitiveExpression(1)),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(8)),
new CodeAssignStatement(new CodeVariableReferenceExpression("i"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Multiply,
new CodePrimitiveExpression(2)))));
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("i")));
class1.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "TestComplexIterationStatement";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "i"));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "a", new CodePrimitiveExpression(7)));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "b"));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "c", new CodePrimitiveExpression(9)));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int)), "d", new CodePrimitiveExpression(2)));
CodeIterationStatement iteration = new CodeIterationStatement();
iteration.IncrementStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("i"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1)));
iteration.InitStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("i"), new
CodePrimitiveExpression(0));
iteration.TestExpression = (new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(2)));
CodeConditionStatement secondIf = new CodeConditionStatement(new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("c"), CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(10)),
new CodeAssignStatement(new CodeVariableReferenceExpression("d"), new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("d"), CodeBinaryOperatorType.Subtract, new CodePrimitiveExpression(1))));
CodeIterationStatement secondFor = new CodeIterationStatement();
secondFor.Statements.Add(secondIf);
secondFor.IncrementStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("b"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("b"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1)));
secondFor.InitStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("b"), new
CodePrimitiveExpression(0));
secondFor.TestExpression = (new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("b"),
CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(2)));
secondFor.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("d"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("d"), CodeBinaryOperatorType.Multiply,
new CodePrimitiveExpression(2))));
CodeConditionStatement firstIf = new CodeConditionStatement();
firstIf.Condition = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.LessThan,
new CodePrimitiveExpression(16));
firstIf.TrueStatements.Add(secondFor);
iteration.Statements.Add(firstIf);
cmm.Statements.Add(iteration);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("d")));
class1.Members.Add(cmm);
AssertEqual(nspace,
@"Namespace NSPC
Public Class ClassWithMethod
Public Shared Function TestBasicIterationStatement() As Integer
Dim i As Integer
i = 1
Do While (i < 8)
i = (i * 2)
Loop
Return i
End Function
Public Shared Function TestComplexIterationStatement() As Integer
Dim i As Integer
Dim a As Integer = 7
Dim b As Integer
Dim c As Integer = 9
Dim d As Integer = 2
i = 0
Do While (i < 2)
If (a < 16) Then
b = 0
Do While (b < 2)
If (c < 10) Then
d = (d - 1)
End If
d = (d * 2)
b = (b + 1)
Loop
End If
i = (i + 1)
Loop
Return d
End Function
End Class
End Namespace");
}
public void Conditionals()
{
CodeTypeDeclaration class1 = new CodeTypeDeclaration("ClassWithMethod");
class1.IsClass = true;
CodeMemberMethod retMethod = new CodeMemberMethod();
retMethod.Name = "ReturnMethod";
retMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static;
retMethod.ReturnType = new CodeTypeReference(typeof(int));
retMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "intInput"));
retMethod.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("intInput"),
CodeBinaryOperatorType.LessThanOrEqual,
new CodePrimitiveExpression(3)),
CodeBinaryOperatorType.BooleanAnd,
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("intInput"),
CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(2))),
new CodeStatement[] { CreateVariableIncrementExpression("intInput", 16) },
new CodeStatement[] { CreateVariableIncrementExpression("intInput", 1) }));
retMethod.Statements.Add(new CodeConditionStatement(
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("intInput"), CodeBinaryOperatorType.LessThanOrEqual,
new CodePrimitiveExpression(10)),
new CodeAssignStatement(new CodeVariableReferenceExpression("intInput"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("intInput"),
CodeBinaryOperatorType.Add, new CodePrimitiveExpression(11)))));
retMethod.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("intInput")));
class1.Members.Add(retMethod);
AssertEqual(class1,
@"Public Class ClassWithMethod
Public Shared Function ReturnMethod(ByVal intInput As Integer) As Integer
If ((intInput <= 3) _
AndAlso (intInput = 2)) Then
intInput = (intInput + 16)
Else
intInput = (intInput + 1)
End If
If (intInput <= 10) Then
intInput = (intInput + 11)
End If
Return intInput
End Function
End Class");
}
public void AddMethod(CodeTypeDeclaration t, CodeNamespace ns, CodeMemberMethod m, AssemblyRefList imports, VariableList parameters, List <IPropertyPointer> pointerList)
{
CreateTestMethod(result, t, ns, m, imports, parameters, pointerList);
}
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");
}
private void ImplementSetParentMethod(IReference input, CodeTypeDeclaration output, CodeTypeReference elementTypeReference, CodeMemberMethod method, ITransformationContext context)
{
var opposite = input.Opposite;
var item = new CodeArgumentReferenceExpression("item");
var parent = new CodeArgumentReferenceExpression("parent");
var thisRef = new CodeThisReferenceExpression();
var nullRef = new CodePrimitiveExpression(null);
var item_opp = new CodePropertyReferenceExpression(item, context.Trace.ResolveIn(Rule <Reference2Property>(), opposite).Name);
var ifNotNull = new CodeConditionStatement(new CodeBinaryOperatorExpression(parent, CodeBinaryOperatorType.IdentityInequality, nullRef));
var targetClass = input.Type;
var eventName = input.IsContainment ? "ParentChanged" : "Deleted";
var eventType = input.IsContainment ? typeof(ValueChangedEventArgs).ToTypeReference() : typeof(EventArgs).ToTypeReference();
var onItemDeleted = new CodeMemberMethod()
{
Name = "OnItem" + eventName,
Attributes = MemberAttributes.Private,
ReturnType = new CodeTypeReference(typeof(void))
};
onItemDeleted.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender"));
onItemDeleted.Parameters.Add(new CodeParameterDeclarationExpression(eventType, "e"));
var actualRemove = new CodeMethodInvokeExpression(
thisRef, "Remove", new CodeCastExpression(elementTypeReference, new CodeArgumentReferenceExpression("sender")));
if (input.IsContainment)
{
var newValue = new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("e"), "NewValue");
var parentRef = new CodePropertyReferenceExpression(thisRef, "Parent");
onItemDeleted.Statements.Add(new CodeConditionStatement(new CodeBinaryOperatorExpression(newValue, CodeBinaryOperatorType.IdentityInequality, parentRef),
new CodeExpressionStatement(actualRemove)));
}
else
{
onItemDeleted.Statements.Add(actualRemove);
}
output.Members.Add(onItemDeleted);
ifNotNull.TrueStatements.Add(new CodeAttachEventStatement(item, eventName, new CodeMethodReferenceExpression(thisRef, onItemDeleted.Name)));
ifNotNull.FalseStatements.Add(new CodeRemoveEventStatement(item, eventName, new CodeMethodReferenceExpression(thisRef, onItemDeleted.Name)));
if (opposite.UpperBound == 1)
{
var assignStatement = new CodeAssignStatement(item_opp, parent);
ifNotNull.TrueStatements.Add(assignStatement);
ifNotNull.FalseStatements.Add(new CodeConditionStatement(new CodeBinaryOperatorExpression(
item_opp, CodeBinaryOperatorType.IdentityEquality, new CodePropertyReferenceExpression(thisRef, "Parent")),
assignStatement));
}
else
{
ifNotNull.FalseStatements.Add(new CodeMethodInvokeExpression(item_opp, "Remove", new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Parent")));
ifNotNull.TrueStatements.Add(new CodeMethodInvokeExpression(item_opp, "Add", parent));
}
method.Statements.Add(ifNotNull);
}
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");
}
public void SetTestSetup(CodeMemberMethod memberMethod)
{
memberMethod.CustomAttributes.Add(
new CodeAttributeDeclaration(
new CodeTypeReference(TESTSETUP_ATTR)));
}
public void Arrays_WithinArrays_Empty_NonPrimitiveTypes()
{
var arrayMethod = new CodeMemberMethod();
arrayMethod.Name = "MoreArrayTests";
arrayMethod.Attributes = (arrayMethod.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
arrayMethod.ReturnType = new CodeTypeReference(typeof(int));
arrayMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
arrayMethod.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[])))));
arrayMethod.Statements.Add(new CodeVariableDeclarationStatement(
new CodeTypeReference("System.Int32", 1), "array2",
new CodeArrayCreateExpression(typeof(int[]), new CodePrimitiveExpression(0))));
arrayMethod.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("Class2", 1),
"arrayType", new CodeArrayCreateExpression(new CodeTypeReference("Class2", 1), new CodePrimitiveExpression(2))));
arrayMethod.Statements.Add(new CodeAssignStatement(new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("arrayType"),
new CodePrimitiveExpression(1)), new CodeObjectCreateExpression(new CodeTypeReference("Class2"))));
arrayMethod.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression
(new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("arrayType"),
new CodePrimitiveExpression(1)), "number"),
new CodeBinaryOperatorExpression(new CodeArrayIndexerExpression(
new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("arrayOfArrays"), new CodePrimitiveExpression(0)), new CodePrimitiveExpression(1)),
CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression("i"))));
arrayMethod.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression
(new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("arrayType"),
new CodePrimitiveExpression(1)), "number")));
AssertEqual(arrayMethod,
@"Public Function MoreArrayTests(ByVal i As Integer) As Integer
Dim arrayOfArrays()() As Integer = New Integer()() {New Integer() {3, 4}, New Integer((1) - 1) {}, New Integer(-1) {}}
Dim array2((0) - 1) As Integer
Dim arrayType((2) - 1) As Class2
arrayType(1) = New Class2()
arrayType(1).number = (arrayOfArrays(0)(1) + i)
Return arrayType(1).number
End Function");
}
void GenerateEventBasedAsyncSupport(CodeTypeDeclaration type, OperationDescription od, CodeNamespace cns)
{
var method = FindByName(type, od.Name) ?? FindByName(type, "Begin" + od.Name);
var endMethod = method.Name == od.Name ? null : FindByName(type, "End" + od.Name);
bool methodAsync = method.Name.StartsWith("Begin", StringComparison.Ordinal);
var resultType = endMethod != null ? endMethod.ReturnType : method.ReturnType;
var thisExpr = new CodeThisReferenceExpression();
var baseExpr = new CodeBaseReferenceExpression();
var nullExpr = new CodePrimitiveExpression(null);
var asyncResultType = new CodeTypeReference(typeof(IAsyncResult));
// OnBeginXxx() implementation
var cm = new CodeMemberMethod()
{
Name = "OnBegin" + od.Name,
Attributes = MemberAttributes.Private | MemberAttributes.Final,
ReturnType = asyncResultType
};
type.Members.Add(cm);
AddMethodParam(cm, typeof(object []), "args");
AddMethodParam(cm, typeof(AsyncCallback), "asyncCallback");
AddMethodParam(cm, typeof(object), "userState");
var call = new CodeMethodInvokeExpression(
thisExpr,
"Begin" + od.Name);
for (int idx = 0; idx < method.Parameters.Count - (methodAsync ? 2 : 0); idx++)
{
var p = method.Parameters [idx];
cm.Statements.Add(new CodeVariableDeclarationStatement(p.Type, p.Name, new CodeCastExpression(p.Type, new CodeArrayIndexerExpression(new CodeArgumentReferenceExpression("args"), new CodePrimitiveExpression(idx)))));
call.Parameters.Add(new CodeVariableReferenceExpression(p.Name));
}
call.Parameters.Add(new CodeArgumentReferenceExpression("asyncCallback"));
call.Parameters.Add(new CodeArgumentReferenceExpression("userState"));
cm.Statements.Add(new CodeMethodReturnStatement(call));
// OnEndXxx() implementation
cm = new CodeMemberMethod()
{
Name = "OnEnd" + od.Name,
Attributes = MemberAttributes.Private | MemberAttributes.Final,
ReturnType = new CodeTypeReference(typeof(object []))
};
type.Members.Add(cm);
AddMethodParam(cm, typeof(IAsyncResult), "result");
var outArgRefs = new List <CodeVariableReferenceExpression> ();
for (int idx = 0; idx < method.Parameters.Count; idx++)
{
var p = method.Parameters [idx];
if (p.Direction != FieldDirection.In)
{
cm.Statements.Add(new CodeVariableDeclarationStatement(p.Type, p.Name));
outArgRefs.Add(new CodeVariableReferenceExpression(p.Name)); // FIXME: should this work? They need "out" or "ref" modifiers.
}
}
call = new CodeMethodInvokeExpression(
thisExpr,
"End" + od.Name,
new CodeArgumentReferenceExpression("result"));
call.Parameters.AddRange(outArgRefs.Cast <CodeExpression> ().ToArray()); // questionable
var retCreate = new CodeArrayCreateExpression(typeof(object));
if (resultType.BaseType == "System.Void")
{
cm.Statements.Add(call);
}
else
{
cm.Statements.Add(new CodeVariableDeclarationStatement(typeof(object), "__ret", call));
retCreate.Initializers.Add(new CodeVariableReferenceExpression("__ret"));
}
foreach (var outArgRef in outArgRefs)
{
retCreate.Initializers.Add(new CodeVariableReferenceExpression(outArgRef.VariableName));
}
cm.Statements.Add(new CodeMethodReturnStatement(retCreate));
// OnXxxCompleted() implementation
cm = new CodeMemberMethod()
{
Name = "On" + od.Name + "Completed",
Attributes = MemberAttributes.Private | MemberAttributes.Final
};
type.Members.Add(cm);
AddMethodParam(cm, typeof(object), "state");
string argsname = identifiers.AddUnique(od.Name + "CompletedEventArgs", null);
var iaargs = new CodeTypeReference("InvokeAsyncCompletedEventArgs"); // avoid messy System.Type instance for generic nested type :|
var iaref = new CodeVariableReferenceExpression("args");
var methodEventArgs = new CodeObjectCreateExpression(new CodeTypeReference(argsname),
new CodePropertyReferenceExpression(iaref, "Results"),
new CodePropertyReferenceExpression(iaref, "Error"),
new CodePropertyReferenceExpression(iaref, "Cancelled"),
new CodePropertyReferenceExpression(iaref, "UserState"));
cm.Statements.Add(new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeEventReferenceExpression(thisExpr, od.Name + "Completed"), CodeBinaryOperatorType.IdentityInequality, nullExpr),
new CodeVariableDeclarationStatement(iaargs, "args", new CodeCastExpression(iaargs, new CodeArgumentReferenceExpression("state"))),
new CodeExpressionStatement(new CodeMethodInvokeExpression(thisExpr, od.Name + "Completed", thisExpr, methodEventArgs))));
// delegate fields
type.Members.Add(new CodeMemberField(new CodeTypeReference("BeginOperationDelegate"), "onBegin" + od.Name + "Delegate"));
type.Members.Add(new CodeMemberField(new CodeTypeReference("EndOperationDelegate"), "onEnd" + od.Name + "Delegate"));
type.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(SendOrPostCallback)), "on" + od.Name + "CompletedDelegate"));
// XxxCompletedEventArgs class
var argsType = new CodeTypeDeclaration(argsname);
argsType.BaseTypes.Add(new CodeTypeReference(typeof(AsyncCompletedEventArgs)));
cns.Types.Add(argsType);
var argsCtor = new CodeConstructor()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final
};
argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object []), "results"));
argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Exception), "error"));
argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(bool), "cancelled"));
argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));
argsCtor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("error"));
argsCtor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("cancelled"));
argsCtor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("userState"));
var resultsField = new CodeFieldReferenceExpression(thisExpr, "results");
argsCtor.Statements.Add(new CodeAssignStatement(resultsField, new CodeArgumentReferenceExpression("results")));
argsType.Members.Add(argsCtor);
argsType.Members.Add(new CodeMemberField(typeof(object []), "results"));
if (resultType.BaseType != "System.Void")
{
var resultProp = new CodeMemberProperty
{
Name = "Result",
Type = resultType,
Attributes = MemberAttributes.Public | MemberAttributes.Final
};
resultProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeCastExpression(resultProp.Type, new CodeArrayIndexerExpression(resultsField, new CodePrimitiveExpression(0)))));
argsType.Members.Add(resultProp);
}
// event field
var handlerType = new CodeTypeReference(typeof(EventHandler <>));
handlerType.TypeArguments.Add(new CodeTypeReference(argsType.Name));
type.Members.Add(new CodeMemberEvent()
{
Name = od.Name + "Completed",
Type = handlerType,
Attributes = MemberAttributes.Public | MemberAttributes.Final
});
// XxxAsync() implementations
bool hasAsync = false;
foreach (int __x in Enumerable.Range(0, 2))
{
cm = new CodeMemberMethod();
type.Members.Add(cm);
cm.Name = od.Name + "Async";
cm.Attributes = MemberAttributes.Public
| MemberAttributes.Final;
var inArgs = new List <CodeParameterDeclarationExpression> ();
for (int idx = 0; idx < method.Parameters.Count - (methodAsync ? 2 : 0); idx++)
{
var pd = method.Parameters [idx];
inArgs.Add(pd);
cm.Parameters.Add(pd);
}
// First one is overload without asyncState arg.
if (!hasAsync)
{
call = new CodeMethodInvokeExpression(thisExpr, cm.Name, inArgs.ConvertAll <CodeExpression> (decl => new CodeArgumentReferenceExpression(decl.Name)).ToArray());
call.Parameters.Add(nullExpr);
cm.Statements.Add(new CodeExpressionStatement(call));
hasAsync = true;
continue;
}
// Second one is the primary one.
cm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));
// if (onBeginBarOperDelegate == null) onBeginBarOperDelegate = new BeginOperationDelegate (OnBeginBarOper);
// if (onEndBarOperDelegate == null) onEndBarOperDelegate = new EndOperationDelegate (OnEndBarOper);
// if (onBarOperCompletedDelegate == null) onBarOperCompletedDelegate = new BeginOperationDelegate (OnBarOperCompleted);
var beginOperDelegateRef = new CodeFieldReferenceExpression(thisExpr, "onBegin" + od.Name + "Delegate");
var endOperDelegateRef = new CodeFieldReferenceExpression(thisExpr, "onEnd" + od.Name + "Delegate");
var operCompletedDelegateRef = new CodeFieldReferenceExpression(thisExpr, "on" + od.Name + "CompletedDelegate");
var ifstmt = new CodeConditionStatement(
new CodeBinaryOperatorExpression(beginOperDelegateRef, CodeBinaryOperatorType.IdentityEquality, nullExpr),
new CodeAssignStatement(beginOperDelegateRef, new CodeDelegateCreateExpression(new CodeTypeReference("BeginOperationDelegate"), thisExpr, "OnBegin" + od.Name)));
cm.Statements.Add(ifstmt);
ifstmt = new CodeConditionStatement(
new CodeBinaryOperatorExpression(endOperDelegateRef, CodeBinaryOperatorType.IdentityEquality, nullExpr),
new CodeAssignStatement(endOperDelegateRef, new CodeDelegateCreateExpression(new CodeTypeReference("EndOperationDelegate"), thisExpr, "OnEnd" + od.Name)));
cm.Statements.Add(ifstmt);
ifstmt = new CodeConditionStatement(
new CodeBinaryOperatorExpression(operCompletedDelegateRef, CodeBinaryOperatorType.IdentityEquality, nullExpr),
new CodeAssignStatement(operCompletedDelegateRef, new CodeDelegateCreateExpression(new CodeTypeReference(typeof(SendOrPostCallback)), thisExpr, "On" + od.Name + "Completed")));
cm.Statements.Add(ifstmt);
// InvokeAsync (onBeginBarOperDelegate, inValues, onEndBarOperDelegate, onBarOperCompletedDelegate, userState);
inArgs.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));
var args = new List <CodeExpression> ();
args.Add(beginOperDelegateRef);
args.Add(new CodeArrayCreateExpression(typeof(object), inArgs.ConvertAll <CodeExpression> (decl => new CodeArgumentReferenceExpression(decl.Name)).ToArray()));
args.Add(endOperDelegateRef);
args.Add(new CodeFieldReferenceExpression(thisExpr, "on" + od.Name + "CompletedDelegate"));
args.Add(new CodeArgumentReferenceExpression("userState"));
call = new CodeMethodInvokeExpression(baseExpr, "InvokeAsync", args.ToArray());
cm.Statements.Add(new CodeExpressionStatement(call));
}
}
static void GenerateProjectActionsCode(CodeNamespace cns, GenerationOptions options, params ProjectBackend[] projects)
{
bool multiProject = projects.Length > 1;
CodeTypeDeclaration type = new CodeTypeDeclaration("ActionGroups");
type.Attributes = MemberAttributes.Private;
type.TypeAttributes = TypeAttributes.NestedAssembly;
cns.Types.Add(type);
// Generate the global action group getter
CodeMemberMethod met = new CodeMemberMethod();
met.Name = "GetActionGroup";
type.Members.Add(met);
met.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Type), "type"));
if (multiProject)
{
met.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "file"));
}
met.ReturnType = new CodeTypeReference(typeof(Gtk.ActionGroup));
met.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeMethodInvokeExpression call = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression(new CodeTypeReference(cns.Name + ".ActionGroups")),
"GetActionGroup"
),
new CodePropertyReferenceExpression(
new CodeArgumentReferenceExpression("type"),
"FullName"
)
);
if (multiProject)
{
call.Parameters.Add(new CodeArgumentReferenceExpression("file"));
}
met.Statements.Add(new CodeMethodReturnStatement(call));
// Generate the global action group getter (overload)
met = new CodeMemberMethod();
met.Name = "GetActionGroup";
type.Members.Add(met);
met.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "name"));
if (multiProject)
{
met.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "file"));
}
met.ReturnType = new CodeTypeReference(typeof(Gtk.ActionGroup));
met.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeArgumentReferenceExpression cfile = new CodeArgumentReferenceExpression("file");
CodeArgumentReferenceExpression cid = new CodeArgumentReferenceExpression("name");
CodeStatementCollection projectCol = met.Statements;
int n = 1;
foreach (ProjectBackend gp in projects)
{
CodeStatementCollection widgetCol;
if (multiProject)
{
CodeConditionStatement pcond = new CodeConditionStatement();
pcond.Condition = new CodeBinaryOperatorExpression(
cfile,
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(gp.Id)
);
projectCol.Add(pcond);
widgetCol = pcond.TrueStatements;
projectCol = pcond.FalseStatements;
}
else
{
widgetCol = projectCol;
}
foreach (Wrapper.ActionGroup grp in gp.ActionGroups)
{
string fname = "group" + (n++);
CodeMemberField grpField = new CodeMemberField(new CodeTypeReference(typeof(Gtk.ActionGroup), CodeTypeReferenceOptions.GlobalReference), fname);
grpField.Attributes |= MemberAttributes.Static;
type.Members.Add(grpField);
CodeFieldReferenceExpression grpVar = new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(new CodeTypeReference(cns.Name + ".ActionGroups", CodeTypeReferenceOptions.GlobalReference)),
fname
);
CodeConditionStatement pcond = new CodeConditionStatement();
pcond.Condition = new CodeBinaryOperatorExpression(
cid,
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(grp.Name)
);
widgetCol.Add(pcond);
// If the group has not yet been created, create it
CodeConditionStatement pcondGrp = new CodeConditionStatement();
pcondGrp.Condition = new CodeBinaryOperatorExpression(
grpVar,
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)
);
pcondGrp.TrueStatements.Add(
new CodeAssignStatement(
grpVar,
new CodeObjectCreateExpression(grp.Name)
)
);
pcond.TrueStatements.Add(pcondGrp);
pcond.TrueStatements.Add(new CodeMethodReturnStatement(grpVar));
widgetCol = pcond.FalseStatements;
}
widgetCol.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
}
if (met.Statements.Count == 0)
{
met.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
}
}
public void MaskingVariables()
{
CodeNamespace ns = new CodeNamespace("ns");
CodeTypeDeclaration class1 = new CodeTypeDeclaration();
class1.Name = "Class1";
ns.Types.Add(class1);
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = "for";
class1.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "while";
cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public;
cmm.Statements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "for")));
class1.Members.Add(cmm);
class1 = new CodeTypeDeclaration();
class1.Name = "TestMasking";
ns.Types.Add(class1);
cmm = new CodeMemberMethod();
cmm.Name = "TestMasks";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.Attributes = MemberAttributes.Static | MemberAttributes.Public;
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("Class1"), "temp", new CodeObjectCreateExpression(new CodeTypeReference("Class1"))));
cmm.Statements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("temp"), "while")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("i")));
class1.Members.Add(cmm);
AssertEqual(ns,
@"Namespace ns
Public Class Class1
Private Sub [for]()
End Sub
Public Sub [while]()
Me.for
End Sub
End Class
Public Class TestMasking
Public Shared Function TestMasks(ByVal i As Integer) As Integer
Dim temp As Class1 = New Class1()
temp.while
Return i
End Function
End Class
End Namespace");
}
void AddMethodParam(CodeMemberMethod cm, Type type, string name)
{
cm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(type), name));
}
public void Indexers()
{
CodeNamespace nspace = new CodeNamespace("NSPC");
CodeTypeDeclaration cd = new CodeTypeDeclaration("TEST");
cd.IsClass = true;
nspace.Types.Add(cd);
CodeMemberField field = new CodeMemberField();
field.Name = "PublicField";
field.InitExpression = new CodeArrayCreateExpression(new CodeTypeReference(typeof(int)), new CodeExpression[]{
new CodePrimitiveExpression(0), new CodePrimitiveExpression(0),new CodePrimitiveExpression(0),new CodePrimitiveExpression(0),
new CodePrimitiveExpression(0),new CodePrimitiveExpression(0), new CodePrimitiveExpression(0)});
field.Attributes = MemberAttributes.Public | MemberAttributes.Final;
field.Type = new CodeTypeReference(typeof(int[]));
cd.Members.Add(field);
// nonarray indexers
CodeMemberProperty indexerProperty = new CodeMemberProperty();
indexerProperty.Name = "Item";
indexerProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final;
indexerProperty.Type = new CodeTypeReference(typeof(int));
indexerProperty.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i"));
// uses array indexer
indexerProperty.SetStatements.Add(new CodeAssignStatement(new CodeArrayIndexerExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression()
, "PublicField"), new CodeExpression[] { new CodeVariableReferenceExpression("i") }),
new CodeVariableReferenceExpression("value")));
indexerProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeArrayIndexerExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "PublicField"),
new CodeVariableReferenceExpression("i"))));
cd.Members.Add(indexerProperty);
// nonarray indexers
indexerProperty = new CodeMemberProperty();
indexerProperty.Name = "Item";
indexerProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final;
indexerProperty.Type = new CodeTypeReference(typeof(int));
indexerProperty.SetStatements.Add(new CodeAssignStatement(new CodeArrayIndexerExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression()
, "PublicField"), new CodeExpression[] { new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add,
new CodeVariableReferenceExpression("b"))}),
new CodeVariableReferenceExpression("value")));
indexerProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeArrayIndexerExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "PublicField"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression("b")))));
indexerProperty.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "a"));
indexerProperty.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "b"));
// uses array indexer
cd.Members.Add(indexerProperty);
cd = new CodeTypeDeclaration("UseTEST");
cd.IsClass = true;
nspace.Types.Add(cd);
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = "TestMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i"));
cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public;
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("TEST"),
"temp", new CodeObjectCreateExpression("TEST")));
cmm.Statements.Add(new CodeAssignStatement(new CodeIndexerExpression(
new CodeVariableReferenceExpression("temp"), new CodeExpression[] { new CodePrimitiveExpression(1) }),
new CodeVariableReferenceExpression("i")));
cmm.Statements.Add(new CodeAssignStatement(new CodeIndexerExpression(
new CodeVariableReferenceExpression("temp"), new CodeExpression[]{new CodePrimitiveExpression(2),
new CodePrimitiveExpression(4)}),
new CodePrimitiveExpression(83)));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
new CodeIndexerExpression(new CodeVariableReferenceExpression("temp"), new CodeExpression[] { new CodePrimitiveExpression(1) }),
CodeBinaryOperatorType.Add,
new CodeIndexerExpression(new CodeVariableReferenceExpression("temp"), new CodeExpression[] { new CodePrimitiveExpression(2), new CodePrimitiveExpression(4) }))));
cd.Members.Add(cmm);
AssertEqual(nspace,
@"Namespace NSPC
Public Class TEST
Public PublicField() As Integer = New Integer() {0, 0, 0, 0, 0, 0, 0}
Public Overloads Default Property Item(ByVal i As Integer) As Integer
Get
Return Me.PublicField(i)
End Get
Set
Me.PublicField(i) = value
End Set
End Property
Public Overloads Default Property Item(ByVal a As Integer, ByVal b As Integer) As Integer
Get
Return Me.PublicField((a + b))
End Get
Set
Me.PublicField((a + b)) = value
End Set
End Property
End Class
Public Class UseTEST
Public Function TestMethod(ByVal i As Integer) As Integer
Dim temp As TEST = New TEST()
temp(1) = i
temp(2, 4) = 83
Return (temp(1) + temp(2, 4))
End Function
End Class
End Namespace");
}
private CodeExpression[] ExportMessages(MessageDescriptionCollection messages, CodeMemberMethod method, bool return_args)
{
CodeExpression [] args = null;
foreach (MessageDescription md in messages)
{
if (md.Direction == MessageDirection.Output)
{
if (md.Body.ReturnValue != null)
{
ExportDataContract(md.Body.ReturnValue);
method.ReturnType = md.Body.ReturnValue.CodeTypeReference;
}
continue;
}
if (return_args)
{
args = new CodeExpression [md.Body.Parts.Count];
}
MessagePartDescriptionCollection parts = md.Body.Parts;
for (int i = 0; i < parts.Count; i++)
{
ExportDataContract(parts [i]);
method.Parameters.Add(
new CodeParameterDeclarationExpression(
parts [i].CodeTypeReference,
parts [i].Name));
if (return_args)
{
args [i] = new CodeArgumentReferenceExpression(parts [i].Name);
}
}
}
return(args);
}
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 CodeMemberMethod CreateCompositeKeyEqualsMethod(IList <string> columns)
{
if (columns.Count == 0)
{
return(null);
}
var method = new CodeMemberMethod
{
Name = "Equals",
ReturnType = new CodeTypeReference(typeof(bool)),
Attributes = MemberAttributes.Public | MemberAttributes.Override,
};
method.Parameters.Add(new CodeParameterDeclarationExpression("System.Object", "obj"));
// Create the if statement to compare if the obj equals another.
var compareCode = new StringBuilder();
var className = string.Format("{0}{1}", appPrefs.ClassNamePrefix, Formatter.FormatSingular(Table.Name));
if (appPrefs.Language == Language.CSharp)
{
method.Statements.Add(new CodeSnippetStatement("\t\t\tif (obj == null) return false;"));
method.Statements.Add(new CodeSnippetStatement(string.Format("\t\t\tvar t = obj as {0};", className)));
method.Statements.Add(new CodeSnippetStatement("\t\t\tif (t == null) return false;"));
compareCode.Append("\t\t\tif (");
var lastCol = columns.LastOrDefault();
foreach (var column in columns)
{
compareCode.Append(string.Format("{0} == t.{0}", column));
compareCode.Append(column != lastCol ? "\n\t\t\t && " : ")");
}
method.Statements.Add(new CodeSnippetStatement(compareCode.ToString()));
method.Statements.Add(new CodeSnippetStatement("\t\t\t\treturn true;"));
method.Statements.Add(new CodeSnippetStatement(string.Empty));
method.Statements.Add(new CodeSnippetStatement("\t\t\treturn false;"));
}
else if (appPrefs.Language == Language.VB)
{
method.Statements.Add(new CodeSnippetStatement("\t\t\tIf obj Is Nothing Then Return False"));
method.Statements.Add(new CodeSnippetStatement(string.Format("\t\t\tDim t = TryCast(obj, {0})", className)));
method.Statements.Add(new CodeSnippetStatement("\t\t\tIf t Is Nothing Then Return False"));
compareCode.Append("\t\t\tIf ");
var lastCol = columns.LastOrDefault();
foreach (var column in columns)
{
compareCode.Append(string.Format("{0} = t.{0}", column));
compareCode.Append(column != lastCol ? " AndAlso " : string.Empty);
}
method.Statements.Add(new CodeSnippetStatement(compareCode.ToString()));
method.Statements.Add(new CodeSnippetStatement("\t\t\t\tReturn True"));
method.Statements.Add(new CodeSnippetStatement("\t\t\tEnd If"));
method.Statements.Add(new CodeSnippetStatement(string.Empty));
method.Statements.Add(new CodeSnippetStatement("\t\t\tReturn False"));
}
return(method);
}
public void GenericTypesAndConstraints()
{
CodeNamespace ns = new CodeNamespace("NS");
ns.Imports.Add(new CodeNamespaceImport("System"));
ns.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
CodeTypeDeclaration class1 = new CodeTypeDeclaration();
class1.Name = "MyDictionary";
class1.BaseTypes.Add(new CodeTypeReference("Dictionary", new CodeTypeReference[] { new CodeTypeReference("TKey"), new CodeTypeReference("TValue"), }));
CodeTypeParameter kType = new CodeTypeParameter("TKey");
kType.HasConstructorConstraint = true;
kType.Constraints.Add(new CodeTypeReference(typeof(IComparable)));
kType.CustomAttributes.Add(new CodeAttributeDeclaration(
"System.ComponentModel.DescriptionAttribute", new CodeAttributeArgument(new CodePrimitiveExpression("KeyType"))));
CodeTypeReference iComparableT = new CodeTypeReference("IComparable");
iComparableT.TypeArguments.Add(new CodeTypeReference(kType));
kType.Constraints.Add(iComparableT);
CodeTypeParameter vType = new CodeTypeParameter("TValue");
vType.Constraints.Add(new CodeTypeReference(typeof(IList<System.String>)));
vType.CustomAttributes.Add(new CodeAttributeDeclaration(
"System.ComponentModel.DescriptionAttribute", new CodeAttributeArgument(new CodePrimitiveExpression("ValueType"))));
class1.TypeParameters.Add(kType);
class1.TypeParameters.Add(vType);
ns.Types.Add(class1);
// Declare a generic method.
CodeMemberMethod printMethod = new CodeMemberMethod();
CodeTypeParameter sType = new CodeTypeParameter("S");
sType.HasConstructorConstraint = true;
CodeTypeParameter tType = new CodeTypeParameter("T");
sType.HasConstructorConstraint = true;
printMethod.Name = "Nop";
printMethod.TypeParameters.Add(sType);
printMethod.TypeParameters.Add(tType);
printMethod.Attributes = MemberAttributes.Public;
class1.Members.Add(printMethod);
var class2 = new CodeTypeDeclaration();
class2.Name = "Demo";
var methodMain = new CodeEntryPointMethod();
var myClass = new CodeTypeReference(
"MyDictionary",
new CodeTypeReference[] {
new CodeTypeReference(typeof(int)),
new CodeTypeReference("List",
new CodeTypeReference[]
{new CodeTypeReference("System.String") })});
methodMain.Statements.Add(new CodeVariableDeclarationStatement(myClass, "dict", new CodeObjectCreateExpression(myClass)));
string dictionaryTypeName = typeof(System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<string>>[]).FullName;
var dictionaryType = new CodeTypeReference(dictionaryTypeName);
methodMain.Statements.Add(
new CodeVariableDeclarationStatement(dictionaryType, "dict2",
new CodeArrayCreateExpression(dictionaryType, new CodeExpression[1] { new CodePrimitiveExpression(null) })));
class2.Members.Add(methodMain);
ns.Types.Add(class2);
AssertEqual(ns,
@"Imports System
Imports System.Collections.Generic
Namespace NS
Public Class MyDictionary(Of TKey As {System.IComparable, IComparable(Of TKey), New}, TValue As System.Collections.Generic.IList(Of String))
Inherits Dictionary(Of TKey, TValue)
Public Overridable Sub Nop(Of S As New, T)()
End Sub
End Class
Public Class Demo
Public Shared Sub Main()
Dim dict As MyDictionary(Of Integer, List(Of String)) = New MyDictionary(Of Integer, List(Of String))()
Dim dict2() As System.Collections.Generic.Dictionary(Of Integer, System.Collections.Generic.List(Of String)) = New System.Collections.Generic.Dictionary(Of Integer, System.Collections.Generic.List(Of String))() {Nothing}
End Sub
End Class
End Namespace");
}
/// <summary>
/// Generates control fields
/// </summary>
/// <param name="source">The source.</param>
/// <param name="classType">Type of the class.</param>
/// <param name="method">The initialize method.</param>
/// <param name="generateField">if set to <c>true</c> [generate field].</param>
/// <returns></returns>
public override CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod method, bool generateField)
{
CodeExpression fieldReference = base.Generate(source, classType, method, generateField);
Image image = source as Image;
BitmapImage bitmap = image.Source as BitmapImage;
if (bitmap != null)
{
CodeComHelper.GenerateBitmapImageField(method, fieldReference, source, bitmap.UriSource, image.Name + "_bm", Image.SourceProperty);
}
CodeComHelper.GenerateEnumField <Stretch>(method, fieldReference, source, Image.StretchProperty);
return(fieldReference);
}
public void Arrays_SingleDimensional_PrimitiveTypes()
{
var arrayMethod = new CodeMemberMethod();
arrayMethod.Name = "ArrayMethod";
arrayMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "parameter"));
arrayMethod.Attributes = (arrayMethod.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
arrayMethod.ReturnType = new CodeTypeReference(typeof(System.Int64));
arrayMethod.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "arraySize", new CodePrimitiveExpression(3)));
arrayMethod.Statements.Add(new CodeVariableDeclarationStatement(typeof(int[]), "array1"));
arrayMethod.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int32", 1), "array2", new CodeArrayCreateExpression(typeof(int[]), new CodePrimitiveExpression(3))));
arrayMethod.Statements.Add(
new CodeVariableDeclarationStatement(new CodeTypeReference("System.Int16", 1), "array3", new CodeArrayCreateExpression(new CodeTypeReference("System.Int16", 1),
new CodeExpression[] {
new CodePrimitiveExpression(1),
new CodePrimitiveExpression(4),
new CodePrimitiveExpression(9),})));
arrayMethod.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("array1"), new CodeArrayCreateExpression(typeof(int[]), new CodeVariableReferenceExpression("arraySize"))));
arrayMethod.Statements.Add(new CodeVariableDeclarationStatement(typeof(System.Int64), "retValue", new CodePrimitiveExpression(0)));
arrayMethod.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "i"));
arrayMethod.Statements.Add(
new CodeIterationStatement(
new CodeAssignStatement(new CodeVariableReferenceExpression("i"), new CodePrimitiveExpression(0)),
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.LessThan,
new CodePropertyReferenceExpression(
new CodeVariableReferenceExpression("array1"), "Length")),
new CodeAssignStatement(
new CodeVariableReferenceExpression("i"),
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1))),
new CodeAssignStatement(
new CodeArrayIndexerExpression(
new CodeVariableReferenceExpression("array1"),
new CodeVariableReferenceExpression("i")),
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.Multiply,
new CodeVariableReferenceExpression("i"))),
new CodeAssignStatement(
new CodeArrayIndexerExpression(
new CodeVariableReferenceExpression("array2"),
new CodeVariableReferenceExpression("i")),
new CodeBinaryOperatorExpression(
new CodeArrayIndexerExpression(
new CodeVariableReferenceExpression("array1"),
new CodeVariableReferenceExpression("i")),
CodeBinaryOperatorType.Subtract,
new CodeVariableReferenceExpression("i"))),
new CodeAssignStatement(
new CodeVariableReferenceExpression("retValue"),
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("retValue"),
CodeBinaryOperatorType.Add,
new CodeBinaryOperatorExpression(
new CodeArrayIndexerExpression(
new CodeVariableReferenceExpression("array1"),
new CodeVariableReferenceExpression("i")),
CodeBinaryOperatorType.Add,
new CodeBinaryOperatorExpression(
new CodeArrayIndexerExpression(
new CodeVariableReferenceExpression("array2"),
new CodeVariableReferenceExpression("i")),
CodeBinaryOperatorType.Add,
new CodeArrayIndexerExpression(
new CodeVariableReferenceExpression("array3"),
new CodeVariableReferenceExpression("i"))))))));
arrayMethod.Statements.Add(
new CodeMethodReturnStatement(new CodeVariableReferenceExpression("retValue")));
AssertEqual(arrayMethod,
@"Public Function ArrayMethod(ByVal parameter As Integer) As Long
Dim arraySize As Integer = 3
Dim array1() As Integer
Dim array2((3) - 1) As Integer
Dim array3() As Short = New Short() {1, 4, 9}
array1 = New Integer((arraySize) - 1) {}
Dim retValue As Long = 0
Dim i As Integer
i = 0
Do While (i < array1.Length)
array1(i) = (i * i)
array2(i) = (array1(i) - i)
retValue = (retValue _
+ (array1(i) _
+ (array2(i) + array3(i))))
i = (i + 1)
Loop
Return retValue
End Function");
}
void GenerateCode()
{
//Create the target directory if required
Directory.CreateDirectory(IOPath.GetDirectoryName(OutputFile));
var ccu = new CodeCompileUnit();
ccu.AssemblyCustomAttributes.Add(
new CodeAttributeDeclaration(new CodeTypeReference($"global::{typeof(XamlResourceIdAttribute).FullName}"),
new CodeAttributeArgument(new CodePrimitiveExpression(ResourceId)),
new CodeAttributeArgument(new CodePrimitiveExpression(TargetPath.Replace('\\', '/'))), //use forward slashes, paths are uris-like
new CodeAttributeArgument(RootType == null ? (CodeExpression) new CodePrimitiveExpression(null) : new CodeTypeOfExpression($"global::{RootClrNamespace}.{RootType}"))
));
if (XamlResourceIdOnly)
{
goto writeAndExit;
}
if (RootType == null)
{
throw new Exception("Something went wrong while executing XamlG");
}
var declNs = new CodeNamespace(RootClrNamespace);
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))),
}
};
if (AddXamlCompilationAttribute)
{
declType.CustomAttributes.Add(
new CodeAttributeDeclaration(new CodeTypeReference($"global::{typeof(XamlCompilationAttribute).FullName}"),
new CodeAttributeArgument(new CodeSnippetExpression($"global::{typeof(XamlCompilationOptions).FullName}.Compile"))));
}
if (HideFromIntellisense)
{
declType.CustomAttributes.Add(
new CodeAttributeDeclaration(new CodeTypeReference($"global::{typeof(System.ComponentModel.EditorBrowsableAttribute).FullName}"),
new CodeAttributeArgument(new CodeSnippetExpression($"global::{typeof(System.ComponentModel.EditorBrowsableState).FullName}.{nameof(System.ComponentModel.EditorBrowsableState.Never)}"))));
}
declType.BaseTypes.Add(BaseType);
declNs.Types.Add(declType);
//Create a default ctor calling InitializeComponent
if (GenerateDefaultCtor)
{
var ctor = new CodeConstructor {
Attributes = MemberAttributes.Public,
CustomAttributes = { GeneratedCodeAttrDecl },
Statements =
{
new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "InitializeComponent")
}
};
declType.Members.Add(ctor);
}
//Create InitializeComponent()
var initcomp = new CodeMemberMethod {
Name = "InitializeComponent",
CustomAttributes = { GeneratedCodeAttrDecl }
};
declType.Members.Add(initcomp);
//Create and initialize fields
initcomp.Statements.Add(new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(new CodeTypeReference($"global::{typeof(Extensions).FullName}")),
"LoadFromXaml", new CodeThisReferenceExpression(), new CodeTypeOfExpression(declType.Name)));
foreach (var namedField in NamedFields)
{
declType.Members.Add(namedField);
var find_invoke = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression(new CodeTypeReference($"global::{typeof(NameScopeExtensions).FullName}")),
"FindByName", namedField.Type),
new CodeThisReferenceExpression(), new CodePrimitiveExpression(namedField.Name));
CodeAssignStatement assign = new CodeAssignStatement(
new CodeVariableReferenceExpression(namedField.Name), find_invoke);
initcomp.Statements.Add(assign);
}
writeAndExit:
//write the result
using (var writer = new StreamWriter(OutputFile))
Provider.GenerateCodeFromCompileUnit(ccu, writer, new CodeGeneratorOptions());
}
public void MetadataAttributes()
{
var cu = new CodeCompileUnit();
var ns = new CodeNamespace();
ns.Name = "MyNamespace";
ns.Imports.Add(new CodeNamespaceImport("System"));
ns.Imports.Add(new CodeNamespaceImport("System.Drawing"));
ns.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
ns.Imports.Add(new CodeNamespaceImport("System.ComponentModel"));
cu.Namespaces.Add(ns);
var attrs = cu.AssemblyCustomAttributes;
attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyTitle", new CodeAttributeArgument(new CodePrimitiveExpression("MyAssembly"))));
attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyVersion", new CodeAttributeArgument(new CodePrimitiveExpression("1.0.6.2"))));
attrs.Add(new CodeAttributeDeclaration("System.CLSCompliantAttribute", new CodeAttributeArgument(new CodePrimitiveExpression(false))));
var class1 = new CodeTypeDeclaration() { Name = "MyClass" };
class1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Serializable"));
class1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Obsolete", new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Class"))));
ns.Types.Add(class1);
var nestedClass = new CodeTypeDeclaration("NestedClass") { IsClass = true, TypeAttributes = TypeAttributes.NestedPublic };
nestedClass.CustomAttributes.Add(new CodeAttributeDeclaration("System.Serializable"));
class1.Members.Add(nestedClass);
var method1 = new CodeMemberMethod() { Name = "MyMethod" };
method1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Obsolete", new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Method"))));
method1.CustomAttributes.Add(new CodeAttributeDeclaration("System.ComponentModel.Editor", new CodeAttributeArgument(new CodePrimitiveExpression("This")), new CodeAttributeArgument(new CodePrimitiveExpression("That"))));
var param1 = new CodeParameterDeclarationExpression(typeof(string), "blah");
param1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlElementAttribute",
new CodeAttributeArgument("Form", new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.Xml.Schema.XmlSchemaForm"), "Unqualified")),
new CodeAttributeArgument("IsNullable", new CodePrimitiveExpression(false))));
method1.Parameters.Add(param1);
var param2 = new CodeParameterDeclarationExpression(typeof(int[]), "arrayit");
param2.CustomAttributes.Add(
new CodeAttributeDeclaration("System.Xml.Serialization.XmlElementAttribute",
new CodeAttributeArgument("Form", new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.Xml.Schema.XmlSchemaForm"), "Unqualified")),
new CodeAttributeArgument("IsNullable", new CodePrimitiveExpression(false))));
method1.Parameters.Add(param2);
class1.Members.Add(method1);
var function1 = new CodeMemberMethod();
function1.Name = "MyFunction";
function1.ReturnType = new CodeTypeReference(typeof(string));
function1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Obsolete", new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Function"))));
function1.ReturnTypeCustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlIgnoreAttribute"));
function1.ReturnTypeCustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlRootAttribute", new
CodeAttributeArgument("Namespace", new CodePrimitiveExpression("Namespace Value")), new
CodeAttributeArgument("ElementName", new CodePrimitiveExpression("Root, hehehe"))));
function1.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression("Return")));
class1.Members.Add(function1);
CodeMemberMethod function2 = new CodeMemberMethod();
function2.Name = "GlobalKeywordFunction";
function2.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(ObsoleteAttribute), CodeTypeReferenceOptions.GlobalReference), new
CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Function"))));
CodeTypeReference typeRef = new CodeTypeReference("System.Xml.Serialization.XmlIgnoreAttribute", CodeTypeReferenceOptions.GlobalReference);
CodeAttributeDeclaration codeAttrib = new CodeAttributeDeclaration(typeRef);
function2.ReturnTypeCustomAttributes.Add(codeAttrib);
class1.Members.Add(function2);
CodeMemberField field1 = new CodeMemberField();
field1.Name = "myField";
field1.Type = new CodeTypeReference(typeof(string));
field1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlElementAttribute"));
field1.InitExpression = new CodePrimitiveExpression("hi!");
class1.Members.Add(field1);
CodeMemberProperty prop1 = new CodeMemberProperty();
prop1.Name = "MyProperty";
prop1.Type = new CodeTypeReference(typeof(string));
prop1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Obsolete", new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Property"))));
prop1.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "myField")));
class1.Members.Add(prop1);
CodeConstructor const1 = new CodeConstructor();
const1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Obsolete", new CodeAttributeArgument(new CodePrimitiveExpression("Don't use this Constructor"))));
class1.Members.Add(const1);
class1 = new CodeTypeDeclaration("Test");
class1.IsClass = true;
class1.BaseTypes.Add(new CodeTypeReference("Form"));
ns.Types.Add(class1);
CodeMemberField mfield = new CodeMemberField(new CodeTypeReference("Button"), "b");
mfield.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference("Button"));
class1.Members.Add(mfield);
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Public;
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
"Size"), new CodeObjectCreateExpression(new CodeTypeReference("Size"),
new CodePrimitiveExpression(600), new CodePrimitiveExpression(600))));
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"),
"Text"), new CodePrimitiveExpression("Test")));
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"),
"TabIndex"), new CodePrimitiveExpression(0)));
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"),
"Location"), new CodeObjectCreateExpression(new CodeTypeReference("Point"),
new CodePrimitiveExpression(400), new CodePrimitiveExpression(525))));
ctor.Statements.Add(new CodeAttachEventStatement(new CodeEventReferenceExpression(new
CodeThisReferenceExpression(), "MyEvent"), new CodeDelegateCreateExpression(new CodeTypeReference("EventHandler")
, new CodeThisReferenceExpression(), "b_Click")));
class1.Members.Add(ctor);
CodeMemberEvent evt = new CodeMemberEvent();
evt.Name = "MyEvent";
evt.Type = new CodeTypeReference("System.EventHandler");
evt.Attributes = MemberAttributes.Public;
evt.CustomAttributes.Add(new CodeAttributeDeclaration("System.CLSCompliantAttribute", new CodeAttributeArgument(new CodePrimitiveExpression(false))));
class1.Members.Add(evt);
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = "b_Click";
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender"));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(EventArgs), "e"));
class1.Members.Add(cmm);
AssertEqual(cu,
@"'------------------------------------------------------------------------------
' <auto-generated>
' This code was generated by a tool.
' Runtime Version:4.0.30319.42000
'
' Changes to this file may cause incorrect behavior and will be lost if
' the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------
Option Strict Off
Option Explicit On
Imports System
Imports System.ComponentModel
Imports System.Drawing
Imports System.Windows.Forms
<Assembly: System.Reflection.AssemblyTitle(""MyAssembly""), _
Assembly: System.Reflection.AssemblyVersion(""1.0.6.2""), _
Assembly: System.CLSCompliantAttribute(false)>
Namespace MyNamespace
<System.Serializable(), _
System.Obsolete(""Don't use this Class"")> _
Public Class [MyClass]
<System.Xml.Serialization.XmlElementAttribute()> _
Private myField As String = ""hi!""
<System.Obsolete(""Don't use this Constructor"")> _
Private Sub New()
MyBase.New
End Sub
<System.Obsolete(""Don't use this Property"")> _
Private ReadOnly Property MyProperty() As String
Get
Return Me.myField
End Get
End Property
<System.Obsolete(""Don't use this Method""), _
System.ComponentModel.Editor(""This"", ""That"")> _
Private Sub MyMethod(<System.Xml.Serialization.XmlElementAttribute(Form:=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable:=false)> ByVal blah As String, <System.Xml.Serialization.XmlElementAttribute(Form:=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable:=false)> ByVal arrayit() As Integer)
End Sub
<System.Obsolete(""Don't use this Function"")> _
Private Function MyFunction() As <System.Xml.Serialization.XmlIgnoreAttribute(), System.Xml.Serialization.XmlRootAttribute([Namespace]:=""Namespace Value"", ElementName:=""Root, hehehe"")> String
Return ""Return""
End Function
<Global.System.ObsoleteAttribute(""Don't use this Function"")> _
Private Sub GlobalKeywordFunction()
End Sub
<System.Serializable()> _
Public Class NestedClass
End Class
End Class
Public Class Test
Inherits Form
Private b As Button = New Button()
Public Sub New()
MyBase.New
Me.Size = New Size(600, 600)
b.Text = ""Test""
b.TabIndex = 0
b.Location = New Point(400, 525)
AddHandler MyEvent, AddressOf Me.b_Click
End Sub
<System.CLSCompliantAttribute(false)> _
Public Event MyEvent As System.EventHandler
Private Sub b_Click(ByVal sender As Object, ByVal e As System.EventArgs)
End Sub
End Class
End Namespace");
}
public void AppendCodeSnippetExpression(CodeMemberMethod method, string code)
{
CodeSnippetExpression snippetExpresion = new CodeSnippetExpression(code);
method.Statements.Add(snippetExpresion);
}
public void CastingOperations()
{
var cd = new CodeTypeDeclaration();
cd.Name = "Test";
cd.IsClass = true;
// create method to test casting float to int
CodeMemberMethod castReturnValue = new CodeMemberMethod();
castReturnValue.Name = "CastReturnValue";
castReturnValue.ReturnType = new CodeTypeReference(typeof(int));
castReturnValue.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression strParam = new CodeParameterDeclarationExpression(typeof(string), "value");
castReturnValue.Parameters.Add(strParam);
castReturnValue.Statements.Add(new CodeMethodReturnStatement(new CodeCastExpression(typeof(int), new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("System.Single"), "Parse", new CodeExpression[] { new CodeVariableReferenceExpression("value"), new CodePropertyReferenceExpression(new CodeTypeReferenceExpression("System.Globalization.CultureInfo"), "InvariantCulture") }))));
cd.Members.Add(castReturnValue);
// create method to test casting interface -> class
CodeMemberMethod castInterface = new CodeMemberMethod();
castInterface.Name = "CastInterface";
castInterface.ReturnType = new CodeTypeReference(typeof(string));
castInterface.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression interfaceParam = new CodeParameterDeclarationExpression(typeof(System.ICloneable), "value");
castInterface.Parameters.Add(interfaceParam);
castInterface.Statements.Add(new CodeMethodReturnStatement(new CodeCastExpression(typeof(string), new CodeVariableReferenceExpression("value"))));
cd.Members.Add(castInterface);
// create method to test casting value type -> reference type
CodeMemberMethod valueToReference = new CodeMemberMethod();
valueToReference.Name = "ValueToReference";
valueToReference.ReturnType = new CodeTypeReference(typeof(System.Object));
valueToReference.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression valueParam = new CodeParameterDeclarationExpression(typeof(int), "value");
valueToReference.Parameters.Add(valueParam);
valueToReference.Statements.Add(new CodeMethodReturnStatement(new CodeCastExpression(typeof(System.Object), new CodeVariableReferenceExpression("value"))));
cd.Members.Add(valueToReference);
AssertEqual(cd,
@"Public Class Test
Public Shared Function CastReturnValue(ByVal value As String) As Integer
Return CType(Single.Parse(value, System.Globalization.CultureInfo.InvariantCulture),Integer)
End Function
Public Shared Function CastInterface(ByVal value As System.ICloneable) As String
Return CType(value,String)
End Function
Public Shared Function ValueToReference(ByVal value As Integer) As Object
Return CType(value,Object)
End Function
End Class");
}
public static void AssertHasParameter(CodeMemberMethod methodDeclaration, string name)
{
Assert.IsTrue(methodDeclaration.Parameters.OfType <CodeParameterDeclarationExpression>().Any(p => p.Name == name));
}
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("TestFields");
cd.IsClass = true;
nspace.Types.Add(cd);
// GENERATES (C#):
// public static int UseStaticPublicField(int i) {
// ClassWithFields.StaticPublicField = i;
// return ClassWithFields.StaticPublicField;
//
CodeMemberMethod cmm;
if (Supports(provider, GeneratorSupport.PublicStaticMembers))
{
AddScenario("CheckUseStaticPublicField");
cmm = new CodeMemberMethod();
cmm.Name = "UseStaticPublicField";
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("ClassWithFields"), "StaticPublicField"),
new CodeArgumentReferenceExpression("i")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new
CodeTypeReferenceExpression("ClassWithFields"), "StaticPublicField")));
cd.Members.Add(cmm);
}
// GENERATES (C#):
// public static int UseNonStaticPublicField(int i) {
// ClassWithFields variable = new ClassWithFields();
// variable.NonStaticPublicField = i;
// return variable.NonStaticPublicField;
// }
AddScenario("CheckUseNonStaticPublicField");
cmm = new CodeMemberMethod();
cmm.Name = "UseNonStaticPublicField";
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 CodeVariableDeclarationStatement("ClassWithFields", "variable", new CodeObjectCreateExpression("ClassWithFields")));
cmm.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(
new CodeVariableReferenceExpression("variable"), "NonStaticPublicField"),
new CodeArgumentReferenceExpression("i")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new
CodeVariableReferenceExpression("variable"), "NonStaticPublicField")));
cd.Members.Add(cmm);
// GENERATES (C#):
// public static int UseNonStaticInternalField(int i) {
// ClassWithFields variable = new ClassWithFields();
// variable.NonStaticInternalField = i;
// return variable.NonStaticInternalField;
// }
if (!(provider is JScriptCodeProvider) && !(provider is VBCodeProvider))
{
cmm = new CodeMemberMethod();
AddScenario("CheckUseNonStaticInternalField");
cmm.Name = "UseNonStaticInternalField";
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 CodeVariableDeclarationStatement("ClassWithFields", "variable", new CodeObjectCreateExpression("ClassWithFields")));
cmm.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(
new CodeVariableReferenceExpression("variable"), "NonStaticInternalField"),
new CodeArgumentReferenceExpression("i")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new
CodeVariableReferenceExpression("variable"), "NonStaticInternalField")));
cd.Members.Add(cmm);
}
// GENERATES (C#):
// public static int UseInternalField(int i) {
// ClassWithFields.InternalField = i;
// return ClassWithFields.InternalField;
// }
if (!(provider is JScriptCodeProvider) && !(provider is VBCodeProvider))
{
AddScenario("CheckUseInternalField");
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("ClassWithFields"), "InternalField"),
new CodeArgumentReferenceExpression("i")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new
CodeTypeReferenceExpression("ClassWithFields"), "InternalField")));
cd.Members.Add(cmm);
}
// GENERATES (C#):
// public static int UseConstantField(int i) {
// return ClassWithFields.ConstantField;
// }
AddScenario("CheckUseConstantField");
cmm = new CodeMemberMethod();
cmm.Name = "UseConstantField";
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 CodeMethodReturnStatement(new CodeFieldReferenceExpression(new
CodeTypeReferenceExpression("ClassWithFields"), "ConstantField")));
cd.Members.Add(cmm);
// code a new class to test that the protected field can be accessed by classes that inherit it
// GENERATES (C#):
// public class TestProtectedField : ClassWithFields {
// public static int UseProtectedField(int i) {
// ProtectedField = i;
// return ProtectedField;
// }
// }
cd = new CodeTypeDeclaration("TestProtectedField");
cd.BaseTypes.Add(new CodeTypeReference("ClassWithFields"));
cd.IsClass = true;
nspace.Types.Add(cd);
cmm = new CodeMemberMethod();
AddScenario("CheckUseProtectedField");
cmm.Name = "UseProtectedField";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i"));
CodeFieldReferenceExpression reference = new CodeFieldReferenceExpression();
reference.FieldName = "ProtectedField";
reference.TargetObject = new CodeTypeReferenceExpression("ClassWithFields");
cmm.Statements.Add(new CodeAssignStatement(reference,
new CodeArgumentReferenceExpression("i")));
cmm.Statements.Add(new CodeMethodReturnStatement(reference));
cd.Members.Add(cmm);
// declare class with fields
// GENERATES (C#):
// public class ClassWithFields {
// public static int StaticPublicField = 5;
// /*FamANDAssem*/ internal static int InternalField = 0;
// public const int ConstantField = 0;
// protected static int ProtectedField = 0;
// private static int PrivateField = 5;
// public int NonStaticPublicField = 5;
// /*FamANDAssem*/ internal int NonStaticInternalField = 0;
// public static int UsePrivateField(int i) {
// PrivateField = i;
// return PrivateField;
// }
// }
cd = new CodeTypeDeclaration ("ClassWithFields");
cd.IsClass = true;
nspace.Types.Add (cd);
CodeMemberField field;
if (Supports (provider, GeneratorSupport.PublicStaticMembers)) {
field = new CodeMemberField ();
field.Name = "StaticPublicField";
field.Attributes = MemberAttributes.Public | MemberAttributes.Static;
field.Type = new CodeTypeReference (typeof (int));
field.InitExpression = new CodePrimitiveExpression (5);
cd.Members.Add (field);
}
if (!(provider is JScriptCodeProvider) && !(provider is VBCodeProvider)) {
field = new CodeMemberField ();
field.Name = "InternalField";
field.Attributes = MemberAttributes.FamilyOrAssembly | MemberAttributes.Static;
field.Type = new CodeTypeReference (typeof (int));
field.InitExpression = new CodePrimitiveExpression (0);
cd.Members.Add (field);
}
field = new CodeMemberField ();
field.Name = "ConstantField";
field.Attributes = MemberAttributes.Public | MemberAttributes.Const;
field.Type = new CodeTypeReference (typeof (int));
field.InitExpression = new CodePrimitiveExpression (0);
cd.Members.Add (field);
field = new CodeMemberField ();
field.Name = "ProtectedField";
field.Attributes = MemberAttributes.Family | MemberAttributes.Static;
field.Type = new CodeTypeReference (typeof (int));
field.InitExpression = new CodePrimitiveExpression (0);
cd.Members.Add (field);
field = new CodeMemberField ();
field.Name = "PrivateField";
field.Attributes = MemberAttributes.Private | MemberAttributes.Static;
field.Type = new CodeTypeReference (typeof (int));
field.InitExpression = new CodePrimitiveExpression (5);
cd.Members.Add (field);
field = new CodeMemberField ();
field.Name = "NonStaticPublicField";
field.Attributes = MemberAttributes.Public | MemberAttributes.Final;
field.Type = new CodeTypeReference (typeof (int));
field.InitExpression = new CodePrimitiveExpression (5);
cd.Members.Add (field);
if (!(provider is JScriptCodeProvider) && !(provider is VBCodeProvider)) {
field = new CodeMemberField ();
field.Name = "NonStaticInternalField";
field.Attributes = MemberAttributes.FamilyOrAssembly | MemberAttributes.Final;
field.Type = new CodeTypeReference (typeof (int));
field.InitExpression = new CodePrimitiveExpression (0);
cd.Members.Add (field);
}
// create a method to test access to private field
AddScenario ("CheckUsePrivateField");
cmm = new CodeMemberMethod ();
cmm.Name = "UsePrivateField";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (int)), "i"));
CodeFieldReferenceExpression fieldref = new CodeFieldReferenceExpression ();
fieldref.TargetObject = new CodeTypeReferenceExpression("ClassWithFields");
fieldref.FieldName = "PrivateField";
cmm.Statements.Add (new CodeAssignStatement (fieldref, new CodeArgumentReferenceExpression ("i")));
cmm.Statements.Add (new CodeMethodReturnStatement (fieldref));
cd.Members.Add (cmm);
}
/// <summary>
/// Generates control fields
/// </summary>
/// <param name="source">The source.</param>
/// <param name="classType">Type of the class.</param>
/// <param name="initMethod">The initialize method.</param>
/// <param name="generateField">if set to <c>true</c> [generate field].</param>
/// <returns></returns>
public override CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod initMethod, bool generateField)
{
CodeExpression fieldReference = base.Generate(source, classType, initMethod, generateField);
HeaderedItemsControl control = source as HeaderedItemsControl;
UIElement header = control.Header as UIElement;
if (header != null)
{
TypeGenerator headerGenerator = new TypeGenerator();
CodeExpression headerExpr = headerGenerator.ProcessGenerators(header, classType, initMethod, false);
initMethod.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(fieldReference, "Header"), headerExpr));
}
else if (control.Header != null)
{
CodeComHelper.GenerateField <object>(initMethod, fieldReference, source, HeaderedContentControl.HeaderProperty);
// TODO content can be another class, so this will not work
}
return(fieldReference);
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
#if WHIDBEY
if (!(provider is JScriptCodeProvider)) {
// GENERATES (C#):
//
// #region Compile Unit Region
//
// namespace Namespace1 {
//
//
// #region Outer Type Region
// // Outer Type Comment
// public class Class1 {
//
// // Field 1 Comment
// private string field1;
//
// public void Method1() {
// this.Event1(this, System.EventArgs.Empty);
// }
//
// #region Constructor Region
// public Class1() {
// #region Statements Region
// this.field1 = "value1";
// this.field2 = "value2";
// #endregion
// }
// #endregion
//
// public string Property1 {
// get {
// return this.field1;
// }
// }
//
// public static void Main() {
// }
//
// public event System.EventHandler Event1;
//
// public class NestedClass1 {
// }
//
// public delegate void nestedDelegate1(object sender, System.EventArgs e);
//
//
//
// #region Field Region
// private string field2;
// #endregion
//
// #region Method Region
// // Method 2 Comment
//
// #line 500 "MethodLinePragma.txt"
// public void Method2() {
// this.Event2(this, System.EventArgs.Empty);
// }
//
// #line default
// #line hidden
// #endregion
//
// public Class1(string value1, string value2) {
// }
//
// #region Property Region
// public string Property2 {
// get {
// return this.field2;
// }
// }
// #endregion
//
// #region Type Constructor Region
// static Class1() {
// }
// #endregion
//
// #region Event Region
// public event System.EventHandler Event2;
// #endregion
//
// #region Nested Type Region
// // Nested Type Comment
//
// #line 400 "NestedTypeLinePragma.txt"
// public class NestedClass2 {
// }
//
// #line default
// #line hidden
// #endregion
//
// #region Delegate Region
// public delegate void nestedDelegate2(object sender, System.EventArgs e);
// #endregion
//
// #region Snippet Region
//
// #endregion
// }
// #endregion
// }
// #endregion
CodeNamespace ns = new CodeNamespace ("Namespace1");
cu.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Compile Unit Region"));
cu.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
cu.Namespaces.Add (ns);
CodeTypeDeclaration cd = new CodeTypeDeclaration ("Class1");
ns.Types.Add (cd);
cd.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Outer Type Region"));
cd.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
cd.Comments.Add (new CodeCommentStatement ("Outer Type Comment"));
CodeMemberField field1 = new CodeMemberField (typeof (String), "field1");
CodeMemberField field2 = new CodeMemberField (typeof (String), "field2");
field1.Comments.Add (new CodeCommentStatement ("Field 1 Comment"));
field2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Field Region"));
field2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeMemberEvent evt1 = new CodeMemberEvent ();
evt1.Name = "Event1";
evt1.Type = new CodeTypeReference (typeof (System.EventHandler));
evt1.Attributes = (evt1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeMemberEvent evt2 = new CodeMemberEvent ();
evt2.Name = "Event2";
evt2.Type = new CodeTypeReference (typeof (System.EventHandler));
evt2.Attributes = (evt2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
evt2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Event Region"));
evt2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeMemberMethod method1 = new CodeMemberMethod ();
method1.Name = "Method1";
method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
if (provider.Supports (GeneratorSupport.DeclareEvents)) {
method1.Statements.Add (
new CodeDelegateInvokeExpression (
new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "Event1"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
}
CodeMemberMethod method2 = new CodeMemberMethod ();
method2.Name = "Method2";
method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
if (provider.Supports (GeneratorSupport.DeclareEvents)) {
method2.Statements.Add (
new CodeDelegateInvokeExpression (
new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "Event2"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
}
method2.LinePragma = new CodeLinePragma ("MethodLinePragma.txt", 500);
method2.Comments.Add (new CodeCommentStatement ("Method 2 Comment"));
method2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Method Region"));
method2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeMemberProperty property1 = new CodeMemberProperty ();
property1.Name = "Property1";
property1.Type = new CodeTypeReference (typeof (string));
property1.Attributes = (property1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property1.GetStatements.Add (
new CodeMethodReturnStatement (
new CodeFieldReferenceExpression (
new CodeThisReferenceExpression (),
"field1")));
CodeMemberProperty property2 = new CodeMemberProperty ();
property2.Name = "Property2";
property2.Type = new CodeTypeReference (typeof (string));
property2.Attributes = (property2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property2.GetStatements.Add (
new CodeMethodReturnStatement (
new CodeFieldReferenceExpression (
new CodeThisReferenceExpression (),
"field2")));
property2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Property Region"));
property2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeConstructor constructor1 = new CodeConstructor ();
constructor1.Attributes = (constructor1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeStatement conState1 = new CodeAssignStatement (
new CodeFieldReferenceExpression (
new CodeThisReferenceExpression (),
"field1"),
new CodePrimitiveExpression ("value1"));
conState1.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Statements Region"));
constructor1.Statements.Add (conState1);
CodeStatement conState2 = new CodeAssignStatement (
new CodeFieldReferenceExpression (
new CodeThisReferenceExpression (),
"field2"),
new CodePrimitiveExpression ("value2"));
conState2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
constructor1.Statements.Add (conState2);
constructor1.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Constructor Region"));
constructor1.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeConstructor constructor2 = new CodeConstructor ();
constructor2.Attributes = (constructor2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
constructor2.Parameters.Add (new CodeParameterDeclarationExpression (typeof (string), "value1"));
constructor2.Parameters.Add (new CodeParameterDeclarationExpression (typeof (string), "value2"));
CodeTypeConstructor typeConstructor2 = new CodeTypeConstructor ();
typeConstructor2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Type Constructor Region"));
typeConstructor2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeEntryPointMethod methodMain = new CodeEntryPointMethod ();
CodeTypeDeclaration nestedClass1 = new CodeTypeDeclaration ("NestedClass1");
CodeTypeDeclaration nestedClass2 = new CodeTypeDeclaration ("NestedClass2");
nestedClass2.LinePragma = new CodeLinePragma ("NestedTypeLinePragma.txt", 400);
nestedClass2.Comments.Add (new CodeCommentStatement ("Nested Type Comment"));
nestedClass2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Nested Type Region"));
nestedClass2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeTypeDelegate delegate1 = new CodeTypeDelegate ();
delegate1.Name = "nestedDelegate1";
delegate1.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.Object"), "sender"));
delegate1.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.EventArgs"), "e"));
CodeTypeDelegate delegate2 = new CodeTypeDelegate ();
delegate2.Name = "nestedDelegate2";
delegate2.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.Object"), "sender"));
delegate2.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.EventArgs"), "e"));
delegate2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Delegate Region"));
delegate2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeSnippetTypeMember snippet1 = new CodeSnippetTypeMember ();
CodeSnippetTypeMember snippet2 = new CodeSnippetTypeMember ();
CodeRegionDirective regionStart = new CodeRegionDirective (CodeRegionMode.End, "");
regionStart.RegionText = "Snippet Region";
regionStart.RegionMode = CodeRegionMode.Start;
snippet2.StartDirectives.Add (regionStart);
snippet2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
cd.Members.Add (field1);
cd.Members.Add (method1);
cd.Members.Add (constructor1);
cd.Members.Add (property1);
cd.Members.Add (methodMain);
if (Supports (provider, GeneratorSupport.DeclareEvents)) {
cd.Members.Add (evt1);
}
if (Supports (provider, GeneratorSupport.NestedTypes)) {
cd.Members.Add (nestedClass1);
if (Supports (provider, GeneratorSupport.DeclareDelegates)) {
cd.Members.Add (delegate1);
}
}
cd.Members.Add (snippet1);
cd.Members.Add (field2);
cd.Members.Add (method2);
cd.Members.Add (constructor2);
cd.Members.Add (property2);
if (Supports (provider, GeneratorSupport.StaticConstructors)) {
cd.Members.Add (typeConstructor2);
}
if (Supports (provider, GeneratorSupport.DeclareEvents)) {
cd.Members.Add (evt2);
}
if (Supports (provider, GeneratorSupport.NestedTypes)) {
cd.Members.Add (nestedClass2);
if (Supports (provider, GeneratorSupport.DeclareDelegates)) {
cd.Members.Add (delegate2);
}
}
cd.Members.Add (snippet2);
}
#endif
}
public void SetTestTearDown(CodeMemberMethod memberMethod)
{
memberMethod.CustomAttributes.Add(
new CodeAttributeDeclaration(
new CodeTypeReference(TESTTEARDOWN_ATTR)));
}
