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 ProcessDirective(string directiveName, IDictionary <string, string> arguments)
{
if (!arguments.TryGetValue("name", out string name) || string.IsNullOrEmpty(name))
{
throw new DirectiveProcessorException("Parameter directive has no name argument");
}
arguments.TryGetValue("type", out string type);
type = MapTypeName(type);
string fieldName = "_" + name + "Field";
var typeRef = new CodeTypeReference(type);
var thisRef = new CodeThisReferenceExpression();
var fieldRef = new CodeFieldReferenceExpression(thisRef, fieldName);
var property = new CodeMemberProperty()
{
Name = name,
Attributes = MemberAttributes.Public | MemberAttributes.Final,
HasGet = true,
HasSet = false,
Type = typeRef
};
property.GetStatements.Add(new CodeMethodReturnStatement(fieldRef));
members.Add(new CodeMemberField(typeRef, fieldName));
members.Add(property);
var valRef = new CodeVariableReferenceExpression("data");
var namePrimitive = new CodePrimitiveExpression(name);
var sessionRef = new CodePropertyReferenceExpression(thisRef, "Session");
var callContextTypeRefExpr = new CodeTypeReferenceExpression("System.Runtime.Remoting.Messaging.CallContext");
var nullPrim = new CodePrimitiveExpression(null);
bool hasAcquiredCheck = hostSpecific
#if FEATURE_APPDOMAINS
|| true;
#endif
;
string acquiredName = "_" + name + "Acquired";
var acquiredVariable = new CodeVariableDeclarationStatement(typeof(bool), acquiredName, new CodePrimitiveExpression(false));
var acquiredVariableRef = new CodeVariableReferenceExpression(acquiredVariable.Name);
if (hasAcquiredCheck)
{
postStatements.Add(acquiredVariable);
}
//checks the local called "data" can be cast and assigned to the field, and if successful, sets acquiredVariable to true
var checkCastThenAssignVal = new CodeConditionStatement(
new CodeMethodInvokeExpression(
new CodeTypeOfExpression(typeRef), "IsAssignableFrom", new CodeMethodInvokeExpression(valRef, "GetType")),
hasAcquiredCheck
? new CodeStatement[] {
new CodeAssignStatement(fieldRef, new CodeCastExpression(typeRef, valRef)),
new CodeAssignStatement(acquiredVariableRef, new CodePrimitiveExpression(true)),
}
: new CodeStatement [] {
new CodeAssignStatement(fieldRef, new CodeCastExpression(typeRef, valRef)),
}
,
new CodeStatement[] {
new CodeExpressionStatement(new CodeMethodInvokeExpression(thisRef, "Error",
new CodePrimitiveExpression("The type '" + type + "' of the parameter '" + name +
"' did not match the type passed to the template"))),
});
//tries to gets the value from the session
var checkSession = new CodeConditionStatement(
new CodeBinaryOperatorExpression(NotNull(sessionRef), CodeBinaryOperatorType.BooleanAnd,
new CodeMethodInvokeExpression(sessionRef, "ContainsKey", namePrimitive)),
new CodeVariableDeclarationStatement(typeof(object), "data", new CodeIndexerExpression(sessionRef, namePrimitive)),
checkCastThenAssignVal);
this.postStatements.Add(checkSession);
//if acquiredVariable is false, tries to gets the value from the host
if (hostSpecific)
{
var hostRef = new CodePropertyReferenceExpression(thisRef, "Host");
var checkHost = new CodeConditionStatement(
BooleanAnd(IsFalse(acquiredVariableRef), NotNull(hostRef)),
new CodeVariableDeclarationStatement(typeof(string), "data",
new CodeMethodInvokeExpression(hostRef, "ResolveParameterValue", nullPrim, nullPrim, namePrimitive)),
new CodeConditionStatement(
NotNull(valRef),
checkCastThenAssignVal));
this.postStatements.Add(checkHost);
}
#if FEATURE_APPDOMAINS
//if acquiredVariable is false, tries to gets the value from the call context
var checkCallContext = new CodeConditionStatement(
IsFalse(acquiredVariableRef),
new CodeVariableDeclarationStatement(typeof(object), "data",
new CodeMethodInvokeExpression(callContextTypeRefExpr, "LogicalGetData", namePrimitive)),
new CodeConditionStatement(NotNull(valRef), checkCastThenAssignVal));
this.postStatements.Add(checkCallContext);
#endif
}
CodeMemberMethod GenerateMethod(CodeTypeDeclaration mainClass)
{
CodeMemberMethod method;
if (GroupZero)
{
method = GetMainMethod();
}
else
{
method = GetGroupMethod();
}
mainClass.Members.Add(method);
CodeConditionStatement matches, subMatches;
ArrayList reverseMatches;
CodeMemberMethod childMethod;
CodeExpression hasJSRef = GroupZero ?
(CodeExpression) new CodeVariableReferenceExpression("hasJavaScript") :
(CodeExpression) new CodeArgumentReferenceExpression("hasJavaScript");
reverseMatches = GenerateExceptions(mainClass, !GroupZero);
if (reverseMatches != null && reverseMatches.Count > 0)
{
foreach (CodeConditionStatement ccs in reverseMatches)
{
method.Statements.Add(ccs);
}
}
if (childGroups.Count > 0)
{
CodeDirectionExpression hasJavaScript = new CodeDirectionExpression(FieldDirection.Out, hasJSRef);
CodeExpression ualengthRef = GroupZero ?
(CodeExpression) new CodeVariableReferenceExpression("ualength") :
(CodeExpression) new CodeArgumentReferenceExpression("ualength");
int groupId = 0;
CodeMethodReturnStatement returnHasJS = new CodeMethodReturnStatement(
new CodeVariableReferenceExpression("hasJavaScript"));
foreach (GroupDefinition gd in childGroups)
{
matches = gd.GenerateConditionStatement(mainClass);
if (gd.ChildGroups.Count > 0)
{
childMethod = gd.GenerateMethod(mainClass);
subMatches = new CodeConditionStatement();
subMatches.Condition = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression("UplevelHelper"), childMethod.Name),
new CodeExpression[] { new CodeArgumentReferenceExpression("ua"),
hasJavaScript, ualengthRef }
);
subMatches.TrueStatements.Add(returnHasJS);
subMatches.FalseStatements.Add(new CodeMethodReturnStatement(
new CodePrimitiveExpression(false))
);
matches.TrueStatements.Add(subMatches);
}
else
{
reverseMatches = gd.GenerateExceptions(mainClass, !GroupZero);
if (reverseMatches != null && reverseMatches.Count > 0)
{
foreach (CodeConditionStatement ccs in reverseMatches)
{
matches.TrueStatements.Add(ccs);
}
}
if (!GroupZero && gd.Positional)
{
matches.TrueStatements.Add(
new CodeAssignStatement(
new CodeVariableReferenceExpression("hasJavaScript"),
new CodePrimitiveExpression(true))
);
}
matches.TrueStatements.Add(returnTrue);
}
method.Statements.Add(matches);
groupId++;
}
// return false;
method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(false)));
}
else
{
// return <valueOf_DefaultJS>
method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(DefaultJS)));
}
return(method);
}
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");
}
internal CodeConditionStatement If(CodeExpression test, Action xlatThen, Action xlatElse)
{
var i = new CodeConditionStatement
{
Condition = test
};
Scope.Add(i);
var old = Scope;
Scope = i.TrueStatements;
xlatThen();
Scope = i.FalseStatements;
xlatElse();
Scope = old;
return i;
}
private static void ProcessEqualityOperators(CodeMemberMethod cmm)
{
if (cmm.Name == "operator==" || cmm.Name == "operator!=")
{
CodeMethodInvokeExpression methodInvokeExpression =
new CodeMethodInvokeExpression(null, "ReferenceEquals",
new CodeArgumentReferenceExpression(cmm.Parameters[0].Name),
new CodeArgumentReferenceExpression(cmm.Parameters[1].Name));
CodeConditionStatement conditionStatement =
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeMethodInvokeExpression(null, "ReferenceEquals",
new CodeArgumentReferenceExpression(cmm.Parameters[0].Name),
new CodePrimitiveExpression(null)),
CodeBinaryOperatorType.BooleanOr,
new CodeMethodInvokeExpression(null, "ReferenceEquals",
new CodeArgumentReferenceExpression(cmm.Parameters[1].Name),
new CodePrimitiveExpression(null))),
new CodeMethodReturnStatement(
cmm.Name == "operator=="
? (CodeExpression) methodInvokeExpression
: new CodeBinaryOperatorExpression(
methodInvokeExpression, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false))));
cmm.Statements.Add(conditionStatement);
}
}
public static CodeConditionStatement Then(this CodeConditionStatement condition, params CodeStatement [] codeStatements)
{
condition.TrueStatements.AddRange(codeStatements);
return(condition);
}
private void GenerateConditionStatement(CodeConditionStatement e)
{
Output.Write("if (");
GenerateExpression(e.Condition);
Output.Write(")");
OutputStartingBrace();
Indent++;
GenerateStatements(e.TrueStatements);
Indent--;
CodeStatementCollection falseStatements = e.FalseStatements;
if (falseStatements.Count > 0)
{
Output.Write("}");
if (Options.ElseOnClosing)
{
Output.Write(" ");
}
else
{
Output.WriteLine("");
}
Output.Write("else");
OutputStartingBrace();
Indent++;
GenerateStatements(e.FalseStatements);
Indent--;
}
Output.WriteLine("}");
}
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 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))));
}
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));
}
}
public void CodeConditionStatementTest()
{
CodeStatement[] trueStatements = new CodeStatement[]
{
new CodeExpressionStatement(new CodeSnippetExpression("DoA()")),
new CodeExpressionStatement(new CodeSnippetExpression(";")),
new CodeExpressionStatement(new CodeSnippetExpression("DoB()")),
new CodeExpressionStatement(new CodeSnippetExpression("")),
new CodeSnippetStatement("A"),
new CodeExpressionStatement(new CodeSnippetExpression("DoC()"))
};
CodeStatement[] falseStatements = new CodeStatement[]
{
new CodeExpressionStatement(new CodeSnippetExpression("DoD()")),
new CodeSnippetStatement("B"),
new CodeExpressionStatement(new CodeSnippetExpression(";")),
new CodeExpressionStatement(new CodeSnippetExpression("DoE()")),
new CodeExpressionStatement(new CodeSnippetExpression("")),
new CodeExpressionStatement(new CodeSnippetExpression("DoF()"))
};
CodeConditionStatement conditionStatement = new CodeConditionStatement();
statement = conditionStatement;
try
{
Generate();
Assert.Fail("#1");
}
catch (ArgumentNullException)
{
}
conditionStatement.Condition = new CodeSnippetExpression("");
Assert.AreEqual(string.Format(CultureInfo.InvariantCulture,
"if () {{{0}" +
"}}{0}", NewLine), Generate(), "#2");
conditionStatement.Condition = new CodeSnippetExpression("true == false");
Assert.AreEqual(string.Format(CultureInfo.InvariantCulture,
"if (true == false) {{{0}" +
"}}{0}", NewLine), Generate(), "#3");
conditionStatement.TrueStatements.AddRange(trueStatements);
Assert.AreEqual(string.Format(CultureInfo.InvariantCulture,
"if (true == false) {{{0}" +
" DoA();{0}" +
" ;;{0}" +
" DoB();{0}" +
" ;{0}" +
#if NET_2_0
"A{0}" +
#else
" A{0}" +
#endif
" DoC();{0}" +
"}}{0}", NewLine), Generate(), "#3");
conditionStatement.FalseStatements.AddRange(falseStatements);
Assert.AreEqual(string.Format(CultureInfo.InvariantCulture,
"if (true == false) {{{0}" +
" DoA();{0}" +
" ;;{0}" +
" DoB();{0}" +
" ;{0}" +
#if NET_2_0
"A{0}" +
#else
" A{0}" +
#endif
" DoC();{0}" +
"}}{0}" +
"else {{{0}" +
" DoD();{0}" +
#if NET_2_0
"B{0}" +
#else
" B{0}" +
#endif
" ;;{0}" +
" DoE();{0}" +
" ;{0}" +
" DoF();{0}" +
"}}{0}", NewLine), Generate(), "#4");
options.ElseOnClosing = true;
Assert.AreEqual(string.Format(CultureInfo.InvariantCulture,
"if (true == false) {{{0}" +
" DoA();{0}" +
" ;;{0}" +
" DoB();{0}" +
" ;{0}" +
#if NET_2_0
"A{0}" +
#else
" A{0}" +
#endif
" DoC();{0}" +
"}} else {{{0}" +
" DoD();{0}" +
#if NET_2_0
"B{0}" +
#else
" B{0}" +
#endif
" ;;{0}" +
" DoE();{0}" +
" ;{0}" +
" DoF();{0}" +
"}}{0}", NewLine), Generate(), "#5");
options.ElseOnClosing = false;
conditionStatement.TrueStatements.Clear();
Assert.AreEqual(string.Format(CultureInfo.InvariantCulture,
"if (true == false) {{{0}" +
"}}{0}" +
"else {{{0}" +
" DoD();{0}" +
#if NET_2_0
"B{0}" +
#else
" B{0}" +
#endif
" ;;{0}" +
" DoE();{0}" +
" ;{0}" +
" DoF();{0}" +
"}}{0}", NewLine), Generate(), "#6");
conditionStatement.TrueStatements.AddRange(trueStatements);
conditionStatement.FalseStatements.Clear();
Assert.AreEqual(string.Format(CultureInfo.InvariantCulture,
"if (true == false) {{{0}" +
" DoA();{0}" +
" ;;{0}" +
" DoB();{0}" +
" ;{0}" +
#if NET_2_0
"A{0}" +
#else
" A{0}" +
#endif
" DoC();{0}" +
"}}{0}", NewLine), Generate(), "#7");
}
/// <summary>
/// Generates a property that gets the lock for the data model.
/// </summary>
public CurrentProperty(DataModelSchema dataModelSchema)
{
// /// <summary>
// /// Gets the current DataModelTransaction.
// /// </summary>
// public static DataModelTransaction Current
// {
this.Comments.Add(new CodeCommentStatement("<summary>", true));
this.Comments.Add(new CodeCommentStatement("Gets the lock for the data model.", true));
this.Comments.Add(new CodeCommentStatement("</summary>", true));
this.CustomAttributes.AddRange(new CodeCustomAttributesForProperties());
this.Attributes = MemberAttributes.Public | MemberAttributes.Static;
this.Type = new CodeTypeReference(String.Format("{0}Transaction", dataModelSchema.Name));
this.Name = "Current";
// get
// {
// try
// {
CodeTryCatchFinallyStatement tryLockStatement = new CodeTryCatchFinallyStatement();
// global::System.Threading.Monitor.Enter(DataModelTransaction.syncRoot);
tryLockStatement.TryStatements.Add(
new CodeMethodInvokeExpression(
new CodeGlobalTypeReferenceExpression(typeof(Monitor)),
"Enter",
new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(String.Format("{0}Transaction", dataModelSchema.Name)),
"syncRoot")));
// global::System.Transactions.Transaction transaction = global::System.Transactions.Transaction.Current;
tryLockStatement.TryStatements.Add(
new CodeVariableDeclarationStatement(
new CodeGlobalTypeReference(typeof(Transaction)),
"transaction",
new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(Transaction)), "Current")));
// string localIdentifier = transaction.TransactionInformation.LocalIdentifier;
tryLockStatement.TryStatements.Add(
new CodeVariableDeclarationStatement(
new CodeGlobalTypeReference(typeof(String)),
"localIdentifier",
new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("transaction"), "TransactionInformation"),
"LocalIdentifier")));
// DataModelTransaction dataModelTransaction;
tryLockStatement.TryStatements.Add(
new CodeVariableDeclarationStatement(
new CodeTypeReference(String.Format("{0}Transaction", dataModelSchema.Name)),
String.Format("{0}Transaction", CommonConversion.ToCamelCase(dataModelSchema.Name))));
// if (DataModelTransaction.transactionTable.TryGetValue(localIdentifier, out dataModelTransaction) == false)
// {
CodeConditionStatement ifTransactionFound = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeMethodInvokeExpression(
new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(String.Format("{0}Transaction", dataModelSchema.Name)),
"transactionTable"),
"TryGetValue",
new CodeVariableReferenceExpression("localIdentifier"),
new CodeDirectionExpression(
FieldDirection.Out,
new CodeVariableReferenceExpression(String.Format("{0}Transaction", CommonConversion.ToCamelCase(dataModelSchema.Name))))),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(false)));
// dataModelTransaction = new DataModelTransaction();
ifTransactionFound.TrueStatements.Add(
new CodeAssignStatement(
new CodeVariableReferenceExpression(String.Format("{0}Transaction", CommonConversion.ToCamelCase(dataModelSchema.Name))),
new CodeObjectCreateExpression(
new CodeTypeReference(String.Format("{0}Transaction", dataModelSchema.Name)),
new CodeVariableReferenceExpression("transaction"))));
// transactionTable.Add(localIdentifier, dataModelTransaction);
ifTransactionFound.TrueStatements.Add(
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression("transactionTable"),
"Add",
new CodeVariableReferenceExpression("localIdentifier"),
new CodeVariableReferenceExpression(String.Format("{0}Transaction", CommonConversion.ToCamelCase(dataModelSchema.Name)))));
// transaction.TransactionCompleted += new global::System.Transactions.TransactionCompletedEventHandler(OnTransactionCompleted);
ifTransactionFound.TrueStatements.Add(
new CodeAttachEventStatement(
new CodeEventReferenceExpression(new CodeVariableReferenceExpression("transaction"), "TransactionCompleted"),
new CodeObjectCreateExpression(
new CodeGlobalTypeReference(typeof(TransactionCompletedEventHandler)),
new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression(String.Format("{0}Transaction", dataModelSchema.Name)),
"OnTransactionCompleted"))));
// }
tryLockStatement.TryStatements.Add(ifTransactionFound);
// return dataModelTransaction;
tryLockStatement.TryStatements.Add(
new CodeMethodReturnStatement(
new CodeVariableReferenceExpression(String.Format("{0}Transaction", CommonConversion.ToCamelCase(dataModelSchema.Name)))));
// }
// finally
// {
// global::System.Threading.Monitor.Exit(DataModelTransaction.syncRoot);
tryLockStatement.FinallyStatements.Add(
new CodeMethodInvokeExpression(
new CodeGlobalTypeReferenceExpression(typeof(Monitor)),
"Exit",
new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(String.Format("{0}Transaction", dataModelSchema.Name)),
"syncRoot")));
// }
// }
// }
this.GetStatements.Add(tryLockStatement);
// }
}
private void ValidateConditionStatement(CodeConditionStatement e)
{
ValidateExpression(e.Condition);
ValidateStatements(e.TrueStatements);
CodeStatementCollection falseStatemetns = e.FalseStatements;
if (falseStatemetns.Count > 0)
{
ValidateStatements(e.FalseStatements);
}
}
public static CodeConditionStatement Else(this CodeConditionStatement condition, params CodeStatement [] codeStatements)
{
condition.FalseStatements.AddRange(codeStatements);
return(condition);
}
private static void ImplementINotifyPropertyChanged(CodeTypeDeclaration decl)
{
decl.BaseTypes.Add(typeof(INotifyPropertyChanged));
decl.Members.Add(new CodeMemberEvent()
{
Name = PropertyChangedEventName
,
Attributes = MemberAttributes.Public
,
Type = new CodeTypeReference(typeof(PropertyChangedEventHandler))
});
var notify = new CodeMemberMethod()
{
Name = PropertyChangedFunctionName
,
Attributes = MemberAttributes.Family
};
decl.Members.Add(notify);
notify.Parameters.Add(new CodeParameterDeclarationExpression() { Name = PropertyNameParameterName, Type = new CodeTypeReference(typeof(string)) });
notify.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(PropertyChangedEventHandler)), EventHandlerName));
notify.Statements.Add(new CodeAssignStatement() { Left = new CodeVariableReferenceExpression(EventHandlerName), Right = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), PropertyChangedEventName) });
var condition = new CodeConditionStatement()
{
Condition = new CodeBinaryOperatorExpression()
{
Left = new CodePrimitiveExpression(null)
,
Right = new CodeVariableReferenceExpression(EventHandlerName)
,
Operator = CodeBinaryOperatorType.IdentityInequality
}
};
var eventArgs = new CodeObjectCreateExpression() { CreateType = new CodeTypeReference(typeof(PropertyChangedEventArgs)) };
eventArgs.Parameters.Add(new CodeVariableReferenceExpression(PropertyNameParameterName));
var invoke = new CodeMethodInvokeExpression(null,EventHandlerName);
invoke.Parameters.Add(new CodeThisReferenceExpression());
invoke.Parameters.Add(eventArgs);
condition.TrueStatements.Add(
invoke
);
notify.Statements.Add(condition);
}
CodeMemberMethod ImplementFindView(CodeTypeReference typeForParent, CodeTypeReference typeForOverloadCall = null, Func <CodeVariableReferenceExpression, CodeExpression> constructParentViewCall = null)
{
CodeMemberMethod method = CreateMethod("__FindView", MethodAccessibility.Private, MethodScope.Final);
// T __FindView<T> (int resourceId) where T: Android.Views.View
var typeParam = new CodeTypeParameter("T");
typeParam.Constraints.Add(new CodeTypeReference("Android.Views.View", CodeTypeReferenceOptions.GlobalReference));
method.TypeParameters.Add(typeParam);
method.Parameters.Add(new CodeParameterDeclarationExpression(typeForParent, "parentView"));
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "resourceId"));
var tReference = new CodeTypeReference(typeParam);
method.ReturnType = tReference;
// T view = parentView.FindViewById<T> (resourceId);
var parentViewRef = new CodeVariableReferenceExpression("parentView");
var resourceIdVarRef = new CodeVariableReferenceExpression("resourceId");
if (typeForOverloadCall != null)
{
var findViewRef = new CodeMethodReferenceExpression(
new CodeThisReferenceExpression(),
"__FindView",
new [] { tReference }
);
CodeExpression parentViewParam;
if (constructParentViewCall != null)
{
parentViewParam = constructParentViewCall(parentViewRef);
}
else
{
parentViewParam = parentViewRef;
}
var findViewCall = new CodeMethodInvokeExpression(findViewRef, new CodeExpression [] { parentViewParam, resourceIdVarRef });
method.Statements.Add(new CodeMethodReturnStatement(findViewCall));
return(method);
}
var findByIdRef = new CodeMethodReferenceExpression(
parentViewRef,
"FindViewById",
new [] { tReference }
);
var findByIdInvoke = new CodeMethodInvokeExpression(findByIdRef, new [] { resourceIdVarRef });
var viewVar = new CodeVariableDeclarationStatement(tReference, "view", findByIdInvoke);
method.Statements.Add(viewVar);
// if (view == null) {
// OnLayoutViewNotFound (resourceId, ref view);
// }
// if (view != null)
// return view;
// throw new System.InvalidOperationException($"View not found (ID: {resourceId})");
var viewVarRef = new CodeVariableReferenceExpression("view");
var ifViewNotNull = new CodeConditionStatement(
new CodeBinaryOperatorExpression(viewVarRef, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)),
new CodeStatement [] { new CodeMethodReturnStatement(viewVarRef) }
);
var viewRefParam = new CodeDirectionExpression(FieldDirection.Ref, viewVarRef);
var viewNotFoundInvoke = new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
"OnLayoutViewNotFound",
new CodeExpression [] { resourceIdVarRef, viewRefParam }
);
var ifViewNull = new CodeConditionStatement(
new CodeBinaryOperatorExpression(viewVarRef, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)),
new CodeStatement [] { new CodeExpressionStatement(viewNotFoundInvoke) }
);
method.Statements.Add(ifViewNull);
method.Statements.Add(ifViewNotNull);
var throwInvOp = new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(
new CodeTypeReference(typeof(InvalidOperationException), CodeTypeReferenceOptions.GlobalReference),
new [] { new CodeSnippetExpression("$\"View not found (ID: {resourceId})\"") }
)
);
method.Statements.Add(throwInvOp);
return(method);
}
private static CodeMemberMethod CreateOperationCompletedMethod(ServiceContractGenerationContext context, CodeTypeDeclaration clientType, string syncMethodName, CodeTypeDeclaration operationCompletedEventArgsType, CodeMemberEvent operationCompletedEvent)
{
CodeObjectCreateExpression expression;
CodeMemberMethod method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Private;
method.Name = NamingHelper.GetUniqueName(GetOperationCompletedMethodName(syncMethodName), new NamingHelper.DoesNameExist(ClientClassGenerator.DoesMethodNameExist), context.Operations);
method.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(objectType), "state"));
method.ReturnType = new CodeTypeReference(voidType);
CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(invokeAsyncCompletedEventArgsTypeName, "e");
statement.InitExpression = new CodeCastExpression(invokeAsyncCompletedEventArgsTypeName, new CodeArgumentReferenceExpression(method.Parameters[0].Name));
CodeVariableReferenceExpression targetObject = new CodeVariableReferenceExpression(statement.Name);
if (operationCompletedEventArgsType != null)
{
expression = new CodeObjectCreateExpression(operationCompletedEventArgsType.Name, new CodeExpression[] { new CodePropertyReferenceExpression(targetObject, EventArgsPropertyNames[0]), new CodePropertyReferenceExpression(targetObject, EventArgsPropertyNames[1]), new CodePropertyReferenceExpression(targetObject, EventArgsPropertyNames[2]), new CodePropertyReferenceExpression(targetObject, EventArgsPropertyNames[3]) });
}
else
{
expression = new CodeObjectCreateExpression(asyncCompletedEventArgsType, new CodeExpression[] { new CodePropertyReferenceExpression(targetObject, EventArgsPropertyNames[1]), new CodePropertyReferenceExpression(targetObject, EventArgsPropertyNames[2]), new CodePropertyReferenceExpression(targetObject, EventArgsPropertyNames[3]) });
}
CodeEventReferenceExpression expression3 = new CodeEventReferenceExpression(new CodeThisReferenceExpression(), operationCompletedEvent.Name);
CodeDelegateInvokeExpression expression4 = new CodeDelegateInvokeExpression(expression3, new CodeExpression[] { new CodeThisReferenceExpression(), expression });
CodeConditionStatement statement2 = new CodeConditionStatement(new CodeBinaryOperatorExpression(expression3, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)), new CodeStatement[] { statement, new CodeExpressionStatement(expression4) });
method.Statements.Add(statement2);
clientType.Members.Add(method);
return method;
}
CodeMemberMethod ImplementFindFragment(CodeTypeReference typeForParent, CodeTypeReference typeForOverloadCall = null, Func <CodeVariableReferenceExpression, CodeExpression> constructParentViewCall = null)
{
CodeMemberMethod method = CreateMethod("__FindFragment", MethodAccessibility.Private, MethodScope.Final);
var typeParam = new CodeTypeParameter("T")
{
Constraints =
{
new CodeTypeReference("Android.App.Fragment", CodeTypeReferenceOptions.GlobalReference),
},
};
method.TypeParameters.Add(typeParam);
method.Parameters.Add(new CodeParameterDeclarationExpression(typeForParent, "activity"));
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "id"));
var tReference = new CodeTypeReference(typeParam);
method.ReturnType = tReference;
// T fragment = FragmentManager.FindFragmentById<T> (id);
var id = new CodeVariableReferenceExpression("id");
var findByIdRef = new CodeMethodReferenceExpression(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("activity"), "FragmentManager"),
"FindFragmentById",
new[] { tReference }
);
var findByIdInvoke = new CodeMethodInvokeExpression(findByIdRef, new[] { id });
var viewVar = new CodeVariableDeclarationStatement(tReference, "fragment", findByIdInvoke);
method.Statements.Add(viewVar);
// if (view == null) {
// OnLayoutFragmentNotFound (resourceId, ref view);
// }
// if (view != null)
// return view;
// throw new System.InvalidOperationException($"Fragment not found (ID: {id})");
var viewVarRef = new CodeVariableReferenceExpression("fragment");
var ifViewNotNull = new CodeConditionStatement(
new CodeBinaryOperatorExpression(viewVarRef, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)),
new CodeStatement[] { new CodeMethodReturnStatement(viewVarRef) }
);
var viewRefParam = new CodeDirectionExpression(FieldDirection.Ref, viewVarRef);
var viewNotFoundInvoke = new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
"OnLayoutFragmentNotFound",
new CodeExpression[] { id, viewRefParam }
);
var ifViewNull = new CodeConditionStatement(
new CodeBinaryOperatorExpression(viewVarRef, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)),
new CodeStatement[] { new CodeExpressionStatement(viewNotFoundInvoke) }
);
method.Statements.Add(ifViewNull);
method.Statements.Add(ifViewNotNull);
var throwInvOp = new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(
new CodeTypeReference(typeof(InvalidOperationException), CodeTypeReferenceOptions.GlobalReference),
new[] { new CodeSnippetExpression("$\"Fragment not found (ID: {id})\"") }
)
);
method.Statements.Add(throwInvOp);
return(method);
}
public void Goto()
{
CodeNamespace ns = new CodeNamespace("NS");
ns.Imports.Add(new CodeNamespaceImport("System"));
CodeTypeDeclaration class1 = new CodeTypeDeclaration();
class1.Name = "Test";
class1.IsClass = true;
ns.Types.Add(class1);
// create first method to test gotos that jump ahead to a defined label with statement
var cmm = new CodeMemberMethod();
cmm.Name = "FirstMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
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))));
class1.Members.Add(cmm);
// create second method to test gotos that jump ahead to a defined label without a statement attached to it
cmm = new CodeMemberMethod();
cmm.Name = "SecondMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression(typeof(int), "i");
cmm.Parameters.Add(param);
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"));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(7)));
class1.Members.Add(cmm);
// create third method to test gotos that jump to a previously defined label
cmm = new CodeMemberMethod();
cmm.Name = "ThirdMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression(typeof(int), "i");
cmm.Parameters.Add(param);
CodeAssignStatement assignmt = new CodeAssignStatement(new CodeVariableReferenceExpression("i"),
new CodeBinaryOperatorExpression
(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(5)));
cmm.Statements.Add(new CodeLabeledStatement("label", assignmt));
condstmt = new CodeConditionStatement(new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(1)),
new CodeGotoStatement("label"));
cmm.Statements.Add(condstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("i")));
class1.Members.Add(cmm);
AssertEqual(ns,
@"namespace NS {
using System;
public class Test {
public static int FirstMethod(int i) {
if ((i < 1)) {
goto comehere;
}
return 6;
comehere:
return 7;
}
public static int SecondMethod(int i) {
if ((i < 1)) {
goto comehere;
}
return 6;
comehere:
return 7;
}
public static int ThirdMethod(int i) {
label:
i = (i + 5);
if ((i < 1)) {
goto label;
}
return i;
}
}
}");
}
private void CreateRemoveClaimMethod(CodeTypeDeclaration type)
{
CodeMemberMethod method = new CodeMemberMethod();
method.ReturnType = new CodeTypeReference(typeof(Task));
method.Attributes = MemberAttributes.Public;
method.Name = "RemoveClaimAsync";
method.Parameters.Add(new CodeParameterDeclarationExpression(IdentityRole.ClrFullTypeName, "role"));
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Claim), "claim"));
method.ImplementationTypes.Add(GetGenericInterfaceType("Microsoft.AspNet.Identity.IRoleClaimStore", false));
method.Statements.Add(CodeDomUtilities.CreateParameterThrowIfNull("role"));
method.Statements.Add(CodeDomUtilities.CreateParameterThrowIfNull("claim"));
/*
* List<RoleClaim> toDelete = new List<RoleClaim>();
* foreach (var roleClaim in role.Claims)
* {
* if (roleClaim.Equals(claim))
* {
* toDelete.Add(roleClaim);
* }
* }*/
method.Statements.Add(new CodeVariableDeclarationStatement(CodeDomUtilities.GetGenericType(typeof(IList <>), IdentityRoleClaim.ClrFullTypeName), "toDelete", new CodeObjectCreateExpression(CodeDomUtilities.GetGenericType(typeof(List <>), IdentityRoleClaim.ClrFullTypeName))));
var roleClaimsEnumerator = CodeDomUtilities.GetUniqueVariable(method, CodeDomUtilities.GetGenericType(typeof(IEnumerator <>), IdentityRoleClaim.ClrFullTypeName), "enumerator");
roleClaimsEnumerator.InitExpression = new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("role"), IdentityRole.ClaimsProperty.Name), "GetEnumerator");
var roleClaimsIteration = new CodeIterationStatement();
roleClaimsIteration.InitStatement = roleClaimsEnumerator;
roleClaimsIteration.TestExpression = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(roleClaimsEnumerator.Name), "MoveNext");
roleClaimsIteration.IncrementStatement = new CodeSnippetStatement("");
method.Statements.Add(roleClaimsIteration);
roleClaimsIteration.Statements.Add(new CodeVariableDeclarationStatement(IdentityRoleClaim.ClrFullTypeName, "roleClaim", new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(roleClaimsEnumerator.Name), "Current")));
CodeConditionStatement claimsEqual = new CodeConditionStatement();
roleClaimsIteration.Statements.Add(claimsEqual);
claimsEqual.Condition = CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("roleClaim"), IdentityRoleClaim.TypeProperty.Name),
new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("claim"), "Type"));
if (IdentityRoleClaim.ValueProperty.GetAttributeValue("isComparer", Constants.NamespaceUri, true))
{
claimsEqual.Condition = new CodeBinaryOperatorExpression(claimsEqual.Condition, CodeBinaryOperatorType.BooleanAnd,
CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("roleClaim"), IdentityRoleClaim.TypeProperty.Name),
new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("claim"), "Type")));
}
if (IdentityRoleClaim.ValueTypeProperty != null && IdentityRoleClaim.ValueTypeProperty.GetAttributeValue("isComparer", Constants.NamespaceUri, false))
{
claimsEqual.Condition = new CodeBinaryOperatorExpression(claimsEqual.Condition, CodeBinaryOperatorType.BooleanAnd,
CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("roleClaim"), IdentityRoleClaim.ValueTypeProperty.Name),
new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("claim"), "ValueType")));
}
if (IdentityRoleClaim.IssuerProperty != null && IdentityRoleClaim.IssuerProperty.GetAttributeValue("isComparer", Constants.NamespaceUri, false))
{
claimsEqual.Condition = new CodeBinaryOperatorExpression(claimsEqual.Condition, CodeBinaryOperatorType.BooleanAnd,
CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("roleClaim"), IdentityRoleClaim.IssuerProperty.Name),
new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("claim"), "Issuer")));
}
if (IdentityRoleClaim.OriginalIssuerProperty != null && IdentityRoleClaim.OriginalIssuerProperty.GetAttributeValue("isComparer", Constants.NamespaceUri, false))
{
claimsEqual.Condition = new CodeBinaryOperatorExpression(claimsEqual.Condition, CodeBinaryOperatorType.BooleanAnd,
CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("roleClaim"), IdentityRoleClaim.OriginalIssuerProperty.Name),
new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("claim"), "OriginalIssuer")));
}
claimsEqual.TrueStatements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("toDelete"), "Add", new CodeVariableReferenceExpression("roleClaim")));
/*
* foreach (var roleClaim in toDelete)
* {
* roleClaim.Delete();
* role.Claims.Remove(roleClaim);
* }
*/
var toDeleteEnumerator = CodeDomUtilities.GetUniqueVariable(method, CodeDomUtilities.GetGenericType(typeof(IEnumerator <>), IdentityRoleClaim.ClrFullTypeName), "enumerator");
toDeleteEnumerator.InitExpression = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("toDelete"), "GetEnumerator");
var toDeleteIteration = new CodeIterationStatement();
toDeleteIteration.InitStatement = toDeleteEnumerator;
toDeleteIteration.TestExpression = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(toDeleteEnumerator.Name), "MoveNext");
toDeleteIteration.IncrementStatement = new CodeSnippetStatement("");
method.Statements.Add(toDeleteIteration);
toDeleteIteration.Statements.Add(new CodeVariableDeclarationStatement(IdentityRoleClaim.ClrFullTypeName, "roleClaim", new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(toDeleteEnumerator.Name), "Current")));
toDeleteIteration.Statements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("roleClaim"), "Delete"));
toDeleteIteration.Statements.Add(new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("role"), IdentityRole.ClaimsProperty.Name), "Remove", new CodeVariableReferenceExpression("roleClaim")));
method.Statements.Add(CreateEmptyTaskResult());
type.Members.Add(method);
}
/// <summary>
/// 条件语句
/// </summary>
public void AddConditionStatement(CodeConditionStatement inStatement)
{
methodList[0].Method.Statements.Add(inStatement);
}
void AddAsyncMembers(string messageName, CodeMemberMethod method)
{
CodeThisReferenceExpression ethis = new CodeThisReferenceExpression();
CodePrimitiveExpression enull = new CodePrimitiveExpression(null);
CodeMemberField codeField = new CodeMemberField(typeof(System.Threading.SendOrPostCallback), messageName + "OperationCompleted");
codeField.Attributes = MemberAttributes.Private;
CodeTypeDeclaration.Members.Add(codeField);
// Event arguments class
string argsClassName = classNames.AddUnique(messageName + "CompletedEventArgs", null);
CodeTypeDeclaration argsClass = new CodeTypeDeclaration(argsClassName);
argsClass.Attributes |= MemberAttributes.Public;
#if NET_2_0
argsClass.IsPartial = true;
#endif
argsClass.BaseTypes.Add(new CodeTypeReference("System.ComponentModel.AsyncCompletedEventArgs"));
CodeMemberField resultsField = new CodeMemberField(typeof(object[]), "results");
resultsField.Attributes = MemberAttributes.Private;
argsClass.Members.Add(resultsField);
CodeConstructor cc = new CodeConstructor();
cc.Attributes = MemberAttributes.Assembly;
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object[]), "results"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(System.Exception), "exception"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(bool), "cancelled"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));
cc.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("exception"));
cc.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("cancelled"));
cc.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("userState"));
CodeExpression thisResults = new CodeFieldReferenceExpression(ethis, "results");
cc.Statements.Add(new CodeAssignStatement(thisResults, new CodeVariableReferenceExpression("results")));
argsClass.Members.Add(cc);
int ind = 0;
if (method.ReturnType.BaseType != "System.Void")
{
argsClass.Members.Add(CreateArgsProperty(method.ReturnType, "Result", ind++));
}
foreach (CodeParameterDeclarationExpression par in method.Parameters)
{
if (par.Direction == FieldDirection.Out || par.Direction == FieldDirection.Ref)
{
argsClass.Members.Add(CreateArgsProperty(par.Type, par.Name, ind++));
}
}
bool needsArgsClass = (ind > 0);
if (needsArgsClass)
{
asyncTypes.Add(argsClass);
}
else
{
argsClassName = "System.ComponentModel.AsyncCompletedEventArgs";
}
// Event delegate type
CodeTypeDelegate delegateType = new CodeTypeDelegate(messageName + "CompletedEventHandler");
delegateType.Attributes |= MemberAttributes.Public;
delegateType.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender"));
delegateType.Parameters.Add(new CodeParameterDeclarationExpression(argsClassName, "args"));
// Event member
CodeMemberEvent codeEvent = new CodeMemberEvent();
codeEvent.Attributes = codeEvent.Attributes & ~MemberAttributes.AccessMask | MemberAttributes.Public;
codeEvent.Name = messageName + "Completed";
codeEvent.Type = new CodeTypeReference(delegateType.Name);
CodeTypeDeclaration.Members.Add(codeEvent);
// Async method (without user state param)
CodeMemberMethod am = new CodeMemberMethod();
am.Attributes = MemberAttributes.Public | MemberAttributes.Final;
am.Name = method.Name + "Async";
am.ReturnType = new CodeTypeReference(typeof(void));
CodeMethodInvokeExpression inv;
inv = new CodeMethodInvokeExpression(ethis, am.Name);
am.Statements.Add(inv);
// On...Completed method
CodeMemberMethod onCompleted = new CodeMemberMethod();
onCompleted.Name = "On" + messageName + "Completed";
onCompleted.Attributes = MemberAttributes.Private | MemberAttributes.Final;
onCompleted.ReturnType = new CodeTypeReference(typeof(void));
onCompleted.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "arg"));
CodeConditionStatement anIf = new CodeConditionStatement();
CodeExpression eventField = new CodeEventReferenceExpression(ethis, codeEvent.Name);
anIf.Condition = new CodeBinaryOperatorExpression(eventField, CodeBinaryOperatorType.IdentityInequality, enull);
CodeExpression castedArg = new CodeCastExpression(typeof(System.Web.Services.Protocols.InvokeCompletedEventArgs), new CodeVariableReferenceExpression("arg"));
CodeStatement invokeArgs = new CodeVariableDeclarationStatement(typeof(System.Web.Services.Protocols.InvokeCompletedEventArgs), "invokeArgs", castedArg);
anIf.TrueStatements.Add(invokeArgs);
CodeDelegateInvokeExpression delegateInvoke = new CodeDelegateInvokeExpression();
delegateInvoke.TargetObject = eventField;
delegateInvoke.Parameters.Add(ethis);
CodeObjectCreateExpression argsInstance = new CodeObjectCreateExpression(argsClassName);
CodeExpression invokeArgsVar = new CodeVariableReferenceExpression("invokeArgs");
if (needsArgsClass)
{
argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "Results"));
}
argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "Error"));
argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "Cancelled"));
argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "UserState"));
delegateInvoke.Parameters.Add(argsInstance);
anIf.TrueStatements.Add(delegateInvoke);
onCompleted.Statements.Add(anIf);
// Async method
CodeMemberMethod asyncMethod = new CodeMemberMethod();
asyncMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
asyncMethod.Name = method.Name + "Async";
asyncMethod.ReturnType = new CodeTypeReference(typeof(void));
CodeExpression delegateField = new CodeFieldReferenceExpression(ethis, codeField.Name);
anIf = new CodeConditionStatement();
anIf.Condition = new CodeBinaryOperatorExpression(delegateField, CodeBinaryOperatorType.IdentityEquality, enull);;
CodeExpression delegateRef = new CodeMethodReferenceExpression(ethis, onCompleted.Name);
CodeExpression newDelegate = new CodeObjectCreateExpression(typeof(System.Threading.SendOrPostCallback), delegateRef);
CodeAssignStatement cas = new CodeAssignStatement(delegateField, newDelegate);
anIf.TrueStatements.Add(cas);
asyncMethod.Statements.Add(anIf);
CodeArrayCreateExpression paramsArray = new CodeArrayCreateExpression(typeof(object));
// Assign parameters
CodeIdentifiers paramsIds = new CodeIdentifiers();
foreach (CodeParameterDeclarationExpression par in method.Parameters)
{
paramsIds.Add(par.Name, null);
if (par.Direction == FieldDirection.In || par.Direction == FieldDirection.Ref)
{
CodeParameterDeclarationExpression inpar = new CodeParameterDeclarationExpression(par.Type, par.Name);
am.Parameters.Add(inpar);
asyncMethod.Parameters.Add(inpar);
inv.Parameters.Add(new CodeVariableReferenceExpression(par.Name));
paramsArray.Initializers.Add(new CodeVariableReferenceExpression(par.Name));
}
}
inv.Parameters.Add(enull);
string userStateName = paramsIds.AddUnique("userState", null);
asyncMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), userStateName));
CodeExpression userStateVar = new CodeVariableReferenceExpression(userStateName);
asyncMethod.Statements.Add(BuildInvokeAsync(messageName, paramsArray, delegateField, userStateVar));
CodeTypeDeclaration.Members.Add(am);
CodeTypeDeclaration.Members.Add(asyncMethod);
CodeTypeDeclaration.Members.Add(onCompleted);
asyncTypes.Add(delegateType);
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
// GENERATES (C#):
//
// namespace NSPC {
//
//
// public class ClassWithMethod {
//
// public int TestBasicIterationStatement() {
// int i;
// for (i = 1; (i < 8); i = (i * 2)) {
// }
// return i;
// }
//
// public int TestComplexIterationStatement() {
// int i;
// int a = 7;
// int b;
// int c = 9;
// int d = 2;
// for (i = 0; (i < 2); i = (i + 1)) {
// if ((a < 16)) {
// for (b = 0; (b < 2); b = (b + 1)) {
// if ((c < 10)) {
// d = (d - 1);
// }
// d = (d * 2);
// }
// }
// }
// return d;
// }
// }
// }
CodeNamespace nspace = new CodeNamespace ("NSPC");
cu.Namespaces.Add (nspace);
CodeTypeDeclaration class1 = new CodeTypeDeclaration ("ClassWithMethod");
class1.IsClass = true;
nspace.Types.Add (class1);
AddScenario ("CheckTestBasicIterationStatement");
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "TestBasicIterationStatement";
cmm.Attributes = MemberAttributes.Public;
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);
AddScenario ("CheckTestComplexIterationStatement");
cmm = new CodeMemberMethod ();
cmm.Name = "TestComplexIterationStatement";
cmm.Attributes = MemberAttributes.Public;
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);
}
/* Utility methods for <object> stuff */
protected void CreateApplicationOrSessionPropertyForObject(Type type,
string propName,
bool isApplication,
bool isPublic)
{
/* if isApplication this generates (the 'cachedapp' field is created earlier):
* private MyNS.MyClass app {
* get {
* if ((this.cachedapp == null)) {
* this.cachedapp = ((MyNS.MyClass)
* (this.Application.StaticObjects.GetObject("app")));
* }
* return this.cachedapp;
* }
* }
*
* else, this is for Session:
* private MyNS.MyClass ses {
* get {
* return ((MyNS.MyClass) (this.Session.StaticObjects.GetObject("ses")));
* }
* }
*
*/
CodeExpression result = null;
CodeMemberProperty prop = new CodeMemberProperty();
prop.Type = new CodeTypeReference(type);
prop.Name = propName;
if (isPublic)
{
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
}
else
{
prop.Attributes = MemberAttributes.Private | MemberAttributes.Final;
}
CodePropertyReferenceExpression p1;
if (isApplication)
{
p1 = new CodePropertyReferenceExpression(thisRef, "Application");
}
else
{
p1 = new CodePropertyReferenceExpression(thisRef, "Session");
}
CodePropertyReferenceExpression p2;
p2 = new CodePropertyReferenceExpression(p1, "StaticObjects");
CodeMethodReferenceExpression getobject;
getobject = new CodeMethodReferenceExpression(p2, "GetObject");
CodeMethodInvokeExpression invoker;
invoker = new CodeMethodInvokeExpression(getobject,
new CodePrimitiveExpression(propName));
CodeCastExpression cast = new CodeCastExpression(prop.Type, invoker);
if (isApplication)
{
CodeFieldReferenceExpression field;
field = new CodeFieldReferenceExpression(thisRef, "cached" + propName);
CodeConditionStatement stmt = new CodeConditionStatement();
stmt.Condition = new CodeBinaryOperatorExpression(field,
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null));
CodeAssignStatement assign = new CodeAssignStatement();
assign.Left = field;
assign.Right = cast;
stmt.TrueStatements.Add(assign);
prop.GetStatements.Add(stmt);
result = field;
}
else
{
result = cast;
}
prop.GetStatements.Add(new CodeMethodReturnStatement(result));
mainClass.Members.Add(prop);
}
/// <summary>
/// Creates a method to handle moving the deleted records from the active data model to the deleted data model.
/// </summary>
/// <param name="schema">The data model schema.</param>
public ReadDataModelMethod(DataModelSchema dataModelSchema)
{
// These variable are used to create a connection to the server.
String clientTypeName = String.Format("{0}Client", dataModelSchema.Name);
String endpointName = String.Format("{0}Endpoint", dataModelSchema.Name);
String clientVariableName = CommonConversion.ToCamelCase(clientTypeName);
// /// <summary>
// /// This thread will periodically reconcile the client data model with the server's.
// /// </summary>
// private static void ReadDataModel()
// {
this.Comments.Add(new CodeCommentStatement("<summary>", true));
this.Comments.Add(new CodeCommentStatement("This thread will periodically reconcile the client data model with the server's.", true));
this.Comments.Add(new CodeCommentStatement("</summary>", true));
this.CustomAttributes.AddRange(new CodeCustomAttributesForMethods());
this.Attributes = MemberAttributes.Private | MemberAttributes.Static;
this.Name = "ReadDataModel";
// DataModelClient dataModelClient = new DataModelClient(Teraque.AssetNetwork.Properties.Settings.Default.DataModelEndpoint);
this.Statements.Add(
new CodeVariableDeclarationStatement(
new CodeTypeReference(clientTypeName),
clientVariableName,
new CodeObjectCreateExpression(
new CodeTypeReference(clientTypeName),
new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(
new CodeTypeReferenceExpression(String.Format("{0}.{1}", dataModelSchema.TargetNamespace, "Properties")),
"Settings"),
"Default"),
String.Format("{0}Endpoint", dataModelSchema.Name)))));
// for (
// ; (DataModel.IsReading == true);
// )
// {
CodeIterationStatement whileReconciling = new CodeIterationStatement(
new CodeSnippetStatement(),
new CodeBinaryOperatorExpression(
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(dataModelSchema.Name), "IsReading"),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(true)),
new CodeSnippetStatement());
// try
// {
CodeTryCatchFinallyStatement tryReading = new CodeTryCatchFinallyStatement();
// object[] dataHeader = dataModelClient.Read(DataModel.dataSetId, DataModel.sequence);
tryReading.TryStatements.Add(
new CodeVariableDeclarationStatement(
new CodeGlobalTypeReference(typeof(Object[])),
"dataHeader",
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(clientVariableName),
"Read",
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(dataModelSchema.Name), "dataSetId"),
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(dataModelSchema.Name), "sequence"))));
// global::System.Guid dataSetId = ((global::System.Guid)(dataHeader[0]));
tryReading.TryStatements.Add(
new CodeVariableDeclarationStatement(
new CodeGlobalTypeReference(typeof(Guid)),
"dataSetId",
new CodeCastExpression(
new CodeGlobalTypeReference(typeof(Guid)),
new CodeIndexerExpression(new CodeVariableReferenceExpression("dataHeader"), new CodePrimitiveExpression(0)))));
// DataModel.sequence = ((long)(dataHeader[1]));
tryReading.TryStatements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(dataModelSchema.Name), "sequence"),
new CodeCastExpression(
new CodeGlobalTypeReference(typeof(Int64)),
new CodeIndexerExpression(new CodeVariableReferenceExpression("dataHeader"), new CodePrimitiveExpression(1)))));
// object[] transactionLog = ((object[])(dataHeader[2]));
tryReading.TryStatements.Add(
new CodeVariableDeclarationStatement(
new CodeGlobalTypeReference(typeof(Object[])),
"transactionLog",
new CodeCastExpression(
new CodeGlobalTypeReference(typeof(Object[])),
new CodeIndexerExpression(new CodeVariableReferenceExpression("dataHeader"), new CodePrimitiveExpression(2)))));
// if ((dataSetId != DataModel.dataSetId))
// {
CodeConditionStatement ifInvalidDataSet = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("dataSetId"),
CodeBinaryOperatorType.IdentityInequality,
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(dataModelSchema.Name), "dataSetId")));
// DataModel.dataSetId = dataSetId;
ifInvalidDataSet.TrueStatements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(dataModelSchema.Name), "dataSetId"),
new CodeVariableReferenceExpression("dataSetId")));
// DataModel.dataSet.EnforceConstraints = false;
ifInvalidDataSet.TrueStatements.Add(
new CodeAssignStatement(
new CodePropertyReferenceExpression(
new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(dataModelSchema.Name), "dataSet"),
"EnforceConstraints"),
new CodePrimitiveExpression(false)));
// DataModel.dataSet.Clear();
// DataModel.dataSet.Clear();
ifInvalidDataSet.TrueStatements.Add(
new CodeMethodInvokeExpression(
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(dataModelSchema.Name), "dataSet"),
"Clear"));
// DataModel.dataSet.EnforceConstraints = true;
ifInvalidDataSet.TrueStatements.Add(
new CodeAssignStatement(
new CodePropertyReferenceExpression(
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(dataModelSchema.Name), "dataSet"),
"EnforceConstraints"),
new CodePrimitiveExpression(true)));
// }
tryReading.TryStatements.Add(ifInvalidDataSet);
// if ((transactionLog.Length != 0))
// {
CodeConditionStatement ifResults = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("transactionLog"), "Length"),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(0)));
// System.Windows.Application.Current.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.SystemIdle, new System.Action<object[]>(DataModel.StartMerge), transactionLog);
// }
ifResults.TrueStatements.Add(
new CodeMethodInvokeExpression(
new CodePropertyReferenceExpression(new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(Application)), "Current"), "Dispatcher"),
"BeginInvoke",
new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(DispatcherPriority)), "SystemIdle"),
new CodeObjectCreateExpression(new CodeTypeReference(typeof(Action <Object[]>)), new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(dataModelSchema.Name), "StartMerge")),
new CodeVariableReferenceExpression("transactionLog")));
tryReading.TryStatements.Add(ifResults);
// catch (global::System.ServiceModel.FaultException<Teraque.TenantNotLoadedFault> tenantNotFoundFaultException)
// {
// if (DataModel.TenantNotLoaded != null)
// DataModel.TenantNotLoaded(typeof(DataModel), tenantNotFoundFaultException.Detail.TenantName);
// }
CodeCatchClause tenantNotLoadedFaultCatch = new CodeCatchClause(
"tenantNotFoundFaultException",
new CodeGlobalTypeReference(typeof(FaultException <TenantNotLoadedFault>)));
tenantNotLoadedFaultCatch.Statements.Add(
new CodeMethodInvokeExpression(
new CodeGlobalTypeReferenceExpression(typeof(Log)),
"Error",
new CodePrimitiveExpression("Tenant {0} not loaded."),
new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("tenantNotFoundFaultException"), "Detail"), "TenantName")));
tenantNotLoadedFaultCatch.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(dataModelSchema.Name), "TenantNotLoaded"),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)),
new CodeStatement[] {
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(dataModelSchema.Name),
"TenantNotLoaded",
new CodeTypeOfExpression(new CodeTypeReference(dataModelSchema.Name)),
new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("tenantNotFoundFaultException"), "Detail"), "TenantName")))
}));
// }
tryReading.CatchClauses.Add(tenantNotLoadedFaultCatch);
// catch (global::System.Exception exception)
// {
CodeCatchClause generalCatch = new CodeCatchClause("exception", new CodeGlobalTypeReference(typeof(Exception)));
// global::Teraque.Log.Error("{0}, {1}", exception.Message, exception.StackTrace);
// }
generalCatch.Statements.Add(
new CodeMethodInvokeExpression(
new CodeGlobalTypeReferenceExpression(typeof(Log)),
"Error",
new CodePrimitiveExpression("{0}, {1}"),
new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("exception"), "Message"),
new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("exception"), "StackTrace")));
tryReading.CatchClauses.Add(generalCatch);
whileReconciling.Statements.Add(tryReading);
// }
// finally
// {
// if ((dataModelClient.State != System.ServiceModel.CommunicationState.Opened))
// {
CodeConditionStatement ifChannelNotOpen = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataModelClient"), "State"),
CodeBinaryOperatorType.IdentityInequality,
new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(CommunicationState)), "Opened")));
// global::System.Threading.Thread.Sleep(1000);
ifChannelNotOpen.TrueStatements.Add(new CodeMethodInvokeExpression(
new CodeGlobalTypeReferenceExpression(typeof(Thread)),
"Sleep",
new CodePrimitiveExpression(1000)));
// dataModelClient = new DataModelClient(Teraque.AssetNetwork.Properties.Settings.Default.DataModelEndpoint);
// }
// }
ifChannelNotOpen.TrueStatements.Add(
new CodeAssignStatement(
new CodeVariableReferenceExpression(clientVariableName),
new CodeObjectCreateExpression(
new CodeTypeReference(clientTypeName),
new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(
new CodeTypeReferenceExpression(String.Format("{0}.{1}", dataModelSchema.TargetNamespace, "Properties")),
"Settings"),
"Default"),
String.Format("{0}Endpoint", dataModelSchema.Name)))));
tryReading.FinallyStatements.Add(ifChannelNotOpen);
// global::System.Threading.Thread.Sleep(DataModel.refreshInterval);
// global::System.Threading.Thread.Sleep(DataModel.refreshInterval);
whileReconciling.Statements.Add(
new CodeMethodInvokeExpression(
new CodeGlobalTypeReferenceExpression(typeof(Thread)),
"Sleep",
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(dataModelSchema.Name), "refreshInterval")));
// }
this.Statements.Add(whileReconciling);
// }
}
/// <summary>
/// Creates a method to handle moving the deleted records from the active data model to the deleted data model.
/// </summary>
/// <param name="schema">The data model schema.</param>
public ReadMethod(DataModelSchema dataModelSchema)
{
// /// <summary>
// /// Collects the set of modified records that will reconcile the client data model to the master data model.
// /// </summary>
// /// <param name="identifier">A unique identifier of an instance of the data.</param>
// /// <param name="sequence">The sequence of the client data model.</param>
// /// <returns>An array of records that will reconcile the client data model to the server.</returns>
// [global::Teraque.ClaimsPrincipalPermission(global::System.Security.Permissions.SecurityAction.Demand, ClaimType=global::Teraque.ClaimTypes.Read, Resource=global::Teraque.Resources.Application)]
// public object[] Read(global::System.Guid identifier, long sequence)
// {
this.Comments.Add(new CodeCommentStatement("<summary>", true));
this.Comments.Add(new CodeCommentStatement("Collects the set of modified records that will reconcile the client data model to the master data model.", true));
this.Comments.Add(new CodeCommentStatement("</summary>", true));
this.Comments.Add(new CodeCommentStatement("<param name=\"identifier\">A unique identifier of an instance of the data.</param>", true));
this.Comments.Add(new CodeCommentStatement("<param name=\"sequence\">The sequence of the client data model.</param>", true));
this.Comments.Add(new CodeCommentStatement("<returns>An array of records that will reconcile the client data model to the server.</returns>", true));
this.Name = "Read";
this.Attributes = MemberAttributes.Public | MemberAttributes.Final;
this.ReturnType = new CodeGlobalTypeReference(typeof(Object[]));
this.Parameters.Add(new CodeParameterDeclarationExpression(new CodeGlobalTypeReference(typeof(Guid)), "identifier"));
this.Parameters.Add(new CodeParameterDeclarationExpression(new CodeGlobalTypeReference(typeof(Int64)), "sequence"));
// try
// {
CodeTryCatchFinallyStatement tryTransactionLogLock = new CodeTryCatchFinallyStatement();
// DataModel.transactionLogLock.EnterReadLock();
tryTransactionLogLock.TryStatements.Add(
new CodeMethodInvokeExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "transactionLogLock"),
"EnterReadLock"));
// object[] dataHeader = new object[3];
tryTransactionLogLock.TryStatements.Add(
new CodeVariableDeclarationStatement(
new CodeGlobalTypeReference(typeof(Object[])),
"dataHeader", new CodeArrayCreateExpression(new CodeGlobalTypeReference(typeof(Object[])), 3)));
// dataHeader[0] = DataModel.identifier;
tryTransactionLogLock.TryStatements.Add(
new CodeAssignStatement(
new CodeIndexerExpression(new CodeVariableReferenceExpression("dataHeader"), new CodePrimitiveExpression(0)),
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "identifier")));
// dataHeader[1] = ((long)(this.transactionLog.Last.Value.sequence));
tryTransactionLogLock.TryStatements.Add(
new CodeAssignStatement(
new CodeIndexerExpression(new CodeVariableReferenceExpression("dataHeader"), new CodePrimitiveExpression(1)),
new CodeCastExpression(
new CodeTypeReference(typeof(Int64)),
new CodeFieldReferenceExpression(
new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "transactionLog"),
"Last"),
"Value"),
"sequence"))));
// if ((identifier != DataModel.identifier))
// {
CodeConditionStatement ifNewDataModel = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeArgumentReferenceExpression("identifier"),
CodeBinaryOperatorType.IdentityInequality,
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "identifier")));
// sequence = long.MinValue;
ifNewDataModel.TrueStatements.Add(
new CodeAssignStatement(
new CodeArgumentReferenceExpression("sequence"),
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(Int64)), "MinValue")));
tryTransactionLogLock.TryStatements.Add(ifNewDataModel);
// }
// global::System.Collections.ArrayList data = new global::System.Collections.ArrayList();
tryTransactionLogLock.TryStatements.Add(
new CodeVariableDeclarationStatement(
new CodeGlobalTypeReference(typeof(ArrayList)), "data", new CodeObjectCreateExpression(new CodeGlobalTypeReference(typeof(ArrayList)))));
// global::System.Collections.Generic.LinkedListNode<TransactionLogItem> transactionNode = this.transactionLog.Last;
tryTransactionLogLock.TryStatements.Add(
new CodeVariableDeclarationStatement(
new CodeTypeReference("global::System.Collections.Generic.LinkedListNode<TransactionLogItem>"),
"transactionNode",
new CodePropertyReferenceExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "transactionLog"),
"Last")));
// logLoop:
tryTransactionLogLock.TryStatements.Add(new CodeLabeledStatement("logLoop"));
// if ((transactionNode == null))
// {
CodeConditionStatement ifListStart = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("transactionNode"),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)));
// goto endLoop;
ifListStart.TrueStatements.Add(new CodeGotoStatement("endLoop"));
// }
tryTransactionLogLock.TryStatements.Add(ifListStart);
// if ((((long)(transactionNode.Value.sequence)) <= sequence))
// {
CodeConditionStatement ifStale = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeCastExpression(
new CodeGlobalTypeReference(typeof(Int64)),
new CodeFieldReferenceExpression(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("transactionNode"), "Value"),
"sequence")),
CodeBinaryOperatorType.LessThanOrEqual,
new CodeVariableReferenceExpression("sequence")));
// goto endLoop;
ifStale.TrueStatements.Add(new CodeGotoStatement("endLoop"));
// }
tryTransactionLogLock.TryStatements.Add(ifStale);
// object[] transactionLogItem = ((object[])(transactionNode.Value.data));
tryTransactionLogLock.TryStatements.Add(
new CodeVariableDeclarationStatement(
new CodeGlobalTypeReference(typeof(Object[])),
"transactionLogItem",
new CodeCastExpression(
new CodeGlobalTypeReference(typeof(Object[])),
new CodeFieldReferenceExpression(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("transactionNode"), "Value"),
"data"))));
// global::System.Data.DataTable dataTable = DataModel.dataSet.Tables[((int)(transactionLogItem[1]))];
tryTransactionLogLock.TryStatements.Add(
new CodeVariableDeclarationStatement(
new CodeGlobalTypeReference(typeof(DataTable)),
"dataTable",
new CodeIndexerExpression(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Tables"),
new CodeCastExpression(
new CodeGlobalTypeReference(typeof(Int32)),
new CodeIndexerExpression(
new CodeVariableReferenceExpression("transactionLogItem"),
new CodePrimitiveExpression(1))))));
// data.Add(transactionLogItem);
tryTransactionLogLock.TryStatements.Add(
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("data"), "Add", new CodeVariableReferenceExpression("transactionLogItem")));
// transactionNode = transactionNode.Previous;
tryTransactionLogLock.TryStatements.Add(
new CodeAssignStatement(
new CodeVariableReferenceExpression("transactionNode"),
new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("transactionNode"), "Previous")));
// goto logLoop;
tryTransactionLogLock.TryStatements.Add(new CodeGotoStatement("logLoop"));
// endLoop:
tryTransactionLogLock.TryStatements.Add(new CodeLabeledStatement("endLoop"));
// dataHeader[2] = data.ToArray();
tryTransactionLogLock.TryStatements.Add(
new CodeAssignStatement(
new CodeIndexerExpression(new CodeVariableReferenceExpression("dataHeader"), new CodePrimitiveExpression(2)),
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("data"), "ToArray")));
// return dataHeader;
tryTransactionLogLock.TryStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("dataHeader")));
// finally
// {
// DataModel.transactionLogLock.ExitReadLock();
tryTransactionLogLock.FinallyStatements.Add(
new CodeMethodInvokeExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "transactionLogLock"),
"ExitReadLock"));
// }
this.Statements.Add(tryTransactionLogLock);
// }
}
CodeExpression GenerateScanfromExpression(CodeTypeDeclaration mainClass)
{
CodeMemberMethod method = GenerateScanMethod();
int startPosition = scanfrom + skip;
string match = matches [0] as string;
int matchLength = match.Length;
int minsize = startPosition + matchLength + 1;
// if (ualength < minsize)
// return false;
CodeBinaryOperatorExpression uaSizeCheck = new CodeBinaryOperatorExpression();
uaSizeCheck.Left = new CodeArgumentReferenceExpression("ualength");
uaSizeCheck.Operator = CodeBinaryOperatorType.LessThan;
uaSizeCheck.Right = new CodePrimitiveExpression(minsize);
method.Statements.Add(
new CodeConditionStatement(uaSizeCheck,
new CodeMethodReturnStatement(new CodePrimitiveExpression(false))));
// int startPosition = 0;
method.Statements.Add(
new CodeVariableDeclarationStatement(typeof(int), "startPosition",
new CodePrimitiveExpression(0)));
// int endPosition = startPosition + matchLength;
method.Statements.Add(
new CodeVariableDeclarationStatement(
typeof(int), "endPosition",
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("startPosition"),
CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(matchLength - 1))
)
);
// for (int ualeft = ualength; ualeft >= matchlen; ualeft--) {
// if (<condition>) {
// hasJavaScript = true;
// return true;
// }
// startPosition++;
// endPosition++;
// }
CodeIterationStatement iter = new CodeIterationStatement();
iter.InitStatement = new CodeVariableDeclarationStatement(
typeof(int), "ualeft", new CodeArgumentReferenceExpression("ualength"));
iter.IncrementStatement = new CodeAssignStatement(
new CodeVariableReferenceExpression("ualeft"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("ualeft"),
CodeBinaryOperatorType.Subtract,
new CodePrimitiveExpression(1))
);
iter.TestExpression = new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("ualeft"),
CodeBinaryOperatorType.GreaterThanOrEqual,
new CodePrimitiveExpression(matchLength)
);
CodeConditionStatement cond = new CodeConditionStatement(
GenerateScanCondition(match, matchLength, startPosition));
cond.TrueStatements.Add(
new CodeAssignStatement(new CodeArgumentReferenceExpression("hasJavaScript"),
new CodePrimitiveExpression(true)));
cond.TrueStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(true)));
iter.Statements.Add(cond);
iter.Statements.Add(
new CodeAssignStatement(new CodeVariableReferenceExpression("startPosition"),
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("startPosition"),
CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1)))
);
iter.Statements.Add(
new CodeAssignStatement(new CodeVariableReferenceExpression("endPosition"),
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("endPosition"),
CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1)))
);
method.Statements.Add(iter);
method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(false)));
mainClass.Members.Add(method);
return(new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(new CodeTypeReferenceExpression("UplevelHelper"), method.Name),
new CodeExpression[] { new CodeArgumentReferenceExpression("ua"),
new CodeDirectionExpression(
FieldDirection.Out,
new CodeArgumentReferenceExpression("hasJavaScript")),
new CodeArgumentReferenceExpression("ualength") }
));
}
/// <summary>
/// Generates the private field and public property for a piece of data.
/// </summary>
/// <param name="propertyName">Name of the property being generated.</param>
/// <param name="typeName">Name of the type for the property.</param>
/// <param name="typeDeclaration">Type declaration into which the field and property should be placed.</param>
/// <param name="outputXmlMethod">Member method for the OutputXml method.</param>
/// <param name="enumDeclaration">EnumDeclaration, which is null unless called from a locally defined enum attribute.</param>
/// <param name="documentation">Comment string to be placed on the property.</param>
/// <param name="nestedContent">If true, the field will be placed in nested content when outputting to XML.</param>
/// <param name="requiredField">If true, the generated serialization code will throw if the field is not set.</param>
private static void GenerateFieldAndProperty(string propertyName, string typeName, CodeTypeDeclaration typeDeclaration, CodeMemberMethod outputXmlMethod, EnumDeclaration enumDeclaration, string documentation, bool nestedContent, bool requiredField)
{
string fieldName = String.Concat(propertyName.Substring(0, 1).ToLower(), propertyName.Substring(1), "Field");
string fieldNameSet = String.Concat(fieldName, "Set");
Type type = GetClrTypeByXmlName(typeName);
CodeMemberField fieldMember;
if (type == null)
{
fieldMember = new CodeMemberField(typeName, fieldName);
}
else
{
fieldMember = new CodeMemberField(type, fieldName);
}
fieldMember.Attributes = MemberAttributes.Private;
typeDeclaration.Members.Add(fieldMember);
typeDeclaration.Members.Add(new CodeMemberField(typeof(bool), fieldNameSet));
CodeMemberProperty propertyMember = new CodeMemberProperty();
propertyMember.Attributes = MemberAttributes.Public | MemberAttributes.Final;
if (documentation != null)
{
GenerateSummaryComment(propertyMember.Comments, documentation);
}
propertyMember.Name = propertyName;
if (type == null)
{
propertyMember.Type = new CodeTypeReference(typeName);
}
else
{
propertyMember.Type = new CodeTypeReference(type);
}
CodeMethodReturnStatement returnStatement = new CodeMethodReturnStatement();
returnStatement.Expression = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName);
propertyMember.GetStatements.Add(returnStatement);
CodeAssignStatement assignmentStatement = new CodeAssignStatement();
propertyMember.SetStatements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldNameSet), new CodePrimitiveExpression(true)));
assignmentStatement.Left = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName);
assignmentStatement.Right = new CodePropertySetValueReferenceExpression();
propertyMember.SetStatements.Add(assignmentStatement);
CodeConditionStatement fieldSetStatement = new CodeConditionStatement();
fieldSetStatement.Condition = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldNameSet);
string clrTypeName = (string)simpleTypeNamesToClrTypeNames[typeName];
switch (clrTypeName)
{
case "string":
if (nestedContent)
{
fieldSetStatement.TrueStatements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("writer"), "WriteString", new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName)));
}
else
{
fieldSetStatement.TrueStatements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("writer"), "WriteAttributeString", new CodeSnippetExpression(String.Concat("\"", propertyName, "\"")), new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName)));
}
break;
case "int":
case "uint":
if (nestedContent)
{
fieldSetStatement.TrueStatements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("writer"), "WriteString", new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName), "ToString")));
}
else
{
fieldSetStatement.TrueStatements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("writer"), "WriteAttributeString", new CodeSnippetExpression(String.Concat("\"", propertyName, "\"")), new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName), "ToString")));
}
break;
default:
if (typeName == "DateTime")
{
if (nestedContent)
{
fieldSetStatement.TrueStatements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("writer"), "WriteString", new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName), "ToString")));
}
else
{
fieldSetStatement.TrueStatements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("writer"), "WriteAttributeString", new CodeSnippetExpression(String.Concat("\"", propertyName, "\"")), new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName), "ToString")));
}
break;
}
if (enumDeclaration == null)
{
GenerateOutputForEnum(fieldSetStatement, (EnumDeclaration)typeNamesToEnumDeclarations[typeName], fieldName, propertyName);
}
else
{
GenerateOutputForEnum(fieldSetStatement, enumDeclaration, fieldName, propertyName);
}
break;
}
// TODO: Add throw to falseStatements if required field not set.
outputXmlMethod.Statements.Add(fieldSetStatement);
typeDeclaration.Members.Add(propertyMember);
}
/*
* Build the default constructor
*/
protected override void BuildDefaultConstructor()
{
base.BuildDefaultConstructor();
if (CompilParams.IncludeDebugInformation)
{
// If in debug mode, set the timeout to some huge value (ASURT 49427)
// Server.ScriptTimeout = 30000000;
CodeAssignStatement setScriptTimeout = new CodeAssignStatement();
setScriptTimeout.Left = new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(), "Server"),
"ScriptTimeout");
setScriptTimeout.Right = new CodePrimitiveExpression(DebugScriptTimeout);
InitMethod.Statements.Add(setScriptTimeout);
}
if (Parser.TransactionMode != 0 /*TransactionOption.Disabled*/)
{
InitMethod.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TransactionMode"),
new CodePrimitiveExpression(Parser.TransactionMode)));
}
if (Parser.AspCompatMode)
{
InitMethod.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "AspCompatMode"),
new CodePrimitiveExpression(Parser.AspCompatMode)));
}
if (Parser.AsyncMode)
{
InitMethod.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "AsyncMode"),
new CodePrimitiveExpression(Parser.AsyncMode)));
}
if (Parser.OutputCacheParameters != null)
{
OutputCacheParameters cacheSettings = Parser.OutputCacheParameters;
if ((cacheSettings.CacheProfile != null && cacheSettings.CacheProfile.Length != 0) ||
cacheSettings.Duration != 0 ||
cacheSettings.Location == OutputCacheLocation.None)
{
// Add the following code snippet as a static on the class:
//
// private static OutputCacheParameters __outputCacheSettings = null;
//
CodeMemberField outputCacheSettingsField = new CodeMemberField(typeof(OutputCacheParameters), outputCacheSettingsFieldName);
outputCacheSettingsField.Attributes |= MemberAttributes.Static;
outputCacheSettingsField.InitExpression = new CodePrimitiveExpression(null);
_sourceDataClass.Members.Add(outputCacheSettingsField);
// Then, add the following code to the default constructor:
//
// if (__outputCacheSettings == null)
// __outputCacheSettings = new OutputCacheParameters(.....)
//
// This is the "if (__outputCacheSettings == null)" part
CodeConditionStatement outputCacheSettingsCondition = new CodeConditionStatement();
outputCacheSettingsCondition.Condition = new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(
_classTypeExpr,
outputCacheSettingsFieldName),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null));
// This is the "__outputCacheSettings = new OutputCacheParameters()" part
// e.g. declare local variable: OutputCacheParameters outputCacheSettings;
CodeVariableDeclarationStatement outputCacheSettingsDeclaration = new CodeVariableDeclarationStatement();
outputCacheSettingsDeclaration.Type = new CodeTypeReference(typeof(OutputCacheParameters));
outputCacheSettingsDeclaration.Name = outputCacheSettingsLocalName;
outputCacheSettingsCondition.TrueStatements.Insert(0, outputCacheSettingsDeclaration);
// e.g. outputCacheSettings = new outputCacheParameters;
CodeObjectCreateExpression cacheSettingsObject = new CodeObjectCreateExpression();
cacheSettingsObject.CreateType = new CodeTypeReference(typeof(OutputCacheParameters));
CodeVariableReferenceExpression outputCacheSettings =
new CodeVariableReferenceExpression(outputCacheSettingsLocalName);
CodeAssignStatement setOutputCacheObject =
new CodeAssignStatement(outputCacheSettings, cacheSettingsObject);
// Add the statement to the "true" clause
outputCacheSettingsCondition.TrueStatements.Add(setOutputCacheObject);
if (cacheSettings.IsParameterSet(OutputCacheParameter.CacheProfile))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "CacheProfile"),
new CodePrimitiveExpression(cacheSettings.CacheProfile));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.Duration))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "Duration"),
new CodePrimitiveExpression(cacheSettings.Duration));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.Enabled))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "Enabled"),
new CodePrimitiveExpression(cacheSettings.Enabled));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.Location))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "Location"),
new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(typeof(OutputCacheLocation)),
cacheSettings.Location.ToString()));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.NoStore))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "NoStore"),
new CodePrimitiveExpression(cacheSettings.NoStore));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.SqlDependency))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "SqlDependency"),
new CodePrimitiveExpression(cacheSettings.SqlDependency));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByControl))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "VaryByControl"),
new CodePrimitiveExpression(cacheSettings.VaryByControl));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByCustom))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "VaryByCustom"),
new CodePrimitiveExpression(cacheSettings.VaryByCustom));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByContentEncoding))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "VaryByContentEncoding"),
new CodePrimitiveExpression(cacheSettings.VaryByContentEncoding));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByHeader))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "VaryByHeader"),
new CodePrimitiveExpression(cacheSettings.VaryByHeader));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByParam))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "VaryByParam"),
new CodePrimitiveExpression(cacheSettings.VaryByParam));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
// e.g. __outputCacheSettings = outputCacheSettings;
CodeFieldReferenceExpression staticOutputCacheSettings =
new CodeFieldReferenceExpression(_classTypeExpr, outputCacheSettingsFieldName);
CodeAssignStatement assignOutputCacheSettings =
new CodeAssignStatement(staticOutputCacheSettings, outputCacheSettings);
// Add the statement to the "true" clause
outputCacheSettingsCondition.TrueStatements.Add(assignOutputCacheSettings);
InitMethod.Statements.Add(outputCacheSettingsCondition);
}
}
}
private CodeStatement[] ParseFlow(List <CodeLine> lines, int index)
{
#region Variables
var line = lines[index];
string code = line.Code.TrimStart(Spaces);
string[] parts = { string.Empty, string.Empty };
var delimiters = new char[Spaces.Length + 1];
delimiters[0] = Multicast;
Spaces.CopyTo(delimiters, 1);
int[] d = { code.IndexOfAny(delimiters), code.IndexOfAny(new[] { BlockOpen, ParenOpen }) };
if (d[0] == -1 && d[1] == -1)
{
parts[0] = code;
}
else if (d[1] != -1 && (d[1] < d[0] || d[0] == -1))
{
parts[0] = code.Substring(0, d[1]);
parts[1] = code.Substring(d[1], code.Length - d[1]).TrimStart(Spaces);
}
else
{
parts[0] = code.Substring(0, d[0]);
parts[1] = code.Substring(d[0] + 1, code.Length - d[0] - 1).TrimStart(Spaces);
}
if (parts.Length > 1 && IsEmptyStatement(parts[1]))
{
parts = new[] { parts[0] }
}
;
#endregion Variables
switch (parts[0].ToLowerInvariant())
{
#region If/Else
case FlowIf:
{
if (parts.Length < 1)
{
throw new ParseException("If requires a parameter");
}
bool blockOpen = false;
CodeExpression condition = ParseFlowParameter(parts[1], true, out blockOpen, false);
var ifelse = new CodeConditionStatement
{
Condition = condition
};
var block = new CodeBlock(line, Scope, ifelse.TrueStatements, CodeBlock.BlockKind.IfElse, blocks.Count == 0 ? null : blocks.Peek());
block.Type = blockOpen ? CodeBlock.BlockType.Within : CodeBlock.BlockType.Expect;
CloseTopSingleBlock();
blocks.Push(block);
elses.Push(ifelse.FalseStatements);
return(new CodeStatement[] { ifelse });
}
case FlowElse:
{
if (elses.Count == 0)
{
throw new ParseException("Else with no preceeding if block");
}
string next = line.Code.TrimStart(Spaces).Substring(FlowElse.Length).TrimStart(Spaces);
if (!IsEmptyStatement(next))
{
lines.Insert(index + 1, new CodeLine(lines[index].FileName, lines[index].LineNumber, next));
}
var type = parts.Length > 1 && parts[1][0] == BlockOpen ? CodeBlock.BlockType.Within : CodeBlock.BlockType.Expect;
var block = new CodeBlock(lines[index], Scope, elses.Pop(), CodeBlock.BlockKind.IfElse, blocks.Count == 0 ? null : blocks.Peek())
{
Type = type
};
CloseTopSingleBlock();
blocks.Push(block);
}
break;
#endregion If/Else
#region Goto
case FlowGosub:
{
if (parts.Length < 1)
{
throw new ParseException("No label specified");
}
return(new CodeStatement[] { new CodeExpressionStatement(LocalLabelInvoke(parts[1])) });
}
case FlowGoto:
{
if (parts.Length < 1)
{
throw new ParseException("No label specified");
}
return(new CodeStatement[] { new CodeExpressionStatement(LocalLabelInvoke(parts[1])), new CodeMethodReturnStatement() });
}
#endregion Goto
#region Loops
case FlowLoop:
{
bool blockOpen = false;
CodeMethodInvokeExpression iterator;
bool skip = true;
bool checkBrace = true;
bool byref = false;
#region Loop types
if (parts.Length > 1)
{
string[] sub = parts[1].Split(new[] { Multicast }, 2);
sub = new[] { sub[0].Trim(), sub.Length > 1 ? sub[1].Trim() : string.Empty };
switch (sub[0].ToUpperInvariant())
{
case "READ":
byref = true;
iterator = (CodeMethodInvokeExpression)InternalMethods.LoopRead;
break;
case "PARSE":
checkBrace = false;
byref = true;
iterator = (CodeMethodInvokeExpression)InternalMethods.LoopParse;
break;
case "HKEY_LOCAL_MACHINE":
case "HKLM":
case "HKEY_USERS":
case "HKU":
case "HKEY_CURRENT_USER":
case "HKCU":
case "HKEY_CLASSES_ROOT":
case "HKCR":
case "HKEY_CURRENT_CONFIG":
case "HKCC":
iterator = (CodeMethodInvokeExpression)InternalMethods.LoopRegistry;
break;
case "EACH":
byref = true;
iterator = (CodeMethodInvokeExpression)InternalMethods.LoopEach;
break;
default:
{
var file = false;
if (parts[1].IndexOf(Multicast) != -1)
{
file = true;
}
// TODO: check file/iteration loop types
skip = false;
iterator = (CodeMethodInvokeExpression)(file ? InternalMethods.LoopFile : InternalMethods.Loop);
}
break;
}
if (skip)
{
parts[1] = sub[1];
}
if (checkBrace)
{
// TODO: check expression parameters before stripping comments
int x = parts.Length == 1 ? 0 : 1;
string part = StripComment(parts[x]).TrimEnd(Spaces);
int l = part.Length - 1;
if (part.Length > 0 && part[l] == BlockOpen)
{
blockOpen = true;
parts[x] = part.Substring(0, l);
}
}
if (skip && parts[1].Length == 0)
{
throw new ParseException("Loop type must have an argument");
}
foreach (var arg in SplitCommandParameters(parts[1]))
{
iterator.Parameters.Add(ParseCommandParameter(arg));
}
if (LegacyLoop && byref)
{
iterator.Parameters[0] = VarId(iterator.Parameters[0]);
}
}
else
{
iterator = (CodeMethodInvokeExpression)InternalMethods.Loop;
iterator.Parameters.Add(new CodePrimitiveExpression(int.MaxValue));
}
#endregion Loop types
string id = InternalID;
var init = new CodeVariableDeclarationStatement();
init.Name = id;
init.Type = new CodeTypeReference(typeof(IEnumerable));
init.InitExpression = new CodeMethodInvokeExpression(iterator, "GetEnumerator", new CodeExpression[] { });
var condition = new CodeMethodInvokeExpression();
condition.Method.TargetObject = new CodeVariableReferenceExpression(id);
condition.Method.MethodName = "MoveNext";
var loop = new CodeIterationStatement();
loop.InitStatement = init;
loop.IncrementStatement = new CodeCommentStatement(string.Empty); // for C# display
loop.TestExpression = condition;
var block = new CodeBlock(line, Scope, loop.Statements, CodeBlock.BlockKind.Loop, blocks.Count == 0 ? null : blocks.Peek(), InternalID, InternalID);
block.Type = blockOpen ? CodeBlock.BlockType.Within : CodeBlock.BlockType.Expect;
CloseTopSingleBlock();
blocks.Push(block);
return(new CodeStatement[] { loop, new CodeLabeledStatement(block.ExitLabel) });
}
case FlowWhile:
{
bool blockOpen = false;
CodeExpression condition = parts.Length > 1 ? ParseFlowParameter(parts[1], true, out blockOpen, true) : new CodePrimitiveExpression(true);
var loop = new CodeIterationStatement();
loop.TestExpression = condition;
loop.InitStatement = new CodeCommentStatement(string.Empty);
var block = new CodeBlock(line, Scope, loop.Statements, CodeBlock.BlockKind.Loop, blocks.Count == 0 ? null : blocks.Peek(), InternalID, InternalID);
block.Type = blockOpen ? CodeBlock.BlockType.Within : CodeBlock.BlockType.Expect;
CloseTopSingleBlock();
blocks.Push(block);
return(new CodeStatement[] { loop, new CodeLabeledStatement(block.ExitLabel) });
}
case FlowBreak:
int b = 1;
if (parts.Length > 1)
{
parts[1] = StripCommentSingle(parts[1]);
if (!int.TryParse(parts[1], out b) || b < 1)
{
throw new ParseException("Break parameter must be a static integer greater than zero.");
}
}
string exit = PeekLoopLabel(true, b);
if (exit == null)
{
throw new ParseException("Cannot break outside a loop");
}
return(new CodeStatement[] { new CodeGotoStatement(exit) });
case FlowContinue:
int c = 1;
if (parts.Length > 1)
{
parts[1] = StripCommentSingle(parts[1]);
if (!int.TryParse(parts[1], out c) || c < 1)
{
throw new ParseException("Continue parameter must be a static integer greater than zero.");
}
}
string cont = PeekLoopLabel(false, c);
if (cont == null)
{
throw new ParseException("Cannot continue outside a loop");
}
return(new CodeStatement[] { new CodeGotoStatement(cont) });
#endregion Loops
#region Return
case FlowReturn:
if (Scope == mainScope)
{
if (parts.Length > 1)
{
throw new ParseException("Cannot have return parameter for entry point method");
}
return(new CodeStatement[] { new CodeMethodReturnStatement() });
}
else
{
var result = parts.Length > 1 ? ParseSingleExpression(parts[1]) : new CodePrimitiveExpression(null);
return(new CodeStatement[] { new CodeMethodReturnStatement(result) });
}
#endregion Return
#region Function
case FunctionLocal:
case FunctionGlobal:
case FunctionStatic:
// TODO: function local/global/static scoping modifiers
break;
#endregion Function
default:
throw new ParseException(ExUnexpected);
}
return(null);
}
protected override void GenerateConditionStatement
(CodeConditionStatement e)
{
Output.Write("If ");
GenerateExpression(e.Condition);
Output.WriteLine(" Then");
++Indent;
GenerateStatements(e.TrueStatements);
--Indent;
CodeStatementCollection stmts = e.FalseStatements;
if(stmts.Count > 0 || Options.ElseOnClosing)
{
Output.WriteLine("Else");
++Indent;
GenerateStatements(stmts);
--Indent;
}
Output.WriteLine("End If");
}
public int VisitIf(CodeConditionStatement cond)
{
Analyze(this.path, cond.TrueStatements);
Analyze(this.path, cond.FalseStatements);
return(0);
}
private static CodeTypeMember CreatePropertyOverride(PropertyInfo pi, List<string> additionals)
{
CodeMemberProperty mp = new CodeMemberProperty();
mp.Name = pi.Name;
mp.Attributes = MemberAttributes.Override | MemberAttributes.Public;
mp.Type = new CodeTypeReference(pi.PropertyType);
mp.HasGet = mp.HasSet = true;
mp.GetStatements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression() { PropertyName = pi.Name, TargetObject = new CodeBaseReferenceExpression() }));
var conditionForNotify = new CodeMethodInvokeExpression() { Method = new CodeMethodReferenceExpression(new CodePropertyReferenceExpression() { PropertyName = pi.Name, TargetObject = new CodeBaseReferenceExpression() }, "Equals") };
conditionForNotify.Parameters.Add(new CodePropertySetValueReferenceExpression());
var setCondition = new CodeConditionStatement()
{
Condition = new CodeBinaryOperatorExpression() { Left = new CodePrimitiveExpression(false), Right = conditionForNotify, Operator = CodeBinaryOperatorType.IdentityEquality }
};
setCondition.TrueStatements.Add(new CodeAssignStatement() { Left = new CodePropertyReferenceExpression() { PropertyName = pi.Name, TargetObject = new CodeBaseReferenceExpression() }, Right = new CodePropertySetValueReferenceExpression() });
var invokeMethod = new CodeMethodInvokeExpression() { Method = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), PropertyChangedFunctionName) };
invokeMethod.Parameters.Add(new CodePrimitiveExpression(pi.Name));
setCondition.TrueStatements.Add(invokeMethod);
foreach (var additional in additionals)
{
invokeMethod = new CodeMethodInvokeExpression() { Method = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), PropertyChangedFunctionName) };
invokeMethod.Parameters.Add(new CodePrimitiveExpression(additional));
setCondition.TrueStatements.Add(invokeMethod);
}
mp.SetStatements.Add(setCondition);
return mp;
}
public static string GenerateWrapper(WrapperClass wrapperClass, Language language)
{
// Namespace
CodeNamespace _namespace = new CodeNamespace(wrapperClass.Namespace);
// Comments
string comment =
@"------------------------------------------------------------------------------" + Environment.NewLine +
@" <auto-generated>" + Environment.NewLine +
@" This code was generated by '.NET Wrapper Class Generator'" + Environment.NewLine +
@" Product Version:" + Assembly.GetExecutingAssembly().GetName().Version + Environment.NewLine + Environment.NewLine +
@" Changes to this file may cause incorrect behavior and will be lost if" + Environment.NewLine +
@" the code is regenerated." + Environment.NewLine +
@" </auto-generated>" + Environment.NewLine +
@" ------------------------------------------------------------------------------";
_namespace.Comments.Add(new CodeCommentStatement(comment));
// Class
CodeTypeDeclaration classDeclaration = new CodeTypeDeclaration(wrapperClass.ClassName);
classDeclaration.IsPartial = wrapperClass.Partial;
if (wrapperClass.Sealed)
{
classDeclaration.TypeAttributes |= TypeAttributes.Sealed;
}
_namespace.Types.Add(classDeclaration);
// Initialization
CodeParameterDeclarationExpressionCollection initializationParameters = null;
CodeStatementCollection initiazationStatements = null;
if (wrapperClass.Partial)
{
// Initialization method
CodeMemberMethod initializer = new CodeMemberMethod();
classDeclaration.Members.Add(initializer);
initializer.Name = "InitializeWrapper";
initializer.Attributes = MemberAttributes.Private;
{
comment =
@"***************************************************************" + Environment.NewLine +
@" This method should be called by the user-provided constructor!" + Environment.NewLine +
@"***************************************************************";
initializer.Comments.Add(new CodeCommentStatement(comment));
}
initializationParameters = initializer.Parameters;
initiazationStatements = initializer.Statements;
}
else
{
// Constructor
CodeConstructor constructor = new CodeConstructor();
classDeclaration.Members.Add(constructor);
constructor.Attributes = MemberAttributes.Public;
initializationParameters = constructor.Parameters;
initiazationStatements = constructor.Statements;
}
// Iterate over the wrapped types
foreach (WrappedType wrappedType in wrapperClass.WrappedTypes)
{
// Fields
CodeMemberField field = new CodeMemberField(wrappedType.Type, wrappedType.FieldName);
if (wrappedType.Acquisition != Acquisition.UserManaged)
{
classDeclaration.Members.Add(field);
}
string memberPrefix = string.Empty;
if (wrappedType.PrefixMembers)
{
memberPrefix = wrappedType.FieldName;
memberPrefix = memberPrefix.Substring(0, 1).ToUpper() + memberPrefix.Substring(1);
}
CodeFieldReferenceExpression fieldReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), wrappedType.FieldName);
if (wrappedType.Acquisition == Acquisition.Construct)
{
// Instantiation
CodeObjectCreateExpression instantiation = new CodeObjectCreateExpression(wrappedType.Type);
CodeAssignStatement instanceAssignment = new CodeAssignStatement(fieldReference, instantiation);
initiazationStatements.Add(instanceAssignment);
}
else if (wrappedType.Acquisition == Acquisition.Parameter)
{
// Pass as parameter
initializationParameters.Add(new CodeParameterDeclarationExpression(wrappedType.Type, wrappedType.FieldName));
initiazationStatements.Add(new CodeAssignStatement(fieldReference, new CodeVariableReferenceExpression(wrappedType.FieldName)));
}
else if (wrappedType.Acquisition == Acquisition.Property)
{
// Set as property
CodeMemberProperty property = new CodeMemberProperty();
property.Attributes = MemberAttributes.Public;
property.HasGet = property.HasSet = true;
property.Type = new CodeTypeReference(wrappedType.Type);
property.Name = wrappedType.Type.Name;
property.GetStatements.Add(new CodeMethodReturnStatement(fieldReference));
property.SetStatements.Add(new CodeAssignStatement(fieldReference, new CodeVariableReferenceExpression("value")));
classDeclaration.Members.Add(property);
}
// Methods
foreach (WrappedMethod wrappedMethod in wrappedType.WrappedMethods)
{
// Method
CodeMemberMethod method = new CodeMemberMethod();
classDeclaration.Members.Add(method);
method.Name = memberPrefix + wrappedMethod.Method.Name;
method.ReturnType = new CodeTypeReference(wrappedMethod.Method.ReturnType);
Generator.SetMember(method, wrappedMethod);
if (!string.IsNullOrEmpty(wrappedMethod.Interface))
{
method.PrivateImplementationType = new CodeTypeReference(wrappedMethod.Interface);
}
// Parameters
List <CodeExpression> arguments = Generator.SetParameters(method, wrappedMethod.Method.GetParameters());
// Statement
CodeMethodInvokeExpression invocation = null;
if (!wrappedMethod.Method.IsStatic)
{
invocation = new CodeMethodInvokeExpression(fieldReference, wrappedMethod.Method.Name, arguments.ToArray());
}
else
{
invocation = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(wrappedType.Type), wrappedMethod.Method.Name, arguments.ToArray());
method.Attributes |= MemberAttributes.Static;
}
if (wrappedMethod.Method.ReturnType == typeof(void))
{
method.Statements.Add(invocation);
}
else
{
method.Statements.Add(new CodeMethodReturnStatement(invocation));
}
}
// Properties
foreach (WrappedProperty wrappedProperty in wrappedType.WrappedProperties)
{
// Property
CodeMemberProperty property = new CodeMemberProperty();
classDeclaration.Members.Add(property);
property.Name = memberPrefix + wrappedProperty.Property.Name;
property.Type = new CodeTypeReference(wrappedProperty.Property.PropertyType);
Generator.SetMember(property, wrappedProperty);
if (!string.IsNullOrEmpty(wrappedProperty.Interface))
{
property.PrivateImplementationType = new CodeTypeReference(wrappedProperty.Interface);
}
CodePropertyReferenceExpression invocation = null;
if (true) // TODO: check if property is static
{
invocation = new CodePropertyReferenceExpression(fieldReference, wrappedProperty.Property.Name);
}
else
{
}
// Get statement
if (wrappedProperty.Get)
{
property.GetStatements.Add(new CodeMethodReturnStatement(invocation));
}
// Set statement
if (wrappedProperty.Set)
{
property.SetStatements.Add(new CodeAssignStatement(invocation, new CodeVariableReferenceExpression("value")));
}
}
// Events
foreach (WrappedEvent wrappedEvent in wrappedType.WrappedEvents)
{
// Event
MethodInfo eventDelegate = wrappedEvent.Event.EventHandlerType.GetMethod("Invoke");
CodeMemberEvent _event = new CodeMemberEvent();
classDeclaration.Members.Add(_event);
_event.Name = memberPrefix + wrappedEvent.Event.Name;
_event.Type = new CodeTypeReference(wrappedEvent.Event.EventHandlerType);
Generator.SetMember(_event, wrappedEvent);
if (!string.IsNullOrEmpty(wrappedEvent.Interface))
{
_event.PrivateImplementationType = new CodeTypeReference(wrappedEvent.Interface);
}
// Event handler/raiser
CodeMemberMethod eventHandler = new CodeMemberMethod();
classDeclaration.Members.Add(eventHandler);
eventHandler.Name = string.Format("On{0}", _event.Name);
eventHandler.ReturnType = new CodeTypeReference(eventDelegate.ReturnType);
eventHandler.Attributes = MemberAttributes.Private;
List <CodeExpression> arguments = Generator.SetParameters(eventHandler, eventDelegate.GetParameters());
CodeEventReferenceExpression eventReference = new CodeEventReferenceExpression(new CodeThisReferenceExpression(), _event.Name);
CodeConditionStatement conditional = new CodeConditionStatement();
eventHandler.Statements.Add(conditional);
conditional.Condition = new CodeBinaryOperatorExpression(eventReference, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
CodeDelegateInvokeExpression eventInvocation = new CodeDelegateInvokeExpression(eventReference, arguments.ToArray());
if (eventDelegate.ReturnType == typeof(void))
{
conditional.TrueStatements.Add(eventInvocation);
}
else
{
conditional.TrueStatements.Add(new CodeMethodReturnStatement(eventInvocation));
}
// Event registration
CodeEventReferenceExpression wrappedEventReference = new CodeEventReferenceExpression(fieldReference, wrappedEvent.Event.Name);
CodeMethodReferenceExpression eventRaiserReference = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), eventHandler.Name);
CodeAttachEventStatement eventRegistration = new CodeAttachEventStatement(wrappedEventReference, eventRaiserReference);
initiazationStatements.Add(eventRegistration);
}
}
// Generate the code
StringWriter stringWriter = new StringWriter();
CodeDomProvider codeProvider = null;
if (language == Language.CSharp)
{
codeProvider = new CSharpCodeProvider();
}
else if (language == Language.VBNet)
{
codeProvider = new VBCodeProvider();
}
else
{
throw new ArgumentException("Specified language is not supported: " + language);
}
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BracingStyle = "C";
codeProvider.GenerateCodeFromNamespace(_namespace, stringWriter, options);
return(stringWriter.ToString());
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
// create a namespace
CodeNamespace ns = new CodeNamespace ("NS");
ns.Imports.Add (new CodeNamespaceImport ("System"));
cu.Namespaces.Add (ns);
// create a class
CodeTypeDeclaration class1 = new CodeTypeDeclaration ();
class1.Name = "Test";
class1.IsClass = true;
ns.Types.Add (class1);
if (Supports (provider, GeneratorSupport.GotoStatements)) {
// create first method to test gotos that jump ahead to a defined label with statement
// GENERATE (C#):
// public static int FirstMethod(int i) {
// if ((i < 1)) {
// goto comehere;
// }
// return 6;
// comehere:
// return 7;
// }
AddScenario ("CheckFirstMethod");
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "FirstMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (typeof (int), "i");
cmm.Parameters.Add (param);
CodeConditionStatement condstmt = new CodeConditionStatement (new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("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))));
class1.Members.Add (cmm);
// create second method to test gotos that jump ahead to a defined label without a statement attached to it
// GENERATE (C#):
// public static int SecondMethod(int i) {
// if ((i < 1)) {
// goto comehere;
// return 5;
// }
// return 6;
// comehere:
// return 7;
// }
AddScenario ("CheckSecondMethod");
cmm = new CodeMemberMethod ();
cmm.Name = "SecondMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression (typeof (int), "i");
cmm.Parameters.Add (param);
condstmt = new CodeConditionStatement (new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("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"));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (7)));
class1.Members.Add (cmm);
// create third method to test gotos that jump to a previously defined label
// GENERATE (C#):
// public static int ThirdMethod(int i) {
// label:
// i = (i + 5);
// if ((i < 1)) {
// goto label;
// }
// return i;
// }
AddScenario ("CheckThirdMethod");
cmm = new CodeMemberMethod ();
cmm.Name = "ThirdMethod";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
param = new CodeParameterDeclarationExpression (typeof (int), "i");
cmm.Parameters.Add (param);
CodeAssignStatement assignmt = new CodeAssignStatement (new CodeArgumentReferenceExpression ("i"),
new CodeBinaryOperatorExpression
(new CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression (5)));
cmm.Statements.Add (new CodeLabeledStatement ("label", assignmt));
condstmt = new CodeConditionStatement (new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression (1)),
new CodeGotoStatement ("label"));
cmm.Statements.Add (condstmt);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("i")));
class1.Members.Add (cmm);
}
}
/// <summary>
/// See <see cref="CodeProcessor.ProcessGeneratedCode"/>.
/// </summary>
/// <param name="domainServiceDescription">The domainServiceDescription</param>
/// <param name="codeCompileUnit">The codeCompileUnit</param>
/// <param name="typeMapping">The typeMapping</param>
public override void ProcessGeneratedCode(DomainServiceDescription domainServiceDescription, CodeCompileUnit codeCompileUnit, IDictionary <Type, CodeTypeDeclaration> typeMapping)
{
// Make sure the provider extends IAuthentication<T>
Type genericDomainServiceType;
AuthenticationCodeProcessor.CheckIAuthentication(domainServiceDescription, out genericDomainServiceType);
Type userEntityType = genericDomainServiceType.GetGenericArguments()[0];
AuthenticationCodeProcessor.CheckIUser(userEntityType);
// Implement IPrincipal and IIdentity in the user type
CodeTypeDeclaration entityTypeDeclaration;
typeMapping.TryGetValue(userEntityType, out entityTypeDeclaration);
if (entityTypeDeclaration != null)
{
CodeTypeReference identityInterfaceTypeReference =
new CodeTypeReference(typeof(IIdentity))
{
Options = CodeTypeReferenceOptions.GlobalReference
};
CodeTypeReference principalInterfaceTypeReference =
new CodeTypeReference(typeof(IPrincipal))
{
Options = CodeTypeReferenceOptions.GlobalReference
};
entityTypeDeclaration.BaseTypes.Add(identityInterfaceTypeReference);
entityTypeDeclaration.BaseTypes.Add(principalInterfaceTypeReference);
////
//// private string IIdentitiy.AuthenticationType
////
CodeMemberProperty authenticationTypeProperty = new CodeMemberProperty()
{
Attributes = MemberAttributes.Private | MemberAttributes.Final,
HasGet = true,
Name = "AuthenticationType",
Type = new CodeTypeReference(typeof(string))
};
// get { return string.Empty; }
authenticationTypeProperty.GetStatements.Add(new CodeMethodReturnStatement(
new CodePropertyReferenceExpression(
new CodeTypeReferenceExpression(typeof(string)),
"Empty")));
authenticationTypeProperty.PrivateImplementationType = identityInterfaceTypeReference;
entityTypeDeclaration.Members.Add(authenticationTypeProperty);
////
//// public bool IsAuthenticated
////
CodeMemberProperty isAuthenticatedProperty = new CodeMemberProperty()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
HasGet = true,
Name = "IsAuthenticated",
Type = new CodeTypeReference(typeof(bool))
};
// get { return (true != string.IsNullOrEmpty(this.Name)); }
isAuthenticatedProperty.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(true),
CodeBinaryOperatorType.IdentityInequality,
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(string)),
"IsNullOrEmpty",
new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(),
"Name")))));
isAuthenticatedProperty.Comments.AddRange(
AuthenticationCodeProcessor.GetDocComments(Resources.ApplicationServices_CommentIsAuth));
isAuthenticatedProperty.ImplementationTypes.Add(identityInterfaceTypeReference);
entityTypeDeclaration.Members.Add(isAuthenticatedProperty);
////
//// private string IIdentity.Name
////
// VB Codegen requires us to implement a ReadOnly version of Name as well
CodeMemberProperty namePropertyExp = new CodeMemberProperty()
{
Attributes = MemberAttributes.Private | MemberAttributes.Final,
HasGet = true,
Name = "Name",
Type = new CodeTypeReference(typeof(string))
};
// get { return this.Name; }
namePropertyExp.GetStatements.Add(
new CodeMethodReturnStatement(
new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(),
"Name")));
namePropertyExp.PrivateImplementationType = identityInterfaceTypeReference;
entityTypeDeclaration.Members.Add(namePropertyExp);
////
//// private IIdentity IPrincipal.Identity
////
CodeMemberProperty identityProperty = new CodeMemberProperty()
{
Attributes = MemberAttributes.Private | MemberAttributes.Final,
HasGet = true,
Name = "Identity",
Type = identityInterfaceTypeReference,
};
// get { return this; }
identityProperty.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeThisReferenceExpression()));
identityProperty.PrivateImplementationType = principalInterfaceTypeReference;
entityTypeDeclaration.Members.Add(identityProperty);
////
//// public bool IsInRole(string role)
////
CodeMemberMethod isInRoleMethod = new CodeMemberMethod()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = "IsInRole",
ReturnType = new CodeTypeReference(typeof(bool))
};
isInRoleMethod.Parameters.Add(
new CodeParameterDeclarationExpression(
new CodeTypeReference(typeof(string)),
"role"));
// if (this.Roles == null)
// {
// return false;
// }
// return this.Roles.Contains(role);
CodeConditionStatement ifRolesNullStatement = new CodeConditionStatement();
ifRolesNullStatement.Condition = new CodeBinaryOperatorExpression(
new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(),
"Roles"),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null));
ifRolesNullStatement.TrueStatements.Add(
new CodeMethodReturnStatement(new CodePrimitiveExpression(false)));
isInRoleMethod.Statements.Add(ifRolesNullStatement);
isInRoleMethod.Statements.Add(
new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(
new CodeTypeReference(typeof(Enumerable))
{
Options = CodeTypeReferenceOptions.GlobalReference
}),
"Contains",
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Roles"),
new CodeVariableReferenceExpression("role"))));
isInRoleMethod.Comments.AddRange(
AuthenticationCodeProcessor.GetDocComments(Resources.ApplicationServices_CommentIsInRole));
isInRoleMethod.ImplementationTypes.Add(principalInterfaceTypeReference);
entityTypeDeclaration.Members.Add(isInRoleMethod);
// Changes to Name need to raise change notification for IsAuthenticated. To accomplish this,
// we'll insert a change event at the end of the "if (this._name != value)" block.
//
// >> this.RaisePropertyChanged("IsAuthenticated");
CodeMemberProperty nameProperty = entityTypeDeclaration.Members.OfType <CodeMemberProperty>().Where(c => c.Name == "Name").First();
nameProperty.SetStatements.OfType <CodeConditionStatement>().First().TrueStatements.Add(
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
"RaisePropertyChanged",
new CodePrimitiveExpression("IsAuthenticated"))));
// Name should be set to string.Empty by default
CodeMemberField nameField = entityTypeDeclaration.Members.OfType <CodeMemberField>().Where(c => c.Name == "_name").Single();
nameField.InitExpression =
new CodePropertyReferenceExpression(
new CodeTypeReferenceExpression(typeof(string)),
"Empty");
}
// Set context base type
CodeTypeDeclaration providerTypeDeclaration;
typeMapping.TryGetValue(domainServiceDescription.DomainServiceType, out providerTypeDeclaration);
if (providerTypeDeclaration != null)
{
providerTypeDeclaration.BaseTypes.Clear();
providerTypeDeclaration.BaseTypes.Add(
new CodeTypeReference(AuthenticationCodeProcessor.AuthenticationDomainContextBaseName)
{
Options = CodeTypeReferenceOptions.GlobalReference
});
}
}
public void Visit(CodeConditionStatement o)
{
g.GenerateConditionStatement(o);
}
/// <summary>
/// Create a static constructor for the data model.
/// </summary>
/// <param name="dataModelSchema">A description of the data model.</param>
public LoadDataMethod(DataModelSchema dataModelSchema)
{
// /// <summary>
// /// Loads data from the persistent store into the data model.
// /// </summary>
// private static void LoadData()
// {
this.Comments.Add(new CodeCommentStatement("<summary>", true));
this.Comments.Add(new CodeCommentStatement("Loads data from the persistent store into the data model.", true));
this.Comments.Add(new CodeCommentStatement("</summary>", true));
this.Name = "LoadData";
this.Attributes = MemberAttributes.Public | MemberAttributes.Final;
// try {
CodeTryCatchFinallyStatement tryLoadData = new CodeTryCatchFinallyStatement();
// this.dataLock.EnterWriteLock();
tryLoadData.TryStatements.Add(new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "dataLock"), "EnterWriteLock"));
// global::System.Configuration.ConnectionStringSettings connectionStringSettings = global::System.Configuration.ConfigurationManager.ConnectionStrings["DataModel"];
// global::System.Data.SqlClient.SqlConnection sqlConnection = new global::System.Data.SqlClient.SqlConnection(connectionStringSettings.ConnectionString);
// sqlConnection.Open();
tryLoadData.TryStatements.Add(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(SqlConnection)), "sqlConnection", new CodeObjectCreateExpression(new CodeGlobalTypeReference(typeof(SqlConnection)), new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "connectionString"))));
tryLoadData.TryStatements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("sqlConnection"), "Open"));
// this.EnforceConstraints = false;
tryLoadData.TryStatements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "EnforceConstraints"), new CodePrimitiveExpression(false)));
// for (int tableIndex = 0; (tableIndex < this.Tables.Count); tableIndex = (tableIndex + 1)) {
CodeIterationStatement tableLoop1 = new CodeIterationStatement(
new CodeVariableDeclarationStatement(
new CodeGlobalTypeReference(typeof(Int32)),
"tableIndex",
new CodePrimitiveExpression(0)),
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("tableIndex"),
CodeBinaryOperatorType.LessThan,
new CodePropertyReferenceExpression(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Tables"), "Count")),
new CodeAssignStatement(
new CodeVariableReferenceExpression("tableIndex"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("tableIndex"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))));
// global::System.Data.DataTable dataTable = Teraque.UnitTest.Server.DataModel.Tables[tableIndex];
tableLoop1.Statements.Add(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(DataTable)), "dataTable", new CodeIndexerExpression(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Tables"), new CodeVariableReferenceExpression("tableIndex"))));
// global::System.Data.DataColumn rowVersionColumn = dataTable.Columns["RowVersion"];
tableLoop1.Statements.Add(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(DataColumn)), "rowVersionColumn",
new CodeIndexerExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataTable"), "Columns"), new CodePrimitiveExpression("RowVersion"))));
// if (((bool)(dataTable.ExtendedProperties["IsPersistent"]))) {
CodeConditionStatement ifPersistent = new CodeConditionStatement();
ifPersistent.Condition = new CodeCastExpression(new CodeGlobalTypeReference(typeof(Boolean)), new CodeIndexerExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataTable"), "ExtendedProperties"), new CodePrimitiveExpression("IsPersistent")));
// string columnList = "\"IsArchived\", \"IsDeleted\"";
// for (int columnIndex = 0; (columnIndex < dataTable.Columns.Count); columnIndex = (columnIndex + 1)) {
// global::System.Data.DataColumn dataColumn = dataTable.Columns[columnIndex];
// if (((bool)(dataColumn.ExtendedProperties["IsPersistent"]))) {
// columnList = (columnList
// + (",\""
// + (dataColumn.ColumnName + "\"")));
// }
// }
ifPersistent.TrueStatements.Add(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(String)), "columnList", new CodePrimitiveExpression("\"IsArchived\", \"IsDeleted\"")));
CodeIterationStatement columnLoop1 = new CodeIterationStatement(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(Int32)), "columnIndex", new CodePrimitiveExpression(0)), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("columnIndex"), CodeBinaryOperatorType.LessThan, new CodePropertyReferenceExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataTable"), "Columns"), "Count")), new CodeAssignStatement(new CodeVariableReferenceExpression("columnIndex"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("columnIndex"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))));
columnLoop1.Statements.Add(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(DataColumn)), "dataColumn", new CodeIndexerExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataTable"), "Columns"), new CodeVariableReferenceExpression("columnIndex"))));
columnLoop1.Statements.Add(new CodeConditionStatement(new CodeCastExpression(new CodeGlobalTypeReference(typeof(Boolean)), new CodeIndexerExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataColumn"), "ExtendedProperties"), new CodePrimitiveExpression("IsPersistent"))),
new CodeAssignStatement(new CodeVariableReferenceExpression("columnList"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("columnList"), CodeBinaryOperatorType.Add, new CodeBinaryOperatorExpression(new CodePrimitiveExpression(",\""), CodeBinaryOperatorType.Add, new CodeBinaryOperatorExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataColumn"), "ColumnName"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression("\"")))))));
ifPersistent.TrueStatements.Add(columnLoop1);
// string selectCommand = String.Format("select {0} from \"{1}\"", columnList, dataTable.TableName);
// System.Data.SqlClient.SqlCommand sqlCommand = new System.Data.SqlClient.SqlCommand(selectCommand);
// sqlCommand.Connection = sqlConnection;
// System.Data.SqlClient.SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
ifPersistent.TrueStatements.Add(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(String)), "selectCommand", new CodeMethodInvokeExpression(new CodeGlobalTypeReferenceExpression(typeof(String)), "Format", new CodePrimitiveExpression("select {0} from \"{1}\""), new CodeVariableReferenceExpression("columnList"), new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataTable"), "TableName"))));
ifPersistent.TrueStatements.Add(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(SqlCommand)), "sqlCommand", new CodeObjectCreateExpression(new CodeGlobalTypeReference(typeof(SqlCommand)), new CodeVariableReferenceExpression("selectCommand"))));
ifPersistent.TrueStatements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("sqlCommand"), "Connection"), new CodeVariableReferenceExpression("sqlConnection")));
ifPersistent.TrueStatements.Add(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(SqlDataReader)), "sqlDataReader", new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("sqlCommand"), "ExecuteReader")));
// for (
// ; (sqlDataReader.Read() == true);
// ) {
CodeIterationStatement readLoop = new CodeIterationStatement(new CodeSnippetStatement(""), new CodeBinaryOperatorExpression(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("sqlDataReader"), "Read"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(true)), new CodeSnippetStatement(""));
// if (((((bool)(sqlDataReader["IsArchived"])) == true)
// || (((bool)(sqlDataReader["IsDeleted"])) == true))) {
// long rowVersion = ((long)(sqlDataReader["RowVersion"]));
// if ((rowVersion > Teraque.UnitTest.Server.DataModel.masterRowVersion)) {
// Teraque.UnitTest.Server.DataModel.masterRowVersion = rowVersion;
// }
// }
CodeConditionStatement activeRecords = new CodeConditionStatement(new CodeBinaryOperatorExpression(new CodeBinaryOperatorExpression(new CodeCastExpression(typeof(Boolean), new CodeIndexerExpression(new CodeVariableReferenceExpression("sqlDataReader"), new CodePrimitiveExpression("IsArchived"))), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(true)), CodeBinaryOperatorType.BooleanOr, new CodeBinaryOperatorExpression(new CodeCastExpression(typeof(Boolean), new CodeIndexerExpression(new CodeVariableReferenceExpression("sqlDataReader"), new CodePrimitiveExpression("IsDeleted"))), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(true))));
activeRecords.TrueStatements.Add(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(Int64)), "rowVersion", new CodeCastExpression(typeof(Int64), new CodeIndexerExpression(new CodeVariableReferenceExpression("sqlDataReader"), new CodePrimitiveExpression("RowVersion")))));
CodeConditionStatement ifRowVersionUpdate = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("rowVersion"),
CodeBinaryOperatorType.GreaterThan,
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "rowVersion")));
ifRowVersionUpdate.TrueStatements.Add(
new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "rowVersion"),
new CodeVariableReferenceExpression("rowVersion")));
activeRecords.TrueStatements.Add(ifRowVersionUpdate);
// else {
// global::System.Data.DataRow dataRow = dataTable.NewRow();
activeRecords.FalseStatements.Add(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(DataRow)), "dataRow", new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("dataTable"), "NewRow")));
// for (int ordinal = 0; (ordinal < sqlDataReader.FieldCount); ordinal = (ordinal + 1)) {
// global::System.Data.DataColumn destinationColumn = dataTable.Columns[sqlDataReader.GetName(ordinal)];
// if ((destinationColumn != null)) {
// dataRow[destinationColumn] = sqlDataReader.GetValue(ordinal);
// }
// }
CodeIterationStatement ordinalLoop = new CodeIterationStatement(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(Int32)), "ordinal", new CodePrimitiveExpression(0)), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("ordinal"), CodeBinaryOperatorType.LessThan, new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("sqlDataReader"), "FieldCount")), new CodeAssignStatement(new CodeVariableReferenceExpression("ordinal"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("ordinal"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))));
ordinalLoop.Statements.Add(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(DataColumn)), "destinationColumn", new CodeIndexerExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataTable"), "Columns"), new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("sqlDataReader"), "GetName", new CodeVariableReferenceExpression("ordinal")))));
ordinalLoop.Statements.Add(new CodeConditionStatement(new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("destinationColumn"), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)),
new CodeAssignStatement(new CodeIndexerExpression(new CodeVariableReferenceExpression("dataRow"), new CodeVariableReferenceExpression("destinationColumn")), new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("sqlDataReader"), "GetValue", new CodeVariableReferenceExpression("ordinal")))));
activeRecords.FalseStatements.Add(ordinalLoop);
// dataTable.Rows.Add(dataRow);
// if ((((long)(dataRow["RowVersion"])) > Teraque.UnitTest.Server.DataModel.masterRowVersion)) {
// Teraque.UnitTest.Server.DataModel.masterRowVersion = ((long)(dataRow["RowVersion"]));
// }
activeRecords.FalseStatements.Add(new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataTable"), "Rows"), "Add", new CodeVariableReferenceExpression("dataRow")));
CodeConditionStatement ifBiggerRowVersion = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeCastExpression(
new CodeGlobalTypeReference(typeof(Int64)),
new CodeIndexerExpression(new CodeVariableReferenceExpression("dataRow"), new CodePrimitiveExpression("RowVersion"))),
CodeBinaryOperatorType.GreaterThan,
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "rowVersion")));
ifBiggerRowVersion.TrueStatements.Add(
new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "rowVersion"),
new CodeCastExpression(
new CodeGlobalTypeReference(typeof(Int64)),
new CodeIndexerExpression(new CodeVariableReferenceExpression("dataRow"), new CodePrimitiveExpression("RowVersion")))));
activeRecords.FalseStatements.Add(ifBiggerRowVersion);
// }
readLoop.Statements.Add(activeRecords);
// }
// sqlDataReader.Close();
ifPersistent.TrueStatements.Add(readLoop);
ifPersistent.TrueStatements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("sqlDataReader"), "Close"));
// }
tableLoop1.Statements.Add(ifPersistent);
// }
tryLoadData.TryStatements.Add(tableLoop1);
// Teraque.UnitTest.Server.DataModel.dataSet.EnforceConstraints = true;
tryLoadData.TryStatements.Add(
new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "EnforceConstraints"), new CodePrimitiveExpression(true)));
// global::System.Collections.Generic.List<object> transactionLogItem = new global::System.Collections.Generic.List<object>();
tryLoadData.TryStatements.Add(
new CodeVariableDeclarationStatement(
new CodeGlobalTypeReference(typeof(List <Object>)),
"transactionLogItem",
new CodeObjectCreateExpression(
new CodeGlobalTypeReference(typeof(List <Object>)))));
// for (int tableIndex = 0; (tableIndex < DataModel.Tables.Count); tableIndex = (tableIndex + 1))
// {
CodeIterationStatement tableLoop = new CodeIterationStatement(
new CodeVariableDeclarationStatement(
new CodeGlobalTypeReference(typeof(Int32)), "tableIndex", new CodePrimitiveExpression(0)),
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("tableIndex"),
CodeBinaryOperatorType.LessThan,
new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Tables"), "Count")),
new CodeAssignStatement(
new CodeVariableReferenceExpression("tableIndex"),
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("tableIndex"),
CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1))));
// global::System.Data.DataTable dataTable = DataModel.dataSet.Tables[tableIndex];
tableLoop.Statements.Add(
new CodeVariableDeclarationStatement(
new CodeGlobalTypeReference(typeof(DataTable)),
"dataTable",
new CodeIndexerExpression(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Tables"),
new CodeVariableReferenceExpression("tableIndex"))));
// for (int rowIndex = 0; (rowIndex < dataTable.Rows.Count); rowIndex = (rowIndex + 1))
// {
CodeIterationStatement rowLoop = new CodeIterationStatement(
new CodeVariableDeclarationStatement(
new CodeGlobalTypeReference(typeof(Int32)), "rowIndex", new CodePrimitiveExpression(0)),
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("rowIndex"),
CodeBinaryOperatorType.LessThan,
new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataTable"), "Rows"),
"Count")),
new CodeAssignStatement(
new CodeVariableReferenceExpression("rowIndex"),
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("rowIndex"),
CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1))));
// DataModel.Initialize(((global::Teraque.IRow)(dataTable.Rows[rowIndex])), transactionLogItem);
rowLoop.Statements.Add(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
"SequenceRecord",
new CodeCastExpression(new CodeGlobalTypeReference(typeof(IRow)),
new CodeIndexerExpression(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataTable"), "Rows"),
new CodeVariableReferenceExpression("rowIndex"))),
new CodeVariableReferenceExpression("transactionLogItem")));
// }
tableLoop.Statements.Add(rowLoop);
// }
tryLoadData.TryStatements.Add(tableLoop);
// }
// catch (global::System.Data.ConstraintException constraintException) {
// for (int tableIndex = 0; (tableIndex < Teraque.UnitTest.Server.DataModel.Tables.Count); tableIndex = (tableIndex + 1)) {
// global::System.Data.DataTable dataTable = Teraque.UnitTest.Server.DataModel.Tables[tableIndex];
// for (int rowIndex = 0; (rowIndex < dataTable.Rows.Count); rowIndex = (rowIndex + 1)) {
// global::System.Data.DataRow dataRow = dataTable.Rows[rowIndex];
// if ((dataRow.HasErrors == true)) {
// Log.Error("Error in \'{0}\': {1}", dataRow.Table.TableName, dataRow.RowError);
// }
// }
// }
// throw constraintException;
// }
CodeCatchClause catchConstraint = new CodeCatchClause("constraintException", new CodeGlobalTypeReference(typeof(ConstraintException)));
CodeIterationStatement constraintTableLoop = new CodeIterationStatement(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(Int32)), "tableIndex", new CodePrimitiveExpression(0)), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("tableIndex"), CodeBinaryOperatorType.LessThan, new CodePropertyReferenceExpression(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Tables"), "Count")), new CodeAssignStatement(new CodeVariableReferenceExpression("tableIndex"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("tableIndex"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))));
constraintTableLoop.Statements.Add(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(DataTable)), "dataTable", new CodeIndexerExpression(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Tables"), new CodeVariableReferenceExpression("tableIndex"))));
CodeIterationStatement constraintRowLoop = new CodeIterationStatement(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(Int32)), "rowIndex", new CodePrimitiveExpression(0)), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("rowIndex"), CodeBinaryOperatorType.LessThan, new CodePropertyReferenceExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataTable"), "Rows"), "Count")), new CodeAssignStatement(new CodeVariableReferenceExpression("rowIndex"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("rowIndex"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))));
constraintRowLoop.Statements.Add(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(DataRow)), "dataRow", new CodeIndexerExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataTable"), "Rows"), new CodeVariableReferenceExpression("rowIndex"))));
constraintRowLoop.Statements.Add(new CodeConditionStatement(new CodeBinaryOperatorExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataRow"), "HasErrors"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(true)),
new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeGlobalTypeReferenceExpression(typeof(Log)), "Error", new CodePrimitiveExpression("Error in '{0}': {1}"), new CodePropertyReferenceExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataRow"), "Table"), "TableName"), new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataRow"), "RowError")))));
constraintTableLoop.Statements.Add(constraintRowLoop);
catchConstraint.Statements.Add(constraintTableLoop);
catchConstraint.Statements.Add(new CodeThrowExceptionStatement(new CodeVariableReferenceExpression("constraintException")));
tryLoadData.CatchClauses.Add(catchConstraint);
// catch (global::System.Data.SqlClient.SqlException sqlException) {
// for (int errorIndex = 0; (errorIndex < sqlException.Errors.Count); errorIndex = (errorIndex + 1)) {
// Log.Error(sqlException.Errors[errorIndex].Message);
// }
// throw sqlException;
// }
CodeCatchClause catchSqlException = new CodeCatchClause("sqlException", new CodeGlobalTypeReference(typeof(SqlException)));
CodeIterationStatement sqlErrorLoop = new CodeIterationStatement(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(Int32)), "errorIndex", new CodePrimitiveExpression(0)), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("errorIndex"), CodeBinaryOperatorType.LessThan, new CodePropertyReferenceExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("sqlException"), "Errors"), "Count")), new CodeAssignStatement(new CodeVariableReferenceExpression("errorIndex"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("errorIndex"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))));
sqlErrorLoop.Statements.Add(new CodeMethodInvokeExpression(new CodeGlobalTypeReferenceExpression(typeof(Log)), "Error", new CodePropertyReferenceExpression(new CodeIndexerExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("sqlException"), "Errors"), new CodeVariableReferenceExpression("errorIndex")), "Message")));
catchSqlException.Statements.Add(sqlErrorLoop);
catchSqlException.Statements.Add(new CodeThrowExceptionStatement(new CodeVariableReferenceExpression("sqlException")));
tryLoadData.CatchClauses.Add(catchSqlException);
this.Statements.Add(tryLoadData);
// }
// finally
// {
// DataModel.dataLock.ExitWriteLock();
// }
tryLoadData.FinallyStatements.Add(
new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "dataLock"), "ExitWriteLock"));
// }
}
public void ForLoops()
{
var nspace = new CodeNamespace("NSPC");
CodeTypeDeclaration class1 = new CodeTypeDeclaration("ClassWithMethod");
class1.IsClass = true;
nspace.Types.Add(class1);
var 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 static int TestBasicIterationStatement() {
int i;
for (i = 1; (i < 8); i = (i * 2)) {
}
return i;
}
public static int TestComplexIterationStatement() {
int i;
int a = 7;
int b;
int c = 9;
int d = 2;
for (i = 0; (i < 2); i = (i + 1)) {
if ((a < 16)) {
for (b = 0; (b < 2); b = (b + 1)) {
if ((c < 10)) {
d = (d - 1);
}
d = (d * 2);
}
}
}
return d;
}
}
}");
}
private static CodeNamespace CreateMimsyNamespace()
{
var mimsyNamespace = new CodeNamespace("Mimsy");
mimsyNamespace.Imports.AddRange(new[]
{
new CodeNamespaceImport("System"),
new CodeNamespaceImport("System.Text"),
new CodeNamespaceImport("System.Collections")
});
var jubjubClass = new CodeTypeDeclaration("Jubjub")
{
TypeAttributes = TypeAttributes.Public
};
var wabeCountFld = new CodeMemberField(typeof(int), "_wabeCount")
{
Attributes = MemberAttributes.Private
};
jubjubClass.Members.Add(wabeCountFld);
var typrefArrayList = new CodeTypeReference("ArrayList");
var updatesFld = new CodeMemberField(typrefArrayList, "_updates");
jubjubClass.Members.Add(updatesFld);
mimsyNamespace.Types.Add(jubjubClass);
var jubjubCtor = new CodeConstructor {
Attributes = MemberAttributes.Public
};
var jubjubCtorParam = new CodeParameterDeclarationExpression(typeof(int), "wabeCount");
jubjubCtor.Parameters.Add(jubjubCtorParam);
var refUpdatesFld = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_updates");
var newArrayList = new CodeObjectCreateExpression(typrefArrayList);
var assignUpdates = new CodeAssignStatement(refUpdatesFld, newArrayList);
jubjubCtor.Statements.Add(assignUpdates);
var refWabeCountFld = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_wabeCount");
var refWabeCountProp = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "WabeCount");
var refWabeCountArg = new CodeArgumentReferenceExpression("wabeCount");
var assignWabeCount = new CodeAssignStatement(refWabeCountProp, refWabeCountArg);
jubjubCtor.Statements.Add(assignWabeCount);
jubjubClass.Members.Add(jubjubCtor);
var wabeCountProp = new CodeMemberProperty
{
Attributes = (MemberAttributes)24578,
Type = new CodeTypeReference(typeof(int)),
Name = "WabeCount"
};
wabeCountProp.GetStatements.Add(new CodeMethodReturnStatement(refWabeCountFld));
var suppliedPropertyValue = new CodePropertySetValueReferenceExpression();
var zero = new CodePrimitiveExpression(0);
var suppliedPropValIsLessThanZero = new CodeBinaryOperatorExpression(suppliedPropertyValue,
CodeBinaryOperatorType.LessThan, zero);
var testSuppliedPropValAndAssign = new CodeConditionStatement(suppliedPropValIsLessThanZero,
new CodeStatement[] { new CodeAssignStatement(refWabeCountFld, zero) },
new CodeStatement[] { new CodeAssignStatement(refWabeCountFld, suppliedPropertyValue) });
wabeCountProp.SetStatements.Add(testSuppliedPropValAndAssign);
wabeCountProp.SetStatements.Add(
new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(refUpdatesFld, "Add"), refWabeCountFld));
jubjubClass.Members.Add(wabeCountProp);
var methGetWabeCountHistory = new CodeMemberMethod
{
Attributes = (MemberAttributes)24578,
Name = "GetWabeCountHistory",
ReturnType = new CodeTypeReference(typeof(string))
};
jubjubClass.Members.Add(methGetWabeCountHistory);
methGetWabeCountHistory.Statements.Add(new CodeVariableDeclarationStatement("StringBuilder", "result"));
var refResultVar = new CodeVariableReferenceExpression("result");
methGetWabeCountHistory.Statements.Add(new CodeAssignStatement(refResultVar,
new CodeObjectCreateExpression("StringBuilder")));
methGetWabeCountHistory.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "ndx"));
var refNdxVar = new CodeVariableReferenceExpression("ndx");
methGetWabeCountHistory.Statements.Add(
new CodeIterationStatement(new CodeAssignStatement(refNdxVar, new CodePrimitiveExpression(0)),
new CodeBinaryOperatorExpression(refNdxVar, CodeBinaryOperatorType.LessThan,
new CodePropertyReferenceExpression(refUpdatesFld, "Count")),
new CodeAssignStatement(refNdxVar,
new CodeBinaryOperatorExpression(refNdxVar, CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))),
new CodeConditionStatement(
new CodeBinaryOperatorExpression(refNdxVar, CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(0)),
new CodeStatement[]
{
new CodeExpressionStatement(
new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(refResultVar, "AppendFormat"),
new CodePrimitiveExpression("{0}"), new CodeArrayIndexerExpression(refUpdatesFld, refNdxVar)))
},
new CodeStatement[]
{
new CodeExpressionStatement(
new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(refResultVar, "AppendFormat"),
new CodePrimitiveExpression(", {0}"),
new CodeArrayIndexerExpression(refUpdatesFld, refNdxVar)))
})));
methGetWabeCountHistory.Statements.Add(
new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(refResultVar, "ToString"))));
return(mimsyNamespace);
}
public void ProviderSupports()
{
CodeDomProvider provider = GetProvider();
var cu = new CodeCompileUnit();
var nspace = new CodeNamespace("NSPC");
nspace.Imports.Add(new CodeNamespaceImport("System"));
nspace.Imports.Add(new CodeNamespaceImport("System.Drawing"));
nspace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
nspace.Imports.Add(new CodeNamespaceImport("System.ComponentModel"));
cu.Namespaces.Add(nspace);
var cd = new CodeTypeDeclaration("TEST");
cd.IsClass = true;
nspace.Types.Add(cd);
// Arrays of Arrays
var cmm = new CodeMemberMethod();
cmm.Name = "ArraysOfArrays";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public;
if (provider.Supports(GeneratorSupport.ArraysOfArrays))
{
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int[][])),
"arrayOfArrays", new CodeArrayCreateExpression(typeof(int[][]),
new CodeArrayCreateExpression(typeof(int[]), new CodePrimitiveExpression(3), new CodePrimitiveExpression(4)),
new CodeArrayCreateExpression(typeof(int[]), new CodeExpression[] { new CodePrimitiveExpression(1) }))));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeArrayIndexerExpression(
new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("arrayOfArrays"), new CodePrimitiveExpression(0))
, new CodePrimitiveExpression(1))));
}
else
{
cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(0)));
}
cd.Members.Add(cmm);
// assembly attributes
if (provider.Supports(GeneratorSupport.AssemblyAttributes))
{
CodeAttributeDeclarationCollection attrs = cu.AssemblyCustomAttributes;
attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyTitle", new
CodeAttributeArgument(new CodePrimitiveExpression("MyAssembly"))));
attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyVersion", new
CodeAttributeArgument(new CodePrimitiveExpression("1.0.6.2"))));
}
CodeTypeDeclaration class1 = new CodeTypeDeclaration();
if (provider.Supports(GeneratorSupport.ChainedConstructorArguments))
{
class1.Name = "Test2";
class1.IsClass = true;
nspace.Types.Add(class1);
class1.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(String)), "stringField"));
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = "accessStringField";
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
prop.Type = new CodeTypeReference(typeof(String));
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
"stringField")));
prop.SetStatements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new
CodeThisReferenceExpression(), "stringField"),
new CodePropertySetValueReferenceExpression()));
class1.Members.Add(prop);
CodeConstructor cctor = new CodeConstructor();
cctor.Attributes = MemberAttributes.Public;
cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression("testingString"));
cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression(null));
cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression(null));
class1.Members.Add(cctor);
CodeConstructor cc = new CodeConstructor();
cc.Attributes = MemberAttributes.Public | MemberAttributes.Overloaded;
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p1"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p2"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p3"));
cc.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression()
, "stringField"), new CodeVariableReferenceExpression("p1")));
class1.Members.Add(cc);
// verify chained constructors work
cmm = new CodeMemberMethod();
cmm.Name = "ChainedConstructorUse";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference(typeof(String));
// utilize constructor
cmm.Statements.Add(new CodeVariableDeclarationStatement("Test2", "t", new CodeObjectCreateExpression("Test2")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression("t"), "accessStringField")));
cd.Members.Add(cmm);
}
// complex expressions
if (provider.Supports(GeneratorSupport.ComplexExpressions))
{
cmm = new CodeMemberMethod();
cmm.Name = "ComplexExpressions";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public;
cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i"));
cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("i"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Multiply,
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(3)))));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("i")));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareEnums))
{
CodeTypeDeclaration ce = new CodeTypeDeclaration("DecimalEnum");
ce.IsEnum = true;
nspace.Types.Add(ce);
// things to enumerate
for (int k = 0; k < 5; k++)
{
CodeMemberField Field = new CodeMemberField("System.Int32", "Num" + (k).ToString());
Field.InitExpression = new CodePrimitiveExpression(k);
ce.Members.Add(Field);
}
cmm = new CodeMemberMethod();
cmm.Name = "OutputDecimalEnumVal";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i");
cmm.Parameters.Add(param);
CodeBinaryOperatorExpression eq = new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(3));
CodeMethodReturnStatement truestmt = new CodeMethodReturnStatement(
new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num3")));
CodeConditionStatement condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(4));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num4")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(2));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num2")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(1));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num1")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(0));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num0")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
cmm.ReturnType = new CodeTypeReference("System.int32");
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(10))));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareInterfaces))
{
cmm = new CodeMemberMethod();
cmm.Name = "TestSingleInterface";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement("TestSingleInterfaceImp", "t", new CodeObjectCreateExpression("TestSingleInterfaceImp")));
CodeMethodInvokeExpression methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t")
, "InterfaceMethod");
methodinvoke.Parameters.Add(new CodeVariableReferenceExpression("i"));
cmm.Statements.Add(new CodeMethodReturnStatement(methodinvoke));
cd.Members.Add(cmm);
class1 = new CodeTypeDeclaration("InterfaceA");
class1.IsInterface = true;
nspace.Types.Add(class1);
cmm = new CodeMemberMethod();
cmm.Attributes = MemberAttributes.Public;
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
class1.Members.Add(cmm);
if (provider.Supports(GeneratorSupport.MultipleInterfaceMembers))
{
CodeTypeDeclaration classDecl = new CodeTypeDeclaration("InterfaceB");
classDecl.IsInterface = true;
nspace.Types.Add(classDecl);
cmm = new CodeMemberMethod();
cmm.Name = "InterfaceMethod";
cmm.Attributes = MemberAttributes.Public;
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
classDecl.Members.Add(cmm);
CodeTypeDeclaration class2 = new CodeTypeDeclaration("TestMultipleInterfaceImp");
class2.BaseTypes.Add(new CodeTypeReference("System.Object"));
class2.BaseTypes.Add(new CodeTypeReference("InterfaceB"));
class2.BaseTypes.Add(new CodeTypeReference("InterfaceA"));
class2.IsClass = true;
nspace.Types.Add(class2);
cmm = new CodeMemberMethod();
cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceA"));
cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceB"));
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
class2.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "TestMultipleInterfaces";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement("TestMultipleInterfaceImp", "t", new CodeObjectCreateExpression("TestMultipleInterfaceImp")));
cmm.Statements.Add(new CodeVariableDeclarationStatement("InterfaceA", "interfaceAobject", new CodeCastExpression("InterfaceA",
new CodeVariableReferenceExpression("t"))));
cmm.Statements.Add(new CodeVariableDeclarationStatement("InterfaceB", "interfaceBobject", new CodeCastExpression("InterfaceB",
new CodeVariableReferenceExpression("t"))));
methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("interfaceAobject")
, "InterfaceMethod");
methodinvoke.Parameters.Add(new CodeVariableReferenceExpression("i"));
CodeMethodInvokeExpression methodinvoke2 = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("interfaceBobject")
, "InterfaceMethod");
methodinvoke2.Parameters.Add(new CodeVariableReferenceExpression("i"));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
methodinvoke,
CodeBinaryOperatorType.Subtract, methodinvoke2)));
cd.Members.Add(cmm);
}
class1 = new CodeTypeDeclaration("TestSingleInterfaceImp");
class1.BaseTypes.Add(new CodeTypeReference("System.Object"));
class1.BaseTypes.Add(new CodeTypeReference("InterfaceA"));
class1.IsClass = true;
nspace.Types.Add(class1);
cmm = new CodeMemberMethod();
cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceA"));
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
class1.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareValueTypes))
{
CodeTypeDeclaration structA = new CodeTypeDeclaration("structA");
structA.IsStruct = true;
CodeTypeDeclaration structB = new CodeTypeDeclaration("structB");
structB.Attributes = MemberAttributes.Public;
structB.IsStruct = true;
CodeMemberField firstInt = new CodeMemberField(typeof(int), "int1");
firstInt.Attributes = MemberAttributes.Public;
structB.Members.Add(firstInt);
CodeMemberField innerStruct = new CodeMemberField("structB", "innerStruct");
innerStruct.Attributes = MemberAttributes.Public;
structA.Members.Add(structB);
structA.Members.Add(innerStruct);
nspace.Types.Add(structA);
CodeMemberMethod nestedStructMethod = new CodeMemberMethod();
nestedStructMethod.Name = "NestedStructMethod";
nestedStructMethod.ReturnType = new CodeTypeReference(typeof(int));
nestedStructMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeVariableDeclarationStatement varStructA = new CodeVariableDeclarationStatement("structA", "varStructA");
nestedStructMethod.Statements.Add(varStructA);
nestedStructMethod.Statements.Add
(
new CodeAssignStatement
(
/* Expression1 */ new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("varStructA"), "innerStruct"), "int1"),
/* Expression1 */ new CodePrimitiveExpression(3)
)
);
nestedStructMethod.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("varStructA"), "innerStruct"), "int1")));
cd.Members.Add(nestedStructMethod);
}
if (provider.Supports(GeneratorSupport.EntryPointMethod))
{
CodeEntryPointMethod cep = new CodeEntryPointMethod();
cd.Members.Add(cep);
}
// goto statements
if (provider.Supports(GeneratorSupport.GotoStatements))
{
cmm = new CodeMemberMethod();
cmm.Name = "GoToMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i");
cmm.Parameters.Add(param);
CodeConditionStatement condstmt = new CodeConditionStatement(new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(1)),
new CodeGotoStatement("comehere"));
cmm.Statements.Add(condstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(6)));
cmm.Statements.Add(new CodeLabeledStatement("comehere",
new CodeMethodReturnStatement(new CodePrimitiveExpression(7))));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.NestedTypes))
{
cmm = new CodeMemberMethod();
cmm.Name = "CallingPublicNestedScenario";
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference
("PublicNestedClassA+PublicNestedClassB2+PublicNestedClassC"), "t",
new CodeObjectCreateExpression(new CodeTypeReference
("PublicNestedClassA+PublicNestedClassB2+PublicNestedClassC"))));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t"),
"publicNestedClassesMethod",
new CodeVariableReferenceExpression("i"))));
cd.Members.Add(cmm);
class1 = new CodeTypeDeclaration("PublicNestedClassA");
class1.IsClass = true;
nspace.Types.Add(class1);
CodeTypeDeclaration nestedClass = new CodeTypeDeclaration("PublicNestedClassB1");
nestedClass.IsClass = true;
nestedClass.TypeAttributes = TypeAttributes.NestedPublic;
class1.Members.Add(nestedClass);
nestedClass = new CodeTypeDeclaration("PublicNestedClassB2");
nestedClass.TypeAttributes = TypeAttributes.NestedPublic;
nestedClass.IsClass = true;
class1.Members.Add(nestedClass);
CodeTypeDeclaration innerNestedClass = new CodeTypeDeclaration("PublicNestedClassC");
innerNestedClass.TypeAttributes = TypeAttributes.NestedPublic;
innerNestedClass.IsClass = true;
nestedClass.Members.Add(innerNestedClass);
cmm = new CodeMemberMethod();
cmm.Name = "publicNestedClassesMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
innerNestedClass.Members.Add(cmm);
}
// Parameter Attributes
if (provider.Supports(GeneratorSupport.ParameterAttributes))
{
CodeMemberMethod method1 = new CodeMemberMethod();
method1.Name = "MyMethod";
method1.Attributes = MemberAttributes.Public | MemberAttributes.Final;
CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(string), "blah");
param1.CustomAttributes.Add(
new CodeAttributeDeclaration(
"System.Xml.Serialization.XmlElementAttribute",
new CodeAttributeArgument(
"Form",
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.Xml.Schema.XmlSchemaForm"), "Unqualified")),
new CodeAttributeArgument(
"IsNullable",
new CodePrimitiveExpression(false))));
method1.Parameters.Add(param1);
cd.Members.Add(method1);
}
// public static members
if (provider.Supports(GeneratorSupport.PublicStaticMembers))
{
cmm = new CodeMemberMethod();
cmm.Name = "PublicStaticMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(16)));
cd.Members.Add(cmm);
}
// reference parameters
if (provider.Supports(GeneratorSupport.ReferenceParameters))
{
cmm = new CodeMemberMethod();
cmm.Name = "Work";
cmm.ReturnType = new CodeTypeReference("System.void");
cmm.Attributes = MemberAttributes.Static;
// add parameter with ref direction
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i");
param.Direction = FieldDirection.Ref;
cmm.Parameters.Add(param);
// add parameter with out direction
param = new CodeParameterDeclarationExpression(typeof(int), "j");
param.Direction = FieldDirection.Out;
cmm.Parameters.Add(param);
cmm.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("i"),
new CodeBinaryOperatorExpression(new CodeArgumentReferenceExpression("i"),
CodeBinaryOperatorType.Add, new CodePrimitiveExpression(4))));
cmm.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("j"),
new CodePrimitiveExpression(5)));
cd.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "CallingWork";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression parames = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(parames);
cmm.ReturnType = new CodeTypeReference("System.int32");
cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(10)));
cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "b"));
// invoke the method called "work"
CodeMethodInvokeExpression methodinvoked = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression
(new CodeTypeReferenceExpression("TEST"), "Work"));
// add parameter with ref direction
CodeDirectionExpression parameter = new CodeDirectionExpression(FieldDirection.Ref,
new CodeVariableReferenceExpression("a"));
methodinvoked.Parameters.Add(parameter);
// add parameter with out direction
parameter = new CodeDirectionExpression(FieldDirection.Out, new CodeVariableReferenceExpression("b"));
methodinvoked.Parameters.Add(parameter);
cmm.Statements.Add(methodinvoked);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression
(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression("b"))));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.ReturnTypeAttributes))
{
CodeMemberMethod function1 = new CodeMemberMethod();
function1.Name = "MyFunction";
function1.ReturnType = new CodeTypeReference(typeof(string));
function1.Attributes = MemberAttributes.Public | MemberAttributes.Final;
function1.ReturnTypeCustomAttributes.Add(new
CodeAttributeDeclaration("System.Xml.Serialization.XmlIgnoreAttribute"));
function1.ReturnTypeCustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlRootAttribute", new
CodeAttributeArgument("Namespace", new CodePrimitiveExpression("Namespace Value")), new
CodeAttributeArgument("ElementName", new CodePrimitiveExpression("Root, hehehe"))));
function1.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression("Return")));
cd.Members.Add(function1);
}
if (provider.Supports(GeneratorSupport.StaticConstructors))
{
cmm = new CodeMemberMethod();
cmm.Name = "TestStaticConstructor";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference(typeof(int));
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
// utilize constructor
cmm.Statements.Add(new CodeVariableDeclarationStatement("Test4", "t", new CodeObjectCreateExpression("Test4")));
// set then get number
cmm.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("t"), "i")
, new CodeVariableReferenceExpression("a")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression("t"), "i")));
cd.Members.Add(cmm);
class1 = new CodeTypeDeclaration();
class1.Name = "Test4";
class1.IsClass = true;
nspace.Types.Add(class1);
class1.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(int)), "number"));
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = "i";
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
prop.Type = new CodeTypeReference(typeof(int));
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("number")));
prop.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("number"),
new CodePropertySetValueReferenceExpression()));
class1.Members.Add(prop);
CodeTypeConstructor ctc = new CodeTypeConstructor();
class1.Members.Add(ctc);
}
if (provider.Supports(GeneratorSupport.TryCatchStatements))
{
cmm = new CodeMemberMethod();
cmm.Name = "TryCatchMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
CodeTryCatchFinallyStatement tcfstmt = new CodeTryCatchFinallyStatement();
tcfstmt.FinallyStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"), new
CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(5))));
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareEvents))
{
CodeNamespace ns = new CodeNamespace();
ns.Name = "MyNamespace";
ns.Imports.Add(new CodeNamespaceImport("System"));
ns.Imports.Add(new CodeNamespaceImport("System.Drawing"));
ns.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
ns.Imports.Add(new CodeNamespaceImport("System.ComponentModel"));
cu.Namespaces.Add(ns);
class1 = new CodeTypeDeclaration("Test");
class1.IsClass = true;
class1.BaseTypes.Add(new CodeTypeReference("Form"));
ns.Types.Add(class1);
CodeMemberField mfield = new CodeMemberField(new CodeTypeReference("Button"), "b");
mfield.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference("Button"));
class1.Members.Add(mfield);
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Public;
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
"Size"), new CodeObjectCreateExpression(new CodeTypeReference("Size"),
new CodePrimitiveExpression(600), new CodePrimitiveExpression(600))));
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"),
"Text"), new CodePrimitiveExpression("Test")));
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"),
"TabIndex"), new CodePrimitiveExpression(0)));
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"),
"Location"), new CodeObjectCreateExpression(new CodeTypeReference("Point"),
new CodePrimitiveExpression(400), new CodePrimitiveExpression(525))));
ctor.Statements.Add(new CodeAttachEventStatement(new CodeEventReferenceExpression(new
CodeThisReferenceExpression(), "MyEvent"), new CodeDelegateCreateExpression(new CodeTypeReference("EventHandler")
, new CodeThisReferenceExpression(), "b_Click")));
class1.Members.Add(ctor);
CodeMemberEvent evt = new CodeMemberEvent();
evt.Name = "MyEvent";
evt.Type = new CodeTypeReference("System.EventHandler");
evt.Attributes = MemberAttributes.Public;
class1.Members.Add(evt);
cmm = new CodeMemberMethod();
cmm.Name = "b_Click";
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender"));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(EventArgs), "e"));
class1.Members.Add(cmm);
}
AssertEqual(cu,
@"//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
[assembly: System.Reflection.AssemblyTitle(""MyAssembly"")]
[assembly: System.Reflection.AssemblyVersion(""1.0.6.2"")]
namespace NSPC {
using System;
using System.Drawing;
using System.Windows.Forms;
using System.ComponentModel;
public class TEST {
public int ArraysOfArrays() {
int[][] arrayOfArrays = new int[][] {
new int[] { 3, 4},
new int[] { 1}};
return arrayOfArrays[0][1];
}
public static string ChainedConstructorUse() {
Test2 t = new Test2();
return t.accessStringField;
}
public int ComplexExpressions(int i) {
i = (i * (i + 3));
return i;
}
public static int OutputDecimalEnumVal(int i) {
if ((i == 3)) {
return ((int)(DecimalEnum.Num3));
}
if ((i == 4)) {
return ((int)(DecimalEnum.Num4));
}
if ((i == 2)) {
return ((int)(DecimalEnum.Num2));
}
if ((i == 1)) {
return ((int)(DecimalEnum.Num1));
}
if ((i == 0)) {
return ((int)(DecimalEnum.Num0));
}
return (i + 10);
}
public static int TestSingleInterface(int i) {
TestSingleInterfaceImp t = new TestSingleInterfaceImp();
return t.InterfaceMethod(i);
}
public static int TestMultipleInterfaces(int i) {
TestMultipleInterfaceImp t = new TestMultipleInterfaceImp();
InterfaceA interfaceAobject = ((InterfaceA)(t));
InterfaceB interfaceBobject = ((InterfaceB)(t));
return (interfaceAobject.InterfaceMethod(i) - interfaceBobject.InterfaceMethod(i));
}
public static int NestedStructMethod() {
structA varStructA;
varStructA.innerStruct.int1 = 3;
return varStructA.innerStruct.int1;
}
public static void Main() { }
public int GoToMethod(int i) {
if ((i < 1)) {
goto comehere;
}
return 6;
comehere:
return 7;
}
public static int CallingPublicNestedScenario(int i) {
PublicNestedClassA.PublicNestedClassB2.PublicNestedClassC t = new PublicNestedClassA.PublicNestedClassB2.PublicNestedClassC();
return t.publicNestedClassesMethod(i);
}
public void MyMethod([System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable=false)] string blah) {
}
public static int PublicStaticMethod() {
return 16;
}
static void Work(ref int i, out int j) {
i = (i + 4);
j = 5;
}
public static int CallingWork(int a) {
a = 10;
int b;
TEST.Work(ref a, out b);
return (a + b);
}
[return: System.Xml.Serialization.XmlIgnoreAttribute()]
[return: System.Xml.Serialization.XmlRootAttribute(Namespace=""Namespace Value"", ElementName=""Root, hehehe"")]
public string MyFunction() {
return ""Return"";
}
public static int TestStaticConstructor(int a) {
Test4 t = new Test4();
t.i = a;
return t.i;
}
public static int TryCatchMethod(int a) {
try {
}
finally {
a = (a + 5);
}
return a;
}
}
public class Test2 {
private string stringField;
public Test2() :
this(""testingString"", null, null) {
}
public Test2(string p1, string p2, string p3) {
this.stringField = p1;
}
public string accessStringField {
get {
return this.stringField;
}
set {
this.stringField = value;
}
}
}
public enum DecimalEnum {
Num0 = 0,
Num1 = 1,
Num2 = 2,
Num3 = 3,
Num4 = 4,
}
public interface InterfaceA {
int InterfaceMethod(int a);
}
public interface InterfaceB {
int InterfaceMethod(int a);
}
public class TestMultipleInterfaceImp : object, InterfaceB, InterfaceA {
public int InterfaceMethod(int a) {
return a;
}
}
public class TestSingleInterfaceImp : object, InterfaceA {
public virtual int InterfaceMethod(int a) {
return a;
}
}
public struct structA {
public structB innerStruct;
public struct structB {
public int int1;
}
}
public class PublicNestedClassA {
public class PublicNestedClassB1 { }
public class PublicNestedClassB2 {
public class PublicNestedClassC {
public int publicNestedClassesMethod(int a) {
return a;
}
}
}
}
public class Test4 {
private int number;
static Test4() {
}
public int i {
get {
return number;
}
set {
number = value;
}
}
}
}
namespace MyNamespace {
using System;
using System.Drawing;
using System.Windows.Forms;
using System.ComponentModel;
public class Test : Form {
private Button b = new Button();
public Test() {
this.Size = new Size(600, 600);
b.Text = ""Test"";
b.TabIndex = 0;
b.Location = new Point(400, 525);
this.MyEvent += new EventHandler(this.b_Click);
}
public event System.EventHandler MyEvent;
private void b_Click(object sender, System.EventArgs e) {
}
}
}");
}
private void AddObjectItems(CodeTypeDeclaration codeType, string withEnumChoice, bool useSingular, CodeMemberProperty codeTypeMember, IList <string> nameOrder)
{
var propertyName = "Object" + codeTypeMember.Name;
var fieldName = "object" + codeTypeMember.Name;
var returnName = "ObjectItem";
var constructorParameters = new List <CodeExpression> {
new CodeThisReferenceExpression(), new CodePrimitiveExpression(codeTypeMember.Name)
};
if (!useSingular)
{
returnName += "s";
if (nameOrder != null)
{
var stringArray = new List <CodeExpression>();
stringArray.AddRange(nameOrder.Select(m => new CodePrimitiveExpression(m)));
var newOrderArray = new CodeArrayCreateExpression(typeof(string), stringArray.ToArray());
constructorParameters.Add(newOrderArray);
}
}
var codeMethodReferenceExpression = new CodeMethodReferenceExpression(null, "ObjectItems");
var returnType = new CodeTypeReference(returnName);
List <CodeStatement> trueStatements = null;
if (string.IsNullOrEmpty(withEnumChoice))
{
trueStatements = new List <CodeStatement>
{
new CodeVariableDeclarationStatement(typeof(Dictionary <System.Type, string>), "typeMapping",
new CodeObjectCreateExpression(typeof(Dictionary <System.Type, string>)))
};
// We need to add a type mapping since we have not access to a choice name.
foreach (var customAttribute in codeTypeMember.CustomAttributes.OfType <CodeAttributeDeclaration>())
{
if (customAttribute.Name == xmlElementAttributeString)
{
var name = ((CodePrimitiveExpression)customAttribute.Arguments[0].Value).Value;
var type = ((CodeTypeOfExpression)customAttribute.Arguments[1].Value).Type.BaseType;
trueStatements.Add(
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression("typeMapping"),
"Add",
new CodeSnippetExpression("typeof(" + type + ")"),
new CodePrimitiveExpression(name)
)
)
);
}
}
constructorParameters.Add(new CodeVariableReferenceExpression("typeMapping"));
}
else
{
var typeArgument = new CodeTypeReference(new CodeTypeParameter(withEnumChoice));
codeMethodReferenceExpression.TypeArguments.Add(typeArgument);
returnType.TypeArguments.Add(typeArgument);
}
var property = new CodeMemberProperty
{
Name = propertyName,
Type = returnType
};
var assignment1 =
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression(fieldName),
CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression()
)
);
if (trueStatements != null)
{
assignment1.TrueStatements.AddRange(trueStatements.ToArray());
}
assignment1.TrueStatements.Add(
new CodeAssignStatement(
new CodeVariableReferenceExpression(fieldName),
new CodeObjectCreateExpression(
returnType,
constructorParameters.ToArray()
)
));
property.GetStatements.Add(assignment1);
property.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(fieldName)));
codeType.Members.Add(property);
codeType.Members.Add(new CodeMemberField(returnType, fieldName));
}
protected override void GenerateConditionStatement
(CodeConditionStatement e)
{
Output.Write("if (");
GenerateExpression(e.Condition);
Output.Write(")");
StartBlock();
GenerateStatements(e.TrueStatements);
EndBlock();
CodeStatementCollection stmts = e.FalseStatements;
if(stmts.Count > 0 || Options.ElseOnClosing)
{
Output.Write("else");
StartBlock();
GenerateStatements(stmts);
EndBlock();
}
}
/// <summary>
/// Creates the CodeDOM for a method to insert a record into a table using transacted logic.
/// </summary>
/// <param name="tableSchema">A description of the table.</param>
public CreateMethod(TableSchema tableSchema)
{
// Create a matrix of parameters for this operation.
CreateParameterMatrix createParameterMatrix = new CreateParameterMatrix(tableSchema);
// /// <summary>
// /// Creates a Employee record.
// /// </summary>
// /// <param name="age">The required value for the Age column.</param>
// /// <param name="departmentId">The required value for the DepartmentId column.</param>
// /// <param name="employeeId">The required value for the EmployeeId column.</param>
// /// <param name="raceCode">The optional value for the RaceCode column.</param>
// [global::System.ServiceModel.OperationBehaviorAttribute(TransactionScopeRequired=true)]
// [Teraque.ClaimsPrincipalPermission(System.Security.Permissions.SecurityAction.Demand, ClaimType=Teraque.ClaimTypes.Create, Resource=Teraque.Resources.Application)]
// public void CreateEmployee(int age, int departmentId, int employeeId, object raceCode) {
this.Comments.Add(new CodeCommentStatement("<summary>", true));
this.Comments.Add(new CodeCommentStatement(String.Format("Creates a {0} record.", tableSchema.Name), true));
this.Comments.Add(new CodeCommentStatement("</summary>", true));
foreach (KeyValuePair <string, ExternalParameterItem> parameterPair in createParameterMatrix.ExternalParameterItems)
{
this.Comments.Add(new CodeCommentStatement(String.Format("<param name=\"{0}\">{1}</param>", parameterPair.Value.Name, parameterPair.Value.Description), true));
}
this.Attributes = MemberAttributes.Public | MemberAttributes.Final;
this.Name = String.Format("Create{0}", tableSchema.Name);
foreach (KeyValuePair <string, ExternalParameterItem> parameterPair in createParameterMatrix.ExternalParameterItems)
{
this.Parameters.Add(parameterPair.Value.CodeParameterDeclarationExpression);
}
// DataModelTransaction o1881 = DataModel.CurrentTransaction;
CodeVariableReferenceExpression transactionExpression = new CodeRandomVariableReferenceExpression();
this.Statements.Add(new CodeCreateTransactionStatement(tableSchema.DataModel, transactionExpression));
// if ((configurationId == null))
// {
// configurationId = "";
// }
// if ((indexName == null))
// {
// indexName = "";
// }
foreach (ColumnSchema columnSchema in tableSchema.Columns.Values)
{
if (columnSchema.IsNullable || columnSchema.DefaultValue != DBNull.Value)
{
// if ((indexName == null))
// {
// indexName = "";
// }
CodeConditionStatement ifIsNull = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeArgumentReferenceExpression(CommonConversion.ToCamelCase(columnSchema.Name)),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)));
ifIsNull.TrueStatements.Add(
new CodeAssignStatement(new CodeArgumentReferenceExpression(CommonConversion.ToCamelCase(columnSchema.Name)), CodeConvert.CreateConstantExpression(columnSchema.DefaultValue)));
this.Statements.Add(ifIsNull);
}
}
// Teraque.UnitTest.Server.DataModel.DepartmentRow departmentRowByFK_Department_Employee = Teraque.UnitTest.Server.DataModel.Department.FindByDepartmentId(new object[] {
// departmentId});
// if ((departmentRowByFK_Department_Employee == null)) {
// throw new global::System.ServiceModel.FaultException<RecordNotFoundFault>(new global::Teraque.RecordNotFoundFault("Attempt to access a Department record ({0}) that doesn\'t exist", departmentId));
// }
// // This record locked for reading for the duration of the transaction.
// departmentRowByFK_Department_Employee.AcquireReaderLock(middleTierTransaction.AdoResourceManager.Guid, Teraque.UnitTest.Server.DataModel.lockTimeout);
// middleTierTransaction.AdoResourceManager.AddLock(departmentRowByFK_Department_Employee);
// // This makes sure the record wasn't deleted in the time between when it was found and the time it was locked.
// if ((departmentRowByFK_Department_Employee.RowState == System.Data.DataRowState.Detached)) {
// throw new global::System.ServiceModel.FaultException<RecordNotFoundFault>(new global::Teraque.RecordNotFoundFault("Attempt to access a Department record ({0}) that doesn\'t exist", departmentId));
// }
// // Find the parent Object record if it is required for a foreign key constraint.
// Teraque.UnitTest.Server.DataModel.ObjectRow objectRowByFK_Object_Employee = Teraque.UnitTest.Server.DataModel.Object.FindByObjectId(new object[] {
// employeeId});
// if ((objectRowByFK_Object_Employee == null)) {
// throw new global::System.ServiceModel.FaultException<RecordNotFoundFault>(new global::Teraque.RecordNotFoundFault("Attempt to access a Object record ({0}) that doesn\'t exist", employeeId));
// }
// // This record locked for reading for the duration of the transaction.
// objectRowByFK_Object_Employee.AcquireReaderLock(middleTierTransaction.AdoResourceManager.Guid, Teraque.UnitTest.Server.DataModel.lockTimeout);
// middleTierTransaction.AdoResourceManager.AddLock(objectRowByFK_Object_Employee);
// // This makes sure the record wasn't deleted in the time between when it was found and the time it was locked.
// if ((objectRowByFK_Object_Employee.RowState == System.Data.DataRowState.Detached)) {
// throw new global::System.ServiceModel.FaultException<RecordNotFoundFault>(new global::Teraque.RecordNotFoundFault("Attempt to access a Object record ({0}) that doesn\'t exist", employeeId));
// }
// // Find the parent Race record if it is required for a foreign key constraint.
// if ((raceCode != System.DBNull.Value)) {
// Teraque.UnitTest.Server.DataModel.RaceRow raceRowByFK_Race_Employee = Teraque.UnitTest.Server.DataModel.Race.FindByRaceCode(new object[] {
// raceCode});
// if ((raceRowByFK_Race_Employee == null)) {
// throw new global::System.ServiceModel.FaultException<RecordNotFoundFault>(new global::Teraque.RecordNotFoundFault("Attempt to access a Race record ({0}) that doesn\'t exist", raceCode));
// }
// // This record locked for reading for the duration of the transaction.
// raceRowByFK_Race_Employee.AcquireReaderLock(middleTierTransaction.AdoResourceManager.Guid, Teraque.UnitTest.Server.DataModel.lockTimeout);
// middleTierTransaction.AdoResourceManager.AddLock(raceRowByFK_Race_Employee);
// // This makes sure the record wasn't deleted in the time between when it was found and the time it was locked.
// if ((raceRowByFK_Race_Employee.RowState == System.Data.DataRowState.Detached)) {
// throw new global::System.ServiceModel.FaultException<RecordNotFoundFault>(new global::Teraque.RecordNotFoundFault("Attempt to access a Race record ({0}) that doesn\'t exist", raceCode));
// }
// }
foreach (KeyValuePair <string, RelationSchema> relationPair in tableSchema.ParentRelations)
{
if (tableSchema != relationPair.Value.ParentTable)
{
// This is the table containing the parent record that is to be locked for the transaction.
TableSchema parentTable = relationPair.Value.ParentTable;
// The varible name for the parent row is decorated with the foreign key name thus making it unique.
CodeVariableReferenceExpression parentRowVariableExpression = new CodeRandomVariableReferenceExpression();
CodeTypeReference parentRowType = new CodeTypeReference(String.Format("{0}.{1}Row", tableSchema.DataModelSchema.Name, parentTable.Name));
// This chains all the non-null values of the primary key into an expression that tests if the given key values to the parent table have been
// provided in the input arguments to this method. If the provided values are null, and the columns allow nulls, then there is no need to find
// the parent record.
CodeExpression lockConditions = null;
foreach (ColumnSchema columnSchema in relationPair.Value.ChildColumns)
{
if (columnSchema.IsNullable)
{
lockConditions =
lockConditions == null ?
new CodeBinaryOperatorExpression(
new CodeArgumentReferenceExpression(CommonConversion.ToCamelCase(columnSchema.Name)),
CodeBinaryOperatorType.IdentityInequality,
new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(DBNull)), "Value")) :
new CodeBinaryOperatorExpression(
new CodeBinaryOperatorExpression(
new CodeArgumentReferenceExpression(CommonConversion.ToCamelCase(columnSchema.Name)),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)),
CodeBinaryOperatorType.BitwiseAnd,
lockConditions);
}
}
// The statements to lock the row are added conditionally when the column is nullable. They are added to the main part of the method when the
// constraint is required to match up with a parent record.
CodeStatementCollection codeStatementCollection;
if (lockConditions == null)
{
codeStatementCollection = this.Statements;
}
else
{
CodeConditionStatement ifParentKeyExists = new CodeConditionStatement(lockConditions);
this.Statements.Add(ifParentKeyExists);
codeStatementCollection = ifParentKeyExists.TrueStatements;
}
// Teraque.UnitTest.Server.DataModel.DepartmentRow departmentRowByFK_Department_Employee = Teraque.UnitTest.Server.DataModel.Department.FindByDepartmentId(new object[] {
// departmentId});
// if ((departmentRowByFK_Department_Employee == null))
// {
// throw new Teraque.RecordNotFoundException("Attempt to access a Department record ({0}) that doesn\'t exist", departmentId);
// }
CodeVariableReferenceExpression parentKeyExpression = new CodeRandomVariableReferenceExpression();
codeStatementCollection.Add(
new CodeVariableDeclarationStatement(
new CodeGlobalTypeReference(typeof(Object[])), parentKeyExpression.VariableName, new CodeKeyCreateExpression(relationPair.Value.ChildColumns)));
if (tableSchema.PrimaryKey == null)
{
codeStatementCollection.Add(
new CodeVariableDeclarationStatement(parentRowType, parentRowVariableExpression.VariableName, new CodeFindByRowExpression(parentTable, parentKeyExpression, new CodeThisReferenceExpression())));
}
else
{
codeStatementCollection.Add(
new CodeVariableDeclarationStatement(parentRowType, parentRowVariableExpression.VariableName, new CodeFindByIndexExpression(parentTable, parentKeyExpression, new CodeThisReferenceExpression())));
}
codeStatementCollection.Add(new CodeCheckRecordExistsStatement(parentTable, parentRowVariableExpression, parentKeyExpression));
// // This record locked for reading for the duration of the transaction.
// departmentRowByFK_Department_Employee.AcquireReaderLock(middleTierTransaction.AdoResourceManager.Guid, Teraque.UnitTest.Server.DataModel.lockTimeout);
// middleTierTransaction.AdoResourceManager.AddLock(departmentRowByFK_Department_Employee);
codeStatementCollection.Add(new CodeAcquireRecordReaderLockExpression(transactionExpression, parentRowVariableExpression, parentTable.DataModel));
codeStatementCollection.Add(new CodeAddLockToTransactionExpression(transactionExpression, parentRowVariableExpression));
// // This makes sure the record wasn't deleted in the time between when it was found and the time it was locked.
// if ((departmentRowByFK_Department_Employee.RowState == System.Data.DataRowState.Detached))
// {
// throw new Teraque.RecordNotFoundException("Attempt to access a Department record ({0}) that doesn\'t exist", departmentId);
// }
codeStatementCollection.Add(new CodeCheckRecordDetachedStatement(parentTable, parentRowVariableExpression, parentKeyExpression));
}
}
// ConfigurationRow q1641;
// try
// {
// l420.dataLock.EnterWriteLock();
// i425 = ((AccountRow)(l420.tableAccount.NewRow()));
// }
// finally
// {
// l420.dataLock.ExitWriteLock();
// }
CodeVariableReferenceExpression rowVariableExpression = new CodeRandomVariableReferenceExpression();
this.Statements.Add(new CodeVariableDeclarationStatement(String.Format("{0}.{1}Row", tableSchema.DataModelSchema.Name, tableSchema.Name), rowVariableExpression.VariableName));
CodeTryCatchFinallyStatement tryCreateRecord = new CodeTryCatchFinallyStatement();
tryCreateRecord.TryStatements.Add(new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "dataLock"), "EnterWriteLock"));
tryCreateRecord.TryStatements.Add(
new CodeAssignStatement(
rowVariableExpression,
new CodeCastExpression(new CodeTypeReference(String.Format("{0}.{1}Row", tableSchema.DataModelSchema.Name, tableSchema.Name)),
new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), String.Format("table{0}", tableSchema.Name)), "NewRow"))));
tryCreateRecord.FinallyStatements.Add(new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "dataLock"), "ExitWriteLock"));
this.Statements.Add(tryCreateRecord);
// // This record is locked for writing for the duration of the transaction.
// employeeRow.AcquireWriterLock(middleTierTransaction.AdoResourceManager.Guid, Teraque.UnitTest.Server.DataModel.lockTimeout);
// middleTierTransaction.AdoResourceManager.AddLock(employeeRow);
this.Statements.Add(new CodeAcquireRecordWriterLockExpression(transactionExpression, rowVariableExpression, tableSchema));
this.Statements.Add(new CodeAddLockToTransactionExpression(transactionExpression, rowVariableExpression));
// // Create the Employee record in the ADO data model.
// middleTierTransaction.AdoResourceManager.AddRecord(employeeRow);
this.Statements.Add(new CodeAddRecordToTransactionExpression(transactionExpression, rowVariableExpression));
// try {
// // Lock the owner table and any parent tables while the record is populated. Note that table locks are always held
// // momentarily.
// Teraque.UnitTest.Server.DataModel.ReaderWriterLock.EnterReadLock();
// employeeRow.BeginEdit();
// employeeRow[Teraque.UnitTest.Server.DataModel.Employee.AgeColumn] = age;
// employeeRow[Teraque.UnitTest.Server.DataModel.Employee.DepartmentIdColumn] = departmentId;
// employeeRow[Teraque.UnitTest.Server.DataModel.Employee.EmployeeIdColumn] = employeeId;
// employeeRow[Teraque.UnitTest.Server.DataModel.Employee.RaceCodeColumn] = raceCode;
// employeeRow[Teraque.UnitTest.Server.DataModel.Employee.RowVersionColumn] = System.Threading.Interlocked.Increment(ref Teraque.UnitTest.Server.DataModel.masterRowVersion);
// Teraque.UnitTest.Server.DataModel.Employee.Rows.Add(employeeRow);
// }
// finally {
// // The record create is finished and the momentary table locks are no longer needed.
// employeeRow.EndEdit();
// Teraque.UnitTest.Server.DataModel.ReaderWriterLock.ExitWriteLock();
// }
CodeTryCatchFinallyStatement tryFinallyStatement = new CodeTryCatchFinallyStatement();
tryFinallyStatement.TryStatements.Add(new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "dataLock"), "EnterWriteLock"));
tryFinallyStatement.TryStatements.Add(new CodeMethodInvokeExpression(rowVariableExpression, "BeginEdit"));
foreach (ColumnSchema columnSchema in tableSchema.Columns.Values)
{
if (!columnSchema.IsAutoIncrement)
{
CodeExpression sourceExpression;
if (columnSchema.IsRowVersion)
{
sourceExpression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "IncrementRowVersion");
}
else
{
sourceExpression = new CodeArgumentReferenceExpression(CommonConversion.ToCamelCase(columnSchema.Name));
}
tryFinallyStatement.TryStatements.Add(new CodeAssignStatement(new CodeIndexerExpression(rowVariableExpression, new CodePropertyReferenceExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), String.Format("table{0}", tableSchema.Name)), String.Format("{0}Column", columnSchema.Name))), sourceExpression));
}
}
tryFinallyStatement.TryStatements.Add(
new CodeMethodInvokeExpression(
new CodePropertyReferenceExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), String.Format("table{0}", tableSchema.Name)), "Rows"), "Add", rowVariableExpression));
tryFinallyStatement.FinallyStatements.Add(new CodeMethodInvokeExpression(rowVariableExpression, "EndEdit"));
tryFinallyStatement.FinallyStatements.Add(new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "dataLock"), "ExitWriteLock"));
this.Statements.Add(tryFinallyStatement);
// // Add the Employee record to the SQL data model.
// System.Data.SqlClient.SqlCommand sqlCommand = new global::System.Data.SqlClient.SqlCommand("insert \"Employee\" (\"Age\",\"DepartmentId\",\"EmployeeId\",\"RaceCode\",\"RowVersion\",\"Row" +
// "Version\") values (@age,@departmentId,@employeeId,@raceCode,@rowVersion,@rowVersi" +
// "on)", middleTierTransaction.SqlConnection);
// sqlCommand.Parameters.Add(new global::System.Data.SqlClient.SqlParameter("@age", System.Data.SqlDbType.Int, 0, System.Data.ParameterDirection.Input, false, 0, 0, null, System.Data.DataRowVersion.Current, age));
// sqlCommand.Parameters.Add(new global::System.Data.SqlClient.SqlParameter("@departmentId", System.Data.SqlDbType.Int, 0, System.Data.ParameterDirection.Input, false, 0, 0, null, System.Data.DataRowVersion.Current, departmentId));
// sqlCommand.Parameters.Add(new global::System.Data.SqlClient.SqlParameter("@employeeId", System.Data.SqlDbType.Int, 0, System.Data.ParameterDirection.Input, false, 0, 0, null, System.Data.DataRowVersion.Current, employeeId));
// sqlCommand.Parameters.Add(new global::System.Data.SqlClient.SqlParameter("@raceCode", System.Data.SqlDbType.Int, 0, System.Data.ParameterDirection.Input, false, 0, 0, null, System.Data.DataRowVersion.Current, raceCode));
// sqlCommand.Parameters.Add(new global::System.Data.SqlClient.SqlParameter("@rowVersion", System.Data.SqlDbType.BigInt, 0, System.Data.ParameterDirection.Input, false, 0, 0, null, System.Data.DataRowVersion.Current, employeeRow[Teraque.UnitTest.Server.DataModel.Employee.RowVersionColumn]));
// sqlCommand.ExecuteNonQuery();
if (tableSchema.IsPersistent)
{
CodeVariableReferenceExpression sqlCommandExpression = new CodeRandomVariableReferenceExpression();
string columnList = string.Empty;
string variableList = string.Empty;
int columnIndex = 0;
foreach (ColumnSchema columnSchema in tableSchema.Columns.Values)
{
if (columnSchema.IsPersistent)
{
columnList += String.Format(columnIndex < tableSchema.Columns.Count - 1 ? "\"{0}\"," : "\"{0}\"", columnSchema.Name);
variableList += String.Format(columnIndex < tableSchema.Columns.Count - 1 ? "@{0}," : "@{0}", CommonConversion.ToCamelCase(columnSchema.Name));
columnIndex++;
}
}
string insertCommandText = String.Format("insert \"{0}\" ({1}) values ({2})", tableSchema.Name, columnList, variableList);
this.Statements.Add(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(SqlCommand)), sqlCommandExpression.VariableName, new CodeObjectCreateExpression(new CodeGlobalTypeReference(typeof(SqlCommand)), new CodePrimitiveExpression(insertCommandText), new CodePropertyReferenceExpression(transactionExpression, "SqlConnection"))));
foreach (ColumnSchema columnSchema in tableSchema.Columns.Values)
{
if (columnSchema.IsPersistent)
{
string variableName = CommonConversion.ToCamelCase(columnSchema.Name);
if (columnSchema.IsAutoIncrement)
{
CodeExpression codeExpression = new CodeIndexerExpression(rowVariableExpression, new CodePropertyReferenceExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), String.Format("table{0}", tableSchema.Name)), String.Format("{0}Column", columnSchema.Name)));
this.Statements.Add(new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(sqlCommandExpression, "Parameters"), "Add", new CodeObjectCreateExpression(new CodeGlobalTypeReference(typeof(SqlParameter)), new CodePrimitiveExpression(String.Format("@{0}", variableName)), TypeConverter.Convert(columnSchema.DataType), new CodePrimitiveExpression(0), new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(ParameterDirection)), "Input"), new CodePrimitiveExpression(false), new CodePrimitiveExpression(0), new CodePrimitiveExpression(0), new CodePrimitiveExpression(null), new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(DataRowVersion)), "Current"), codeExpression)));
}
else
{
CodeExpression sourceExpression = columnSchema.IsRowVersion ?
(CodeExpression) new CodeIndexerExpression(rowVariableExpression, new CodePropertyReferenceExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), String.Format("table{0}", tableSchema.Name)), "RowVersionColumn")) :
(CodeExpression) new CodeArgumentReferenceExpression(variableName);
this.Statements.Add(new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(sqlCommandExpression, "Parameters"), "Add", new CodeObjectCreateExpression(new CodeGlobalTypeReference(typeof(SqlParameter)), new CodePrimitiveExpression(String.Format("@{0}", variableName)), TypeConverter.Convert(columnSchema.DataType), new CodePrimitiveExpression(0), new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(ParameterDirection)), "Input"), new CodePrimitiveExpression(false), new CodePrimitiveExpression(0), new CodePrimitiveExpression(0), new CodePrimitiveExpression(null), new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(DataRowVersion)), "Current"), sourceExpression)));
}
}
}
this.Statements.Add(new CodeMethodInvokeExpression(transactionExpression, "Execute", sqlCommandExpression));
}
// DataModel.DestinationOrder.OnRowValidate(new DestinationOrderRowChangeEventArgs(pe9564f2717374e96a76d5222e2258784, System.Data.DataRowAction.Add));
this.Statements.Add(
new CodeMethodInvokeExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), String.Format("table{0}", tableSchema.Name)),
"OnRowValidate",
new CodeObjectCreateExpression(
String.Format("{0}.{1}RowChangeEventArgs", tableSchema.DataModelSchema.Name, tableSchema.Name),
rowVariableExpression,
new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(DataRowAction)), "Add"))));
// Cast the Auto-Increment values back to their native types when returning from this method.
foreach (KeyValuePair <string, ColumnSchema> columnPair in tableSchema.Columns)
{
ColumnSchema columnSchema = columnPair.Value;
if (columnSchema.IsAutoIncrement)
{
this.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression(CommonConversion.ToCamelCase(columnSchema.Name)),
new CodeCastExpression(new CodeGlobalTypeReference(columnSchema.DataType), new CodeIndexerExpression(rowVariableExpression, new CodePropertyReferenceExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), String.Format("table{0}", tableSchema.Name)), String.Format("{0}Column", columnSchema.Name))))));
}
}
// }
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
CodeNamespace ns = new CodeNamespace ("Namespace1");
cu.Namespaces.Add (ns);
CodeTypeDeclaration cd = new CodeTypeDeclaration ("TEST");
cd.IsClass = true;
ns.Types.Add (cd);
if (Supports (provider, GeneratorSupport.DeclareEnums)) {
// GENERATE (C#):
// public enum DecimalEnum {
// Num0 = 0,
// Num1 = 1,
// Num2 = 2,
// Num3 = 3,
// Num4 = 4,
// }
CodeTypeDeclaration ce = new CodeTypeDeclaration ("DecimalEnum");
ce.IsEnum = true;
ns.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);
}
// GENERATE (C#):
// public enum BinaryEnum {
// Bin1 = 1,
// Bin2 = 2,
// Bin3 = 4,
// Bin4 = 8,
// Bin5 = 16,
// }
ce = new CodeTypeDeclaration ("BinaryEnum");
ce.IsEnum = true;
ns.Types.Add (ce);
// things to enumerate
int i = 0x01;
for (int k = 1; k < 6; k++) {
CodeMemberField Field = new CodeMemberField (typeof (int), "Bin" + (k).ToString ());
Field.InitExpression = new CodePrimitiveExpression (i);
i = i * 2;
ce.Members.Add (Field);
}
#if WHIDBEY
// GENERATE (C#):
// public enum MyEnum: System.UInt64 {
// small = 0,
// medium = Int64.MaxValue/10,
// large = Int64.MaxValue,
// }
ce = new CodeTypeDeclaration ("MyEnum");
ce.BaseTypes.Add (new CodeTypeReference (typeof (UInt64)));
ce.IsEnum = true;
ns.Types.Add (ce);
// Add fields
ce.Members.Add (CreateFieldMember ("Small", 0));
ce.Members.Add (CreateFieldMember ("Medium", Int64.MaxValue / 10));
ce.Members.Add (CreateFieldMember ("Large", Int64.MaxValue));
#endif
// GENERATE (C#):
// public int OutputDecimalEnumVal(int i) {
// if ((i == 3)) {
// return ((int)(DecimalEnum.Num3));
// }
// if ((i == 4)) {
// return ((int)(DecimalEnum.Num4));
// }
// if ((i == 2)) {
// return ((int)(DecimalEnum.Num2));
// }
// if ((i == 1)) {
// return ((int)(DecimalEnum.Num1));
// }
// if ((i == 0)) {
// return ((int)(DecimalEnum.Num0));
// }
// return (i + 10);
// }
// generate 5 scenarios for OutputDecimalEnumVal
for (int k = 0; k < 5; k++)
AddScenario ("CheckOutputDecimalEnumVal" + k);
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "OutputDecimalEnumVal";
cmm.Attributes = MemberAttributes.Public;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (typeof (int), "i");
cmm.Parameters.Add (param);
CodeBinaryOperatorExpression eq = new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("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 CodeArgumentReferenceExpression ("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 CodeArgumentReferenceExpression ("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 CodeArgumentReferenceExpression ("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 CodeArgumentReferenceExpression ("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 CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression (10))));
cd.Members.Add (cmm);
// GENERATE (C#):
// public int OutputBinaryEnumVal(int i) {
// if ((i == 3)) {
// return ((int)(BinaryEnum.Bin3));
// }
// if ((i == 4)) {
// return ((int)(BinaryEnum.Bin4));
// }
// if ((i == 2)) {
// return ((int)(BinaryEnum.Bin2));
// }
// if ((i == 1)) {
// return ((int)(BinaryEnum.Bin1));
// }
// if ((i == 5)) {
// return ((int)(BinaryEnum.Bin5));
// }
// return (i + 10);
// }
// generate 6 scenarios for OutputBinaryEnumVal
for (int k = 1; k < 6; k++)
AddScenario ("CheckOutputBinaryEnumVal" + k);
AddScenario ("CheckOutputBinaryEnumValRet17", "Check for a return value of 17");
cmm = new CodeMemberMethod ();
cmm.Name = "OutputBinaryEnumVal";
cmm.Attributes = MemberAttributes.Public;
param = new CodeParameterDeclarationExpression (typeof (int), "i");
cmm.Parameters.Add (param);
eq = new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression (3));
truestmt = new CodeMethodReturnStatement (
new CodeCastExpression (typeof (int),
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("BinaryEnum"), "Bin3")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (4));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("BinaryEnum"), "Bin4")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (2));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("BinaryEnum"), "Bin2")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (1));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("BinaryEnum"), "Bin1")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
eq = new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression (5));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (int), new
CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("BinaryEnum"), "Bin5")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
cmm.ReturnType = new CodeTypeReference ("System.Int32");
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression (10))));
cd.Members.Add (cmm);
#if WHIDBEY
// GENERATE (C#):
// public long VerifyMyEnumExists(int num) {
// if ((num == Int32.MaxValue)) {
// return ((int)(MyEnum.Large));
// }
// return 0;
// }
AddScenario ("CheckVerifyMyEnumExists");
cmm = new CodeMemberMethod ();
cmm.Name = "VerifyMyEnumExists";
cmm.Attributes = MemberAttributes.Public;
param = new CodeParameterDeclarationExpression (typeof (int), "num");
cmm.Parameters.Add (param);
cmm.ReturnType = new CodeTypeReference ("System.Int64");
eq = new CodeBinaryOperatorExpression (
new CodeArgumentReferenceExpression ("num"), CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression (Int32.MaxValue));
truestmt = new CodeMethodReturnStatement (new CodeCastExpression (typeof (long),
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("MyEnum"),
"Large")));
condstmt = new CodeConditionStatement (eq, truestmt);
cmm.Statements.Add (condstmt);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (0)));
cd.Members.Add (cmm);
#endif
}
}
/// <summary>
/// Generates a property getter/setter pair into the given proxy class to match the given property info.
/// </summary>
/// <param name="propertyDescriptor">PropertyDescriptor for the property to generate for.</param>
protected virtual void GenerateProperty(PropertyDescriptor propertyDescriptor)
{
string propertyName = propertyDescriptor.Name;
Type propertyType = CodeGenUtilities.TranslateType(propertyDescriptor.PropertyType);
// ----------------------------------------------------------------
// Property type ref
// ----------------------------------------------------------------
var propTypeReference = CodeGenUtilities.GetTypeReference(propertyType, ClientProxyGenerator, ProxyClass);
// ----------------------------------------------------------------
// Property decl
// ----------------------------------------------------------------
var property = new CodeMemberProperty();
property.Name = propertyName;
property.Type = propTypeReference;
property.Attributes = MemberAttributes.Public | MemberAttributes.Final; // final needed, else becomes virtual
List <Attribute> propertyAttributes = propertyDescriptor.ExplicitAttributes().Cast <Attribute>().ToList();
// Generate <summary> for property
string comment = string.Format(CultureInfo.CurrentCulture, Resource.CodeGen_Entity_Property_Summary_Comment, propertyName);
property.Comments.AddRange(CodeGenUtilities.GenerateSummaryCodeComment(comment, ClientProxyGenerator.IsCSharp));
// ----------------------------------------------------------------
// [DataMember] -> Add if not already present.
// ----------------------------------------------------------------
// Add if not already present.
if (!propertyAttributes.OfType <DataMemberAttribute>().Any())
{
CodeAttributeDeclaration dataMemberAtt = CodeGenUtilities.CreateAttributeDeclaration(typeof(DataMemberAttribute), ClientProxyGenerator, ProxyClass);
property.CustomAttributes.Add(dataMemberAtt);
}
// Here, we check for the existence of [ReadOnly(true)] attributes generated when
// the property does not not have a setter. We want to inject an [Editable(false)]
// attribute into the pipeline.
ReadOnlyAttribute readOnlyAttr = propertyAttributes.OfType <ReadOnlyAttribute>().SingleOrDefault();
if (readOnlyAttr != null && !propertyAttributes.OfType <EditableAttribute>().Any())
{
propertyAttributes.Add(new EditableAttribute(!readOnlyAttr.IsReadOnly));
// REVIEW: should we strip out [ReadOnly] attributes here?
}
// Here, we check for the presence of a complex type. If it exists we need to add a DisplayAttribute
// if not already there. DataSources windows do not handle complex types
if (TypeUtility.IsSupportedComplexType(propertyType) && !propertyAttributes.OfType <DisplayAttribute>().Any())
{
CodeAttributeDeclaration displayAttribute = CodeGenUtilities.CreateDisplayAttributeDeclaration(ClientProxyGenerator, ProxyClass);
property.CustomAttributes.Add(displayAttribute);
}
// ----------------------------------------------------------------
// Propagate the custom attributes
// ----------------------------------------------------------------
CustomAttributeGenerator.GenerateCustomAttributes(
ClientProxyGenerator,
ProxyClass,
ex => string.Format(CultureInfo.CurrentCulture, Resource.ClientCodeGen_Attribute_ThrewException_CodeTypeMember, ex.Message, property.Name, ProxyClass.Name, ex.InnerException.Message),
propertyAttributes.Cast <Attribute>(),
property.CustomAttributes,
property.Comments);
// ----------------------------------------------------------------
// backing private field (CodeDom doesn't yet know about auto properties)
// ----------------------------------------------------------------
string fieldName = CodeGenUtilities.MakeCompliantFieldName(propertyName);
var field = new CodeMemberField(propTypeReference, fieldName);
ProxyClass.Members.Add(field);
var fieldRef = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName);
var valueRef = new CodePropertySetValueReferenceExpression();
// ----------------------------------------------------------------
// getter body
// ----------------------------------------------------------------
property.GetStatements.Add(new CodeMethodReturnStatement(fieldRef));
// ----------------------------------------------------------------
// setter body
// ----------------------------------------------------------------
List <CodeStatement> bodyStatements = new List <CodeStatement>();
// this.OnPropertyXxxChanging(PropType value);
bodyStatements.Add(NotificationMethodGen.GetMethodInvokeExpressionStatementFor(propertyName + "Changing"));
bool propertyIsReadOnly = IsPropertyReadOnly(propertyDescriptor);
if (!propertyIsReadOnly)
{
bodyStatements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "RaiseDataMemberChanging", new CodePrimitiveExpression(propertyDescriptor.Name))));
}
// Generate the validation tests.
CodeStatement validationCode = GeneratePropertySetterValidation(propertyDescriptor.Name);
bodyStatements.Add(validationCode);
// this._field = value
bodyStatements.Add(new CodeAssignStatement(fieldRef, valueRef));
if (!propertyIsReadOnly)
{
bodyStatements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "RaiseDataMemberChanged", new CodePrimitiveExpression(propertyDescriptor.Name))));
}
else
{
// even read-only members need to raise PropertyChanged
bodyStatements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "RaisePropertyChanged", new CodePrimitiveExpression(propertyDescriptor.Name))));
}
// this.OnPropertyXxxChanged();
bodyStatements.Add(NotificationMethodGen.GetMethodInvokeExpressionStatementFor(propertyName + "Changed"));
// if (this._field != value)...
CodeExpression valueTest = CodeGenUtilities.MakeNotEqual(propertyType, fieldRef, valueRef, ClientProxyGenerator.IsCSharp);
CodeConditionStatement body = new CodeConditionStatement(valueTest, bodyStatements.ToArray <CodeStatement>());
property.SetStatements.Add(body);
// add property
ProxyClass.Members.Add(property);
}
void CreateTestFile(String[] values)
{
StreamWriter sw = new StreamWriter("test.cs");
CSharpCodeProvider cdp = new CSharpCodeProvider();
ICodeGenerator cg = cdp.CreateGenerator();
CodeNamespace cnspace = new CodeNamespace("N");
cnspace.Imports.Add(new CodeNamespaceImport("System"));
CodeTypeDeclaration co = new CodeTypeDeclaration ("C");
co.IsClass = true;
cnspace.Types.Add (co);
co.TypeAttributes = TypeAttributes.Public;
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = "Main";
cmm.ReturnType = null;
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeVariableDeclarationStatement cvar = new CodeVariableDeclarationStatement(typeof(String[]), "args", new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("Environment"), "GetCommandLineArgs"));
cmm.Statements.Add(cvar);
cvar = new CodeVariableDeclarationStatement(typeof(Int32), "exitCode", new CodeSnippetExpression("0"));
cmm.Statements.Add(cvar);
String strArgLength = (values.Length + 1).ToString();
CodeConditionStatement ccs1 = new CodeConditionStatement(new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("args.Length"), CodeBinaryOperatorType.IdentityInequality, new CodeSnippetExpression(strArgLength)), new CodeStatement []{new CodeAssignStatement(new CodeVariableReferenceExpression("exitCode"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("exitCode"), CodeBinaryOperatorType.Add, new CodeSnippetExpression("1")))});
cmm.Statements.Add(ccs1);
ccs1 = new CodeConditionStatement(new CodeSnippetExpression("!args[0].ToLower().EndsWith(\"test.exe\")"), new CodeStatement []{new CodeAssignStatement(new CodeVariableReferenceExpression("exitCode"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("exitCode"), CodeBinaryOperatorType.Add, new CodeSnippetExpression("1")))});
cmm.Statements.Add(ccs1);
for(int i=0; i<values.Length; i++){
ccs1 = new CodeConditionStatement(new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("args[" + (i+1).ToString() + "]"), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(values[i])), new CodeStatement []{new CodeAssignStatement(new CodeVariableReferenceExpression("exitCode"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("exitCode"), CodeBinaryOperatorType.Add, new CodeSnippetExpression("1")))});
cmm.Statements.Add(ccs1);
}
cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("Environment.ExitCode"), new CodeVariableReferenceExpression("exitCode")));
co.Members.Add(cmm);
cg.GenerateCodeFromNamespace(cnspace, sw, null);
sw.Flush();
sw.Close();
}
/// <summary>
/// 条件语句
/// </summary>
public void AddConditionStatement(CodeConditionStatement inStatement)
{
methodList[0].Method.Statements.Add(inStatement);
}
protected abstract void GenerateConditionStatement(CodeConditionStatement e);
protected override void GenerateConditionStatement(CodeConditionStatement e)
{
Output.WriteLine("[GenerateConditionStatement: {0}]", e.ToString());
}
public void ProviderSupports()
{
CodeDomProvider provider = GetProvider();
CodeCompileUnit cu = new CodeCompileUnit();
CodeNamespace nspace = new CodeNamespace("NSPC");
nspace.Imports.Add(new CodeNamespaceImport("System"));
nspace.Imports.Add(new CodeNamespaceImport("System.Drawing"));
nspace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
nspace.Imports.Add(new CodeNamespaceImport("System.ComponentModel"));
cu.Namespaces.Add(nspace);
CodeTypeDeclaration cd = new CodeTypeDeclaration("TEST");
cd.IsClass = true;
nspace.Types.Add(cd);
// Arrays of Arrays
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = "ArraysOfArrays";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public;
if (provider.Supports(GeneratorSupport.ArraysOfArrays))
{
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(int[][])),
"arrayOfArrays", new CodeArrayCreateExpression(typeof(int[][]),
new CodeArrayCreateExpression(typeof(int[]), new CodePrimitiveExpression(3), new CodePrimitiveExpression(4)),
new CodeArrayCreateExpression(typeof(int[]), new CodeExpression[] { new CodePrimitiveExpression(1) }))));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeArrayIndexerExpression(
new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("arrayOfArrays"), new CodePrimitiveExpression(0))
, new CodePrimitiveExpression(1))));
}
else
{
throw new Exception("not supported");
}
cd.Members.Add(cmm);
// assembly attributes
if (provider.Supports(GeneratorSupport.AssemblyAttributes))
{
CodeAttributeDeclarationCollection attrs = cu.AssemblyCustomAttributes;
attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyTitle", new
CodeAttributeArgument(new CodePrimitiveExpression("MyAssembly"))));
attrs.Add(new CodeAttributeDeclaration("System.Reflection.AssemblyVersion", new
CodeAttributeArgument(new CodePrimitiveExpression("1.0.6.2"))));
}
CodeTypeDeclaration class1 = new CodeTypeDeclaration();
if (provider.Supports(GeneratorSupport.ChainedConstructorArguments))
{
class1.Name = "Test2";
class1.IsClass = true;
nspace.Types.Add(class1);
class1.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(String)), "stringField"));
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = "accessStringField";
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
prop.Type = new CodeTypeReference(typeof(String));
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
"stringField")));
prop.SetStatements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new
CodeThisReferenceExpression(), "stringField"),
new CodePropertySetValueReferenceExpression()));
class1.Members.Add(prop);
CodeConstructor cctor = new CodeConstructor();
cctor.Attributes = MemberAttributes.Public;
cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression("testingString"));
cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression(null));
cctor.ChainedConstructorArgs.Add(new CodePrimitiveExpression(null));
class1.Members.Add(cctor);
CodeConstructor cc = new CodeConstructor();
cc.Attributes = MemberAttributes.Public | MemberAttributes.Overloaded;
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p1"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p2"));
cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "p3"));
cc.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression()
, "stringField"), new CodeVariableReferenceExpression("p1")));
class1.Members.Add(cc);
// verify chained constructors work
cmm = new CodeMemberMethod();
cmm.Name = "ChainedConstructorUse";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference(typeof(String));
// utilize constructor
cmm.Statements.Add(new CodeVariableDeclarationStatement("Test2", "t", new CodeObjectCreateExpression("Test2")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression("t"), "accessStringField")));
cd.Members.Add(cmm);
}
// complex expressions
if (provider.Supports(GeneratorSupport.ComplexExpressions))
{
cmm = new CodeMemberMethod();
cmm.Name = "ComplexExpressions";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public;
cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i"));
cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("i"),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Multiply,
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(3)))));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("i")));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareEnums))
{
CodeTypeDeclaration ce = new CodeTypeDeclaration("DecimalEnum");
ce.IsEnum = true;
nspace.Types.Add(ce);
// things to enumerate
for (int k = 0; k < 5; k++)
{
CodeMemberField Field = new CodeMemberField("System.Int32", "Num" + (k).ToString());
Field.InitExpression = new CodePrimitiveExpression(k);
ce.Members.Add(Field);
}
cmm = new CodeMemberMethod();
cmm.Name = "OutputDecimalEnumVal";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i");
cmm.Parameters.Add(param);
CodeBinaryOperatorExpression eq = new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(3));
CodeMethodReturnStatement truestmt = new CodeMethodReturnStatement(
new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num3")));
CodeConditionStatement condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(4));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num4")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(2));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num2")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(1));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num1")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
eq = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("i"),
CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(0));
truestmt = new CodeMethodReturnStatement(new CodeCastExpression(typeof(int),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("DecimalEnum"), "Num0")));
condstmt = new CodeConditionStatement(eq, truestmt);
cmm.Statements.Add(condstmt);
cmm.ReturnType = new CodeTypeReference("System.int32");
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(10))));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareInterfaces))
{
cmm = new CodeMemberMethod();
cmm.Name = "TestSingleInterface";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement("TestSingleInterfaceImp", "t", new CodeObjectCreateExpression("TestSingleInterfaceImp")));
CodeMethodInvokeExpression methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t")
, "InterfaceMethod");
methodinvoke.Parameters.Add(new CodeVariableReferenceExpression("i"));
cmm.Statements.Add(new CodeMethodReturnStatement(methodinvoke));
cd.Members.Add(cmm);
class1 = new CodeTypeDeclaration("InterfaceA");
class1.IsInterface = true;
nspace.Types.Add(class1);
cmm = new CodeMemberMethod();
cmm.Attributes = MemberAttributes.Public;
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
class1.Members.Add(cmm);
if (provider.Supports(GeneratorSupport.MultipleInterfaceMembers))
{
CodeTypeDeclaration classDecl = new CodeTypeDeclaration("InterfaceB");
classDecl.IsInterface = true;
nspace.Types.Add(classDecl);
cmm = new CodeMemberMethod();
cmm.Name = "InterfaceMethod";
cmm.Attributes = MemberAttributes.Public;
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
classDecl.Members.Add(cmm);
CodeTypeDeclaration class2 = new CodeTypeDeclaration("TestMultipleInterfaceImp");
class2.BaseTypes.Add(new CodeTypeReference("System.Object"));
class2.BaseTypes.Add(new CodeTypeReference("InterfaceB"));
class2.BaseTypes.Add(new CodeTypeReference("InterfaceA"));
class2.IsClass = true;
nspace.Types.Add(class2);
cmm = new CodeMemberMethod();
cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceA"));
cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceB"));
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
class2.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "TestMultipleInterfaces";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement("TestMultipleInterfaceImp", "t", new CodeObjectCreateExpression("TestMultipleInterfaceImp")));
cmm.Statements.Add(new CodeVariableDeclarationStatement("InterfaceA", "interfaceAobject", new CodeCastExpression("InterfaceA",
new CodeVariableReferenceExpression("t"))));
cmm.Statements.Add(new CodeVariableDeclarationStatement("InterfaceB", "interfaceBobject", new CodeCastExpression("InterfaceB",
new CodeVariableReferenceExpression("t"))));
methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("interfaceAobject")
, "InterfaceMethod");
methodinvoke.Parameters.Add(new CodeVariableReferenceExpression("i"));
CodeMethodInvokeExpression methodinvoke2 = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("interfaceBobject")
, "InterfaceMethod");
methodinvoke2.Parameters.Add(new CodeVariableReferenceExpression("i"));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
methodinvoke,
CodeBinaryOperatorType.Subtract, methodinvoke2)));
cd.Members.Add(cmm);
}
class1 = new CodeTypeDeclaration("TestSingleInterfaceImp");
class1.BaseTypes.Add(new CodeTypeReference("System.Object"));
class1.BaseTypes.Add(new CodeTypeReference("InterfaceA"));
class1.IsClass = true;
nspace.Types.Add(class1);
cmm = new CodeMemberMethod();
cmm.ImplementationTypes.Add(new CodeTypeReference("InterfaceA"));
cmm.Name = "InterfaceMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
class1.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareValueTypes))
{
CodeTypeDeclaration structA = new CodeTypeDeclaration("structA");
structA.IsStruct = true;
CodeTypeDeclaration structB = new CodeTypeDeclaration("structB");
structB.Attributes = MemberAttributes.Public;
structB.IsStruct = true;
CodeMemberField firstInt = new CodeMemberField(typeof(int), "int1");
firstInt.Attributes = MemberAttributes.Public;
structB.Members.Add(firstInt);
CodeMemberField innerStruct = new CodeMemberField("structB", "innerStruct");
innerStruct.Attributes = MemberAttributes.Public;
structA.Members.Add(structB);
structA.Members.Add(innerStruct);
nspace.Types.Add(structA);
CodeMemberMethod nestedStructMethod = new CodeMemberMethod();
nestedStructMethod.Name = "NestedStructMethod";
nestedStructMethod.ReturnType = new CodeTypeReference(typeof(int));
nestedStructMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeVariableDeclarationStatement varStructA = new CodeVariableDeclarationStatement("structA", "varStructA");
nestedStructMethod.Statements.Add(varStructA);
nestedStructMethod.Statements.Add
(
new CodeAssignStatement
(
/* Expression1 */ new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("varStructA"), "innerStruct"), "int1"),
/* Expression1 */ new CodePrimitiveExpression(3)
)
);
nestedStructMethod.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("varStructA"), "innerStruct"), "int1")));
cd.Members.Add(nestedStructMethod);
}
if (provider.Supports(GeneratorSupport.EntryPointMethod))
{
CodeEntryPointMethod cep = new CodeEntryPointMethod();
cd.Members.Add(cep);
}
// goto statements
if (provider.Supports(GeneratorSupport.GotoStatements))
{
cmm = new CodeMemberMethod();
cmm.Name = "GoToMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i");
cmm.Parameters.Add(param);
CodeConditionStatement condstmt = new CodeConditionStatement(new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("i"), CodeBinaryOperatorType.LessThan, new CodePrimitiveExpression(1)),
new CodeGotoStatement("comehere"));
cmm.Statements.Add(condstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(6)));
cmm.Statements.Add(new CodeLabeledStatement("comehere",
new CodeMethodReturnStatement(new CodePrimitiveExpression(7))));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.NestedTypes))
{
cmm = new CodeMemberMethod();
cmm.Name = "CallingPublicNestedScenario";
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference
("PublicNestedClassA+PublicNestedClassB2+PublicNestedClassC"), "t",
new CodeObjectCreateExpression(new CodeTypeReference
("PublicNestedClassA+PublicNestedClassB2+PublicNestedClassC"))));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t"),
"publicNestedClassesMethod",
new CodeVariableReferenceExpression("i"))));
cd.Members.Add(cmm);
class1 = new CodeTypeDeclaration("PublicNestedClassA");
class1.IsClass = true;
nspace.Types.Add(class1);
CodeTypeDeclaration nestedClass = new CodeTypeDeclaration("PublicNestedClassB1");
nestedClass.IsClass = true;
nestedClass.TypeAttributes = TypeAttributes.NestedPublic;
class1.Members.Add(nestedClass);
nestedClass = new CodeTypeDeclaration("PublicNestedClassB2");
nestedClass.TypeAttributes = TypeAttributes.NestedPublic;
nestedClass.IsClass = true;
class1.Members.Add(nestedClass);
CodeTypeDeclaration innerNestedClass = new CodeTypeDeclaration("PublicNestedClassC");
innerNestedClass.TypeAttributes = TypeAttributes.NestedPublic;
innerNestedClass.IsClass = true;
nestedClass.Members.Add(innerNestedClass);
cmm = new CodeMemberMethod();
cmm.Name = "publicNestedClassesMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
innerNestedClass.Members.Add(cmm);
}
// Parameter Attributes
if (provider.Supports(GeneratorSupport.ParameterAttributes))
{
CodeMemberMethod method1 = new CodeMemberMethod();
method1.Name = "MyMethod";
method1.Attributes = MemberAttributes.Public | MemberAttributes.Final;
CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(string), "blah");
param1.CustomAttributes.Add(
new CodeAttributeDeclaration(
"System.Xml.Serialization.XmlElementAttribute",
new CodeAttributeArgument(
"Form",
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.Xml.Schema.XmlSchemaForm"), "Unqualified")),
new CodeAttributeArgument(
"IsNullable",
new CodePrimitiveExpression(false))));
method1.Parameters.Add(param1);
cd.Members.Add(method1);
}
// public static members
if (provider.Supports(GeneratorSupport.PublicStaticMembers))
{
cmm = new CodeMemberMethod();
cmm.Name = "PublicStaticMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(16)));
cd.Members.Add(cmm);
}
// reference parameters
if (provider.Supports(GeneratorSupport.ReferenceParameters))
{
cmm = new CodeMemberMethod();
cmm.Name = "Work";
cmm.ReturnType = new CodeTypeReference("System.void");
cmm.Attributes = MemberAttributes.Static;
// add parameter with ref direction
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "i");
param.Direction = FieldDirection.Ref;
cmm.Parameters.Add(param);
// add parameter with out direction
param = new CodeParameterDeclarationExpression(typeof(int), "j");
param.Direction = FieldDirection.Out;
cmm.Parameters.Add(param);
cmm.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("i"),
new CodeBinaryOperatorExpression(new CodeArgumentReferenceExpression("i"),
CodeBinaryOperatorType.Add, new CodePrimitiveExpression(4))));
cmm.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("j"),
new CodePrimitiveExpression(5)));
cd.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "CallingWork";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression parames = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(parames);
cmm.ReturnType = new CodeTypeReference("System.int32");
cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"),
new CodePrimitiveExpression(10)));
cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "b"));
// invoke the method called "work"
CodeMethodInvokeExpression methodinvoked = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression
(new CodeTypeReferenceExpression("TEST"), "Work"));
// add parameter with ref direction
CodeDirectionExpression parameter = new CodeDirectionExpression(FieldDirection.Ref,
new CodeVariableReferenceExpression("a"));
methodinvoked.Parameters.Add(parameter);
// add parameter with out direction
parameter = new CodeDirectionExpression(FieldDirection.Out, new CodeVariableReferenceExpression("b"));
methodinvoked.Parameters.Add(parameter);
cmm.Statements.Add(methodinvoked);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression
(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression("b"))));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.ReturnTypeAttributes))
{
CodeMemberMethod function1 = new CodeMemberMethod();
function1.Name = "MyFunction";
function1.ReturnType = new CodeTypeReference(typeof(string));
function1.Attributes = MemberAttributes.Public | MemberAttributes.Final;
function1.ReturnTypeCustomAttributes.Add(new
CodeAttributeDeclaration("System.Xml.Serialization.XmlIgnoreAttribute"));
function1.ReturnTypeCustomAttributes.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlRootAttribute", new
CodeAttributeArgument("Namespace", new CodePrimitiveExpression("Namespace Value")), new
CodeAttributeArgument("ElementName", new CodePrimitiveExpression("Root, hehehe"))));
function1.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression("Return")));
cd.Members.Add(function1);
}
if (provider.Supports(GeneratorSupport.StaticConstructors))
{
cmm = new CodeMemberMethod();
cmm.Name = "TestStaticConstructor";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.ReturnType = new CodeTypeReference(typeof(int));
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
// utilize constructor
cmm.Statements.Add(new CodeVariableDeclarationStatement("Test4", "t", new CodeObjectCreateExpression("Test4")));
// set then get number
cmm.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("t"), "i")
, new CodeVariableReferenceExpression("a")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression("t"), "i")));
cd.Members.Add(cmm);
class1 = new CodeTypeDeclaration();
class1.Name = "Test4";
class1.IsClass = true;
nspace.Types.Add(class1);
class1.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(int)), "number"));
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = "i";
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
prop.Type = new CodeTypeReference(typeof(int));
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("number")));
prop.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("number"),
new CodePropertySetValueReferenceExpression()));
class1.Members.Add(prop);
CodeTypeConstructor ctc = new CodeTypeConstructor();
class1.Members.Add(ctc);
}
if (provider.Supports(GeneratorSupport.TryCatchStatements))
{
cmm = new CodeMemberMethod();
cmm.Name = "TryCatchMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(int), "a");
cmm.Parameters.Add(param);
CodeTryCatchFinallyStatement tcfstmt = new CodeTryCatchFinallyStatement();
tcfstmt.FinallyStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("a"), new
CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("a"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(5))));
cmm.Statements.Add(tcfstmt);
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("a")));
cd.Members.Add(cmm);
}
if (provider.Supports(GeneratorSupport.DeclareEvents))
{
CodeNamespace ns = new CodeNamespace();
ns.Name = "MyNamespace";
ns.Imports.Add(new CodeNamespaceImport("System"));
ns.Imports.Add(new CodeNamespaceImport("System.Drawing"));
ns.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
ns.Imports.Add(new CodeNamespaceImport("System.ComponentModel"));
cu.Namespaces.Add(ns);
class1 = new CodeTypeDeclaration("Test");
class1.IsClass = true;
class1.BaseTypes.Add(new CodeTypeReference("Form"));
ns.Types.Add(class1);
CodeMemberField mfield = new CodeMemberField(new CodeTypeReference("Button"), "b");
mfield.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference("Button"));
class1.Members.Add(mfield);
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Public;
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
"Size"), new CodeObjectCreateExpression(new CodeTypeReference("Size"),
new CodePrimitiveExpression(600), new CodePrimitiveExpression(600))));
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"),
"Text"), new CodePrimitiveExpression("Test")));
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"),
"TabIndex"), new CodePrimitiveExpression(0)));
ctor.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("b"),
"Location"), new CodeObjectCreateExpression(new CodeTypeReference("Point"),
new CodePrimitiveExpression(400), new CodePrimitiveExpression(525))));
ctor.Statements.Add(new CodeAttachEventStatement(new CodeEventReferenceExpression(new
CodeThisReferenceExpression(), "MyEvent"), new CodeDelegateCreateExpression(new CodeTypeReference("EventHandler")
, new CodeThisReferenceExpression(), "b_Click")));
class1.Members.Add(ctor);
CodeMemberEvent evt = new CodeMemberEvent();
evt.Name = "MyEvent";
evt.Type = new CodeTypeReference("System.EventHandler");
evt.Attributes = MemberAttributes.Public;
class1.Members.Add(evt);
cmm = new CodeMemberMethod();
cmm.Name = "b_Click";
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender"));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(EventArgs), "e"));
class1.Members.Add(cmm);
}
AssertEqual(cu,
@"'------------------------------------------------------------------------------
' <auto-generated>
' This code was generated by a tool.
' Runtime Version:4.0.30319.42000
'
' Changes to this file may cause incorrect behavior and will be lost if
' the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------
Option Strict Off
Option Explicit On
Imports System
Imports System.ComponentModel
Imports System.Drawing
Imports System.Windows.Forms
<Assembly: System.Reflection.AssemblyTitle(""MyAssembly""), _
Assembly: System.Reflection.AssemblyVersion(""1.0.6.2"")>
Namespace NSPC
Public Class TEST
Public Function ArraysOfArrays() As Integer
Dim arrayOfArrays()() As Integer = New Integer()() {New Integer() {3, 4}, New Integer() {1}}
Return arrayOfArrays(0)(1)
End Function
Public Shared Function ChainedConstructorUse() As String
Dim t As Test2 = New Test2()
Return t.accessStringField
End Function
Public Function ComplexExpressions(ByVal i As Integer) As Integer
i = (i _
* (i + 3))
Return i
End Function
Public Shared Function OutputDecimalEnumVal(ByVal i As Integer) As Integer
If (i = 3) Then
Return CType(DecimalEnum.Num3,Integer)
End If
If (i = 4) Then
Return CType(DecimalEnum.Num4,Integer)
End If
If (i = 2) Then
Return CType(DecimalEnum.Num2,Integer)
End If
If (i = 1) Then
Return CType(DecimalEnum.Num1,Integer)
End If
If (i = 0) Then
Return CType(DecimalEnum.Num0,Integer)
End If
Return (i + 10)
End Function
Public Shared Function TestSingleInterface(ByVal i As Integer) As Integer
Dim t As TestSingleInterfaceImp = New TestSingleInterfaceImp()
Return t.InterfaceMethod(i)
End Function
Public Shared Function TestMultipleInterfaces(ByVal i As Integer) As Integer
Dim t As TestMultipleInterfaceImp = New TestMultipleInterfaceImp()
Dim interfaceAobject As InterfaceA = CType(t,InterfaceA)
Dim interfaceBobject As InterfaceB = CType(t,InterfaceB)
Return (interfaceAobject.InterfaceMethod(i) - interfaceBobject.InterfaceMethod(i))
End Function
Public Shared Function NestedStructMethod() As Integer
Dim varStructA As structA
varStructA.innerStruct.int1 = 3
Return varStructA.innerStruct.int1
End Function
Public Shared Sub Main()
End Sub
Public Function GoToMethod(ByVal i As Integer) As Integer
If (i < 1) Then
goto comehere
End If
Return 6
comehere:
Return 7
End Function
Public Shared Function CallingPublicNestedScenario(ByVal i As Integer) As Integer
Dim t As PublicNestedClassA.PublicNestedClassB2.PublicNestedClassC = New PublicNestedClassA.PublicNestedClassB2.PublicNestedClassC()
Return t.publicNestedClassesMethod(i)
End Function
Public Sub MyMethod(<System.Xml.Serialization.XmlElementAttribute(Form:=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable:=false)> ByVal blah As String)
End Sub
Public Shared Function PublicStaticMethod() As Integer
Return 16
End Function
Shared Sub Work(ByRef i As Integer, ByRef j As Integer)
i = (i + 4)
j = 5
End Sub
Public Shared Function CallingWork(ByVal a As Integer) As Integer
a = 10
Dim b As Integer
TEST.Work(a, b)
Return (a + b)
End Function
Public Function MyFunction() As <System.Xml.Serialization.XmlIgnoreAttribute(), System.Xml.Serialization.XmlRootAttribute([Namespace]:=""Namespace Value"", ElementName:=""Root, hehehe"")> String
Return ""Return""
End Function
Public Shared Function TestStaticConstructor(ByVal a As Integer) As Integer
Dim t As Test4 = New Test4()
t.i = a
Return t.i
End Function
Public Shared Function TryCatchMethod(ByVal a As Integer) As Integer
Try
Finally
a = (a + 5)
End Try
Return a
End Function
End Class
Public Class Test2
Private stringField As String
Public Sub New()
Me.New(""testingString"", Nothing, Nothing)
End Sub
Public Sub New(ByVal p1 As String, ByVal p2 As String, ByVal p3 As String)
MyBase.New
Me.stringField = p1
End Sub
Public Property accessStringField() As String
Get
Return Me.stringField
End Get
Set
Me.stringField = value
End Set
End Property
End Class
Public Enum DecimalEnum
Num0 = 0
Num1 = 1
Num2 = 2
Num3 = 3
Num4 = 4
End Enum
Public Interface InterfaceA
Function InterfaceMethod(ByVal a As Integer) As Integer
End Interface
Public Interface InterfaceB
Function InterfaceMethod(ByVal a As Integer) As Integer
End Interface
Public Class TestMultipleInterfaceImp
Inherits Object
Implements InterfaceB, InterfaceA
Public Function InterfaceMethod(ByVal a As Integer) As Integer Implements InterfaceA.InterfaceMethod , InterfaceB.InterfaceMethod
Return a
End Function
End Class
Public Class TestSingleInterfaceImp
Inherits Object
Implements InterfaceA
Public Overridable Function InterfaceMethod(ByVal a As Integer) As Integer Implements InterfaceA.InterfaceMethod
Return a
End Function
End Class
Public Structure structA
Public innerStruct As structB
Public Structure structB
Public int1 As Integer
End Structure
End Structure
Public Class PublicNestedClassA
Public Class PublicNestedClassB1
End Class
Public Class PublicNestedClassB2
Public Class PublicNestedClassC
Public Function publicNestedClassesMethod(ByVal a As Integer) As Integer
Return a
End Function
End Class
End Class
End Class
Public Class Test4
Private number As Integer
Shared Sub New()
End Sub
Public Property i() As Integer
Get
Return number
End Get
Set
number = value
End Set
End Property
End Class
End Namespace
Namespace MyNamespace
Public Class Test
Inherits Form
Private b As Button = New Button()
Public Sub New()
MyBase.New
Me.Size = New Size(600, 600)
b.Text = ""Test""
b.TabIndex = 0
b.Location = New Point(400, 525)
AddHandler MyEvent, AddressOf Me.b_Click
End Sub
Public Event MyEvent As System.EventHandler
Private Sub b_Click(ByVal sender As Object, ByVal e As System.EventArgs)
End Sub
End Class
End Namespace");
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu)
{
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);
cu.ReferencedAssemblies.Add ("System.Drawing.dll");
cu.ReferencedAssemblies.Add ("System.Windows.Forms.dll");
cu.ReferencedAssemblies.Add ("System.Xml.dll");
CodeTypeDeclaration cd = new CodeTypeDeclaration ("TEST");
cd.IsClass = true;
nspace.Types.Add (cd);
CodeMemberMethod cmm;
// Arrays of Arrays
#if !WHIDBEY
// Everett VB code provider doesn't support array of array initialization
if (!(provider is Microsoft.VisualBasic.VBCodeProvider)) {
#endif
if (Supports (provider, GeneratorSupport.ArraysOfArrays)) {
AddScenario ("CheckArrayOfArrays");
cmm = new CodeMemberMethod ();
cmm.Name = "ArraysOfArrays";
cmm.ReturnType = new CodeTypeReference (typeof (int));
cmm.Attributes = MemberAttributes.Final | MemberAttributes.Public;
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))));
cd.Members.Add (cmm);
}
#if !WHIDBEY
}
#endif
// assembly attributes
if (Supports (provider, GeneratorSupport.AssemblyAttributes)) {
AddScenario ("CheckAssemblyAttributes");
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 (Supports (provider, GeneratorSupport.ChainedConstructorArguments)) {
AddScenario ("CheckChainedConstructorArgs");
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 CodeArgumentReferenceExpression ("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 CodePropertyReferenceExpression (
new CodeVariableReferenceExpression ("t"), "accessStringField")));
cd.Members.Add (cmm);
}
// complex expressions
if (Supports (provider, GeneratorSupport.ComplexExpressions)) {
AddScenario ("CheckComplexExpressions");
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 CodeArgumentReferenceExpression ("i"),
new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.Multiply,
new CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression (3)))));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("i")));
cd.Members.Add (cmm);
}
if (Supports (provider, GeneratorSupport.DeclareEnums)) {
AddScenario ("CheckDeclareEnums");
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 CodeArgumentReferenceExpression ("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 CodeArgumentReferenceExpression ("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 CodeArgumentReferenceExpression ("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 CodeArgumentReferenceExpression ("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 CodeArgumentReferenceExpression ("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 CodeArgumentReferenceExpression ("i"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression (10))));
cd.Members.Add (cmm);
}
if (Supports (provider, GeneratorSupport.DeclareInterfaces)) {
AddScenario ("CheckDeclareInterfaces");
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 CodeArgumentReferenceExpression ("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 (Supports (provider, GeneratorSupport.MultipleInterfaceMembers)) {
AddScenario ("CheckMultipleInterfaceMembers");
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 CodeArgumentReferenceExpression ("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 CodeArgumentReferenceExpression ("i"));
CodeMethodInvokeExpression methodinvoke2 = new CodeMethodInvokeExpression (new CodeVariableReferenceExpression ("interfaceBobject")
, "InterfaceMethod");
methodinvoke2.Parameters.Add (new CodeArgumentReferenceExpression ("i"));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression (
methodinvoke,
CodeBinaryOperatorType.Subtract, methodinvoke2)));
cd.Members.Add (cmm);
}
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 CodeArgumentReferenceExpression ("a")));
class1.Members.Add (cmm);
}
/*if (Supports (provider, GeneratorSupport.DeclareValueTypes)) {
AddScenario ("CheckDeclareValueTypes");
// create first struct to test nested structs
// GENERATE (C#):
// public struct structA {
// public structB innerStruct;
// public struct structB {
// public int int1;
// }
// }
CodeTypeDeclaration structA = new CodeTypeDeclaration ("structA");
structA.IsStruct = true;
CodeTypeDeclaration structB = new CodeTypeDeclaration ("structB");
structB.TypeAttributes = TypeAttributes.NestedPublic;
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
(
new CodeFieldReferenceExpression (new CodeFieldReferenceExpression (new CodeVariableReferenceExpression ("varStructA"), "innerStruct"), "int1"),
new CodePrimitiveExpression (3)
)
);
nestedStructMethod.Statements.Add (new CodeMethodReturnStatement (new CodeFieldReferenceExpression (new CodeFieldReferenceExpression (new CodeVariableReferenceExpression ("varStructA"), "innerStruct"), "int1")));
cd.Members.Add (nestedStructMethod);
}*/
if (Supports (provider, GeneratorSupport.EntryPointMethod)) {
AddScenario ("CheckEntryPointMethod");
CodeEntryPointMethod cep = new CodeEntryPointMethod ();
cd.Members.Add (cep);
}
// goto statements
if (Supports (provider, GeneratorSupport.GotoStatements)) {
AddScenario ("CheckGotoStatements");
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 CodeArgumentReferenceExpression ("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 (Supports (provider, GeneratorSupport.NestedTypes)) {
AddScenario ("CheckNestedTypes");
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 CodeArgumentReferenceExpression ("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 CodeArgumentReferenceExpression ("a")));
innerNestedClass.Members.Add (cmm);
}
// Parameter Attributes
if (Supports (provider, GeneratorSupport.ParameterAttributes)) {
AddScenario ("CheckParameterAttributes");
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 (Supports (provider, GeneratorSupport.PublicStaticMembers)) {
AddScenario ("CheckPublicStaticMembers");
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 (Supports (provider, GeneratorSupport.ReferenceParameters)) {
AddScenario ("CheckReferenceParameters");
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 CodeArgumentReferenceExpression ("a"),
new CodePrimitiveExpression (10)));
cmm.Statements.Add (new CodeVariableDeclarationStatement (typeof (int), "b"));
// invoke the method called "work"
CodeMethodInvokeExpression methodinvoked = new CodeMethodInvokeExpression (new CodeMethodReferenceExpression
(new CodeTypeReferenceExpression ("TEST"), "Work"));
// add parameter with ref direction
CodeDirectionExpression parameter = new CodeDirectionExpression (FieldDirection.Ref,
new CodeArgumentReferenceExpression ("a"));
methodinvoked.Parameters.Add (parameter);
// add parameter with out direction
parameter = new CodeDirectionExpression (FieldDirection.Out, new CodeVariableReferenceExpression ("b"));
methodinvoked.Parameters.Add (parameter);
cmm.Statements.Add (methodinvoked);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeBinaryOperatorExpression
(new CodeArgumentReferenceExpression ("a"), CodeBinaryOperatorType.Add, new CodeVariableReferenceExpression ("b"))));
cd.Members.Add (cmm);
}
if (Supports (provider, GeneratorSupport.ReturnTypeAttributes)) {
AddScenario ("CheckReturnTypeAttributes");
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 (Supports (provider, GeneratorSupport.StaticConstructors)) {
AddScenario ("CheckStaticConstructors");
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 CodeArgumentReferenceExpression ("a")));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodePropertyReferenceExpression (
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 CodeFieldReferenceExpression (null, "number")));
prop.SetStatements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression (null, "number"),
new CodePropertySetValueReferenceExpression ()));
class1.Members.Add (prop);
CodeTypeConstructor ctc = new CodeTypeConstructor ();
class1.Members.Add (ctc);
}
if (Supports (provider, GeneratorSupport.TryCatchStatements)) {
AddScenario ("CheckTryCatchStatements");
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 CodeArgumentReferenceExpression ("a"), new
CodeBinaryOperatorExpression (new CodeArgumentReferenceExpression ("a"), CodeBinaryOperatorType.Add,
new CodePrimitiveExpression (5))));
cmm.Statements.Add (tcfstmt);
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeArgumentReferenceExpression ("a")));
cd.Members.Add (cmm);
}
if (Supports (provider, GeneratorSupport.DeclareEvents)) {
AddScenario ("CheckDeclareEvents");
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 CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
"Text"), new CodePrimitiveExpression ("Test")));
ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
"TabIndex"), new CodePrimitiveExpression (0)));
ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
"Location"), new CodeObjectCreateExpression (new CodeTypeReference ("Point"),
new CodePrimitiveExpression (400), new CodePrimitiveExpression (525))));
ctor.Statements.Add (new CodeAttachEventStatement (new CodeEventReferenceExpression (new
CodeThisReferenceExpression (), "MyEvent"), new CodeDelegateCreateExpression (new CodeTypeReference ("EventHandler")
, new CodeThisReferenceExpression (), "b_Click")));
class1.Members.Add (ctor);
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);
}
if (Supports (provider, GeneratorSupport.MultidimensionalArrays)) {
// no codedom language represents declaration of multidimensional arrays
}
}
