| public Add ( System.CodeDom.CodeExpression value ) : int | ||
| value | System.CodeDom.CodeExpression | |
| return | int | |
public static CodeStatementCollection BuildDetectChangedMembers(TableViewTableTypeBase table)
{
CodeStatementCollection ValidationSetStatement = new CodeStatementCollection();
String PocoTypeName = "this";
ValidationSetStatement.Add(new CodeSnippetExpression("Boolean bResult = new Boolean()"));
ValidationSetStatement.Add(new CodeSnippetExpression("bResult = false"));
foreach (Column c in table.Columns)
{
MemberGraph mGraph = new MemberGraph(c);
CodeConditionStatement csTest1 = new CodeConditionStatement();
if (mGraph.IsNullable)
{
csTest1.Condition = new CodeSnippetExpression(PocoTypeName + "." + mGraph.PropertyName() + ".HasValue == true");
csTest1.TrueStatements.Add(new CodeSnippetExpression("bResult = true"));
}
else
{
csTest1.Condition = new CodeSnippetExpression(PocoTypeName + "." + mGraph.PropertyName() + " == null");
csTest1.TrueStatements.Add(new CodeSnippetExpression(""));
csTest1.FalseStatements.Add(new CodeSnippetExpression("bResult = true"));
}
}
return ValidationSetStatement;
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeExpression expression;
CodeTypeDeclaration declaration = manager.Context[typeof(CodeTypeDeclaration)] as CodeTypeDeclaration;
RootContext context = manager.Context[typeof(RootContext)] as RootContext;
CodeStatementCollection statements = new CodeStatementCollection();
if ((declaration != null) && (context != null))
{
CodeMemberField field = new CodeMemberField(typeof(IContainer), "components") {
Attributes = MemberAttributes.Private
};
declaration.Members.Add(field);
expression = new CodeFieldReferenceExpression(context.Expression, "components");
}
else
{
CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(typeof(IContainer), "components");
statements.Add(statement);
expression = new CodeVariableReferenceExpression("components");
}
base.SetExpression(manager, value, expression);
CodeObjectCreateExpression right = new CodeObjectCreateExpression(typeof(Container), new CodeExpression[0]);
CodeAssignStatement statement2 = new CodeAssignStatement(expression, right);
statement2.UserData["IContainer"] = "IContainer";
statements.Add(statement2);
return statements;
}
public override void ToCodeDom(CodeStatementCollection statements)
{
if (this.expression!=null)
statements.Add(new CodeExpressionStatement(this.expression.ToCodeDom()));
else
statements.Add(new CodeStatement());
}
public override object Serialize (IDesignerSerializationManager manager, object value)
{
if (value == null)
throw new ArgumentNullException ("value");
if (manager == null)
throw new ArgumentNullException ("manager");
object serialized = null;
string name = manager.GetName (value);
ExpressionContext exprContext = manager.Context[typeof (ExpressionContext)] as ExpressionContext;
if (exprContext != null && exprContext.PresetValue == value) {
CodeStatementCollection statements = new CodeStatementCollection ();
bool isComplete = true;
statements.Add (new CodeCommentStatement (String.Empty));
statements.Add (new CodeCommentStatement (name));
statements.Add (new CodeCommentStatement (String.Empty));
statements.Add (new CodeAssignStatement (GetFieldReference (manager, name),
base.SerializeCreationExpression (manager, value, out isComplete)));
base.SerializeProperties (manager, statements, value, new Attribute[0]);
base.SerializeEvents (manager, statements, value);
serialized = statements;
} else {
serialized = base.Serialize (manager, value);
}
return serialized;
}
public override void ExportCode(ActionBranch currentAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, IMethodCompile methodToCompile, System.CodeDom.CodeMemberMethod method, System.CodeDom.CodeStatementCollection statements, bool debug)
{
IMathExpression mathExp = MathExp;
if (mathExp != null)
{
CodeExpression ceCondition = null;
if (Condition != null)
{
ceCondition = Condition.ExportCode(methodToCompile);
if (ceCondition != null)
{
ceCondition = CompilerUtil.ConvertToBool(Condition.DataType, ceCondition);
}
}
CodeExpression ce = mathExp.ReturnCodeExpression(methodToCompile);
if (ce != null)
{
if (ceCondition == null)
{
statements.Add(new CodeMethodReturnStatement(ce));
}
else
{
CodeConditionStatement cd = new CodeConditionStatement();
cd.Condition = ceCondition;
cd.TrueStatements.Add(new CodeMethodReturnStatement(ce));
statements.Add(cd);
}
}
}
}
protected CodeStatementCollection GenerateSetMappedPropertyCode(CodeExpression targetObj, CodeExpression value)
{
CodeStatementCollection statements = new CodeStatementCollection();
CodePropertyReferenceExpression property = new CodePropertyReferenceExpression(targetObj, MappedProperty.Name);
if (_mappedProperty.PropertyType.IsArray)
{
statements.Add(new CodeAssignStatement(
new CodeIndexerExpression(property, new CodePrimitiveExpression(_index)), value));
return statements;
}
if (IsCollection(_mappedProperty.PropertyType))
{
CodeBinaryOperatorExpression isNull =
new CodeBinaryOperatorExpression(property, CodeBinaryOperatorType.ValueEquality, new CodeSnippetExpression("null"));
CodeAssignStatement create = new CodeAssignStatement(property, new CodeObjectCreateExpression(_mappedProperty.PropertyType));
statements.Add(new CodeConditionStatement(isNull, create));
statements.Add(new CodeMethodInvokeExpression(property, "Add", value));
return statements;
}
statements.Add(new CodeAssignStatement(property, value));
return statements;
}
public void AddCommentStatement(CodeStatementCollection statements, string comment)
{
switch (TargetLanguage)
{
case GenerationTargetLanguage.CSharp:
statements.Add(new CodeSnippetStatement("//" + comment));
break;
case GenerationTargetLanguage.VB:
statements.Add(new CodeSnippetStatement("'" + comment));
break;
}
}
internal static void BuildExpressionSetup(ControlBuilder controlBuilder, CodeStatementCollection methodStatements, CodeStatementCollection statements)
{
CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(controlBuilder.ControlType, "dataBindingExpressionBuilderTarget");
methodStatements.Add(statement);
CodeVariableReferenceExpression left = new CodeVariableReferenceExpression(statement.Name);
CodeAssignStatement statement2 = new CodeAssignStatement(left, new CodeCastExpression(controlBuilder.ControlType, new CodeArgumentReferenceExpression("sender")));
statements.Add(statement2);
Type bindingContainerType = controlBuilder.BindingContainerType;
CodeVariableDeclarationStatement statement3 = new CodeVariableDeclarationStatement(bindingContainerType, "Container");
methodStatements.Add(statement3);
CodeAssignStatement statement4 = new CodeAssignStatement(new CodeVariableReferenceExpression(statement3.Name), new CodeCastExpression(bindingContainerType, new CodePropertyReferenceExpression(left, "BindingContainer")));
statements.Add(statement4);
}
public virtual object Serialize (IDesignerSerializationManager manager, object value)
{
if (value == null)
throw new ArgumentNullException ("value");
if (manager == null)
throw new ArgumentNullException ("manager");
object serialized = null;
bool isComplete = false;
CodeExpression createExpr = base.SerializeCreationExpression (manager, value, out isComplete);
if (isComplete) {
serialized = createExpr;
base.SetExpression (manager, value, createExpr);
} else {
ExpressionContext context = manager.Context[typeof (ExpressionContext)] as ExpressionContext;
if (context != null && context.PresetValue == value) {
CodeStatementCollection statements = new CodeStatementCollection ();
statements.Add (new CodeAssignStatement (context.Expression, createExpr));
base.SerializeProperties (manager, statements, value, new Attribute[0]);
base.SerializeEvents (manager, statements, value, new Attribute[0]);
} else {
CodeExpression expression = base.GetExpression (manager, value);
if (expression == null) {
serialized = expression = createExpr;
base.SetExpression (manager, value, expression);
}
}
}
return serialized;
}
public override CodeStatementCollection BuildOperation(CodeGenerationContext ctx, ICodeGeneratorNode element, CodeVariableReferenceExpression value)
{
CodeStatementCollection statemets = new CodeStatementCollection();
statemets.Add(new CodeSnippetExpression(
string.Format("{0} = ({2})((int){0} >> {1})", value.VariableName, Value, GetValueType(element.MappedProperty).FullName)));
return statemets;
}
internal static void BuildEvalExpression(string field, string formatString, string propertyName,
Type propertyType, ControlBuilder controlBuilder, CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeLinePragma linePragma, bool isEncoded, ref bool hasTempObject) {
// Altogether, this function will create a statement that looks like this:
// if (this.Page.GetDataItem() != null) {
// target.{{propName}} = ({{propType}}) this.Eval(fieldName, formatString);
// }
// this.Eval(fieldName, formatString)
CodeMethodInvokeExpression evalExpr = new CodeMethodInvokeExpression();
evalExpr.Method.TargetObject = new CodeThisReferenceExpression();
evalExpr.Method.MethodName = EvalMethodName;
evalExpr.Parameters.Add(new CodePrimitiveExpression(field));
if (!String.IsNullOrEmpty(formatString)) {
evalExpr.Parameters.Add(new CodePrimitiveExpression(formatString));
}
CodeStatementCollection evalStatements = new CodeStatementCollection();
BuildPropertySetExpression(evalExpr, propertyName, propertyType, controlBuilder, methodStatements, evalStatements, linePragma, isEncoded, ref hasTempObject);
// if (this.Page.GetDataItem() != null)
CodeMethodInvokeExpression getDataItemExpr = new CodeMethodInvokeExpression();
getDataItemExpr.Method.TargetObject = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Page");
getDataItemExpr.Method.MethodName = GetDataItemMethodName;
CodeConditionStatement ifStmt = new CodeConditionStatement();
ifStmt.Condition = new CodeBinaryOperatorExpression(getDataItemExpr,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null));
ifStmt.TrueStatements.AddRange(evalStatements);
statements.Add(ifStmt);
}
public override void Serialize (IDesignerSerializationManager manager, object value, MemberDescriptor descriptor,
CodeStatementCollection statements)
{
if (statements == null)
throw new ArgumentNullException ("statements");
if (manager == null)
throw new ArgumentNullException ("manager");
if (value == null)
throw new ArgumentNullException ("value");
if (descriptor == null)
throw new ArgumentNullException ("descriptor");
IEventBindingService service = manager.GetService (typeof (IEventBindingService)) as IEventBindingService;
if (service != null) {
EventDescriptor eventDescriptor = (EventDescriptor) descriptor;
string methodName = (string) service.GetEventProperty (eventDescriptor).GetValue (value);
if (methodName != null) {
CodeDelegateCreateExpression listener = new CodeDelegateCreateExpression (new CodeTypeReference (eventDescriptor.EventType),
_thisReference, methodName);
CodeExpression targetObject = base.SerializeToExpression (manager, value);
CodeEventReferenceExpression eventRef = new CodeEventReferenceExpression (targetObject, eventDescriptor.Name);
statements.Add (new CodeAttachEventStatement (eventRef, listener));
}
}
}
public override void Serialize (IDesignerSerializationManager manager, object value, MemberDescriptor descriptor, CodeStatementCollection statements)
{
if (statements == null)
throw new ArgumentNullException ("statements");
if (manager == null)
throw new ArgumentNullException ("manager");
if (value == null)
throw new ArgumentNullException ("value");
if (descriptor == null)
throw new ArgumentNullException ("descriptor");
IEventBindingService service = manager.GetService (typeof (IEventBindingService)) as IEventBindingService;
if (service != null) {
// In the propertygrid the events are represented by PropertyDescriptors and the value is a string
// which contains the method name to bind to. The propertydescriptors are managed and created by the
// IEventBindingService
//
EventDescriptor ev = (EventDescriptor) descriptor;
string methodName = (string) service.GetEventProperty (ev).GetValue (value);
CodeDelegateCreateExpression listener = new CodeDelegateCreateExpression (new CodeTypeReference (ev.EventType), _thisReference, methodName);
CodeExpression targetObject = base.SerializeToExpression (manager, value);
CodeEventReferenceExpression eventRef = new CodeEventReferenceExpression (targetObject, ev.Name);
statements.Add (new CodeAttachEventStatement (eventRef, listener));
}
}
public override void ToCodeDom(CodeStatementCollection statements)
{
statements.Add(new CodeAssignStatement(
left.ToCodeDom(),
right.ToCodeDom()
));
}
public virtual object Serialize (IDesignerSerializationManager manager, object value)
{
if (value == null)
throw new ArgumentNullException ("value");
if (manager == null)
throw new ArgumentNullException ("manager");
bool isComplete = true;
CodeStatementCollection statements = new CodeStatementCollection ();
ExpressionContext context = manager.Context[typeof (ExpressionContext)] as ExpressionContext;
object serialized = null;
if (context != null && context.PresetValue == value) {
string varName = base.GetUniqueName (manager, value);
CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement (value.GetType (), varName); // declare
statement.InitExpression = base.SerializeCreationExpression (manager, value, out isComplete); // initialize
base.SetExpression (manager, value, statement.InitExpression);
statements.Add (statement);
serialized = statement;
} else {
string name = manager.GetName (value);
if (name == null)
name = base.GetUniqueName (manager, value);
serialized = GetFieldReference (manager, name);
}
base.SerializeProperties (manager, statements, value, new Attribute[0]);
base.SerializeEvents (manager, statements, value, new Attribute[0]);
return serialized;
}
private void BuildControlSkins(CodeStatementCollection statements) {
foreach (ControlSkinBuilderEntry entry in _controlSkinBuilderEntryList) {
string skinID = entry.SkinID;
ControlBuilder builder = entry.Builder;
statements.Add(BuildControlSkinAssignmentStatement(builder, skinID));
}
}
internal static void BuildExpressionSetup(ControlBuilder controlBuilder, CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeLinePragma linePragma, bool isTwoWayBound, bool designerMode) {
// {{controlType}} target;
CodeVariableDeclarationStatement targetDecl = new CodeVariableDeclarationStatement(controlBuilder.ControlType, "dataBindingExpressionBuilderTarget");
methodStatements.Add(targetDecl);
CodeVariableReferenceExpression targetExp = new CodeVariableReferenceExpression(targetDecl.Name);
// target = ({{controlType}}) sender;
CodeAssignStatement setTarget = new CodeAssignStatement(targetExp,
new CodeCastExpression(controlBuilder.ControlType,
new CodeArgumentReferenceExpression("sender")));
setTarget.LinePragma = linePragma;
statements.Add(setTarget);
Type bindingContainerType = controlBuilder.BindingContainerType;
CodeVariableDeclarationStatement containerDecl = new CodeVariableDeclarationStatement(bindingContainerType, "Container");
methodStatements.Add(containerDecl);
// {{containerType}} Container = ({{containerType}}) target.BindingContainer;
CodeAssignStatement setContainer = new CodeAssignStatement(new CodeVariableReferenceExpression(containerDecl.Name),
new CodeCastExpression(bindingContainerType,
new CodePropertyReferenceExpression(targetExp,
"BindingContainer")));
setContainer.LinePragma = linePragma;
statements.Add(setContainer);
string variableName = isTwoWayBound ? "BindItem" : "Item";
GenerateItemTypeExpressions(controlBuilder, methodStatements, statements, linePragma, variableName);
//Generate code for other variable as well at design time in addition to runtime variable for intellisense to work.
if (designerMode) {
GenerateItemTypeExpressions(controlBuilder, methodStatements, statements, linePragma, isTwoWayBound ? "Item" : "BindItem");
}
}
public void Visit(ProcedureCall call)
{
var domArg = new CodeDomArg();
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "Exec_" + domArg.MethodIdentifier;
method.Attributes = MemberAttributes.Private;
GenerateCallStatement(method.Statements, call.Line.Line);
_mainType.Type.Members.Add(method);
var methodStatements = new CodeStatementCollection();
var argList = new List<CodeExpression>();
foreach(var arg in call.Args)
{
domArg = VisitChild(arg);
argList.Add(domArg.CodeExpression);
}
methodStatements.Add(
new CodeVariableDeclarationStatement(call.Name, "r",
new CodeObjectCreateExpression(call.Name, argList.ToArray()))
);
methodStatements.Add(
new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("r"), "RequestFactory"),
new CodePropertyReferenceExpression(null, "RequestFactory"))
);
var delegateGen = new CodeDelegateCreateExpression(new CodeTypeReference(typeof(Action<ProgressArgs>)),
new CodeThisReferenceExpression(), "OnProgress");
methodStatements.Add(new CodeAttachEventStatement(new CodeVariableReferenceExpression("r"), "Progress", delegateGen));
methodStatements.Add(
new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("r"), "Run")
);
methodStatements.Add(new CodeRemoveEventStatement(new CodeVariableReferenceExpression("r"), "Progress", delegateGen));
method.Statements.AddRange(methodStatements);
var methodcall = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(null, method.Name));
_codeStack.Peek().ParentStatements.Add(methodcall);
}
public static CodeStatementCollection Clone(this CodeStatementCollection collection)
{
if (collection == null) return null;
CodeStatementCollection c = new CodeStatementCollection();
foreach (CodeStatement statement in collection)
c.Add(statement.Clone());
return c;
}
public override void ToCodeDom(CodeStatementCollection statements)
{
statements.Add(
new CodeThrowExceptionStatement(
this.toThrow.ToCodeDom()
)
);
}
public override void ToCodeDom(CodeStatementCollection statements)
{
statements.Add(new CodeConditionStatement(
this.condition.ToCodeDom(),
this.trueStatements.ToCodeDomArray(),
this.falseStatements.ToCodeDomArray()
));
}
private void AddOutputWriteStatement(CodeStatementCollection methodStatements, CodeExpression expr, CodeLinePragma linePragma)
{
CodeStatement outputWriteStatement = this.GetOutputWriteStatement(expr, false);
if (linePragma != null)
{
outputWriteStatement.LinePragma = linePragma;
}
methodStatements.Add(outputWriteStatement);
}
public override void ToCodeDom(CodeStatementCollection statements)
{
CodeStatementCollection col = new CodeStatementCollection();
statement.ToCodeDom(col);
statements.Add(
new CodeLabeledStatement(label,col[0])
);
}
public static WidgetMap GenerateCreationCode(CodeNamespace cns, CodeTypeDeclaration type, Wrapper.ActionGroup grp, CodeExpression groupVarExp, CodeStatementCollection statements, GenerationOptions options, ArrayList warnings)
{
statements.Add (new CodeCommentStatement ("Action group " + grp.Name));
GeneratorContext ctx = new ProjectGeneratorContext (cns, type, statements, options);
ctx.GenerateCreationCode (grp, groupVarExp);
ctx.EndGeneration ();
warnings.AddRange (ctx.Warnings);
return ctx.WidgetMap;
}
public CodeStatementCollection DefaultInvocationMethod(Activity activity)
{
var activityServiceReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), VariableHelper.ToVariableName(activity.Name));
var methodInvocation = new CodeMethodInvokeExpression(activityServiceReference, "Execute", new CodeExpression[] { });
var invocationCodeCollection = new CodeStatementCollection();
invocationCodeCollection.AddRange(LogActivity(activity));
invocationCodeCollection.Add(methodInvocation);
return invocationCodeCollection;
}
public static WidgetMap GenerateCreationCode(CodeNamespace cns, CodeTypeDeclaration type, Gtk.Widget w, CodeExpression widgetVarExp, CodeStatementCollection statements, GenerationOptions options, ArrayList warnings)
{
statements.Add (new CodeCommentStatement ("Widget " + w.Name));
GeneratorContext ctx = new ProjectGeneratorContext (cns, type, statements, options);
Stetic.Wrapper.Widget ww = Stetic.Wrapper.Widget.Lookup (w);
ctx.GenerateCreationCode (ww, widgetVarExp);
ctx.EndGeneration ();
warnings.AddRange (ctx.Warnings);
return ctx.WidgetMap;
}
public override void ToCodeDom(CodeStatementCollection statements)
{
statements.Add(
new CodeTryCatchFinallyStatement(
this.tryStatements.ToCodeDomArray(),
this.catchClauses.ToCodeDomArray(),
this.finallyStatements.ToCodeDomArray()
)
);
}
private CodeExpression BuildArray(CodeStatementCollection statements, string name, object value)
{
Array array = (Array) value;
Type type = value.GetType();
string uniqueVariableName = GetUniqueVariableName(name, statements);
CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(type.FullName, uniqueVariableName);
statement.InitExpression = new CodeArrayCreateExpression(type.GetElementType(), array.Length);
statements.Add(statement);
CodeVariableReferenceExpression targetObject = new CodeVariableReferenceExpression(uniqueVariableName);
string str2 = name + "_";
for (int i = 0; i < array.Length; i++)
{
CodeArrayIndexerExpression left = new CodeArrayIndexerExpression(targetObject, new CodeExpression[0]);
left.Indices.Add(new CodePrimitiveExpression(i));
CodeExpression right = this.BuildObject(statements, str2 + i.ToString(), array.GetValue(i));
statements.Add(new CodeAssignStatement(left, right));
}
return targetObject;
}
/// <summary>
/// Serializes a PaletteGroupView object to the code DOM.
/// </summary>
/// <param name="manager"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
object retVal = value;
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(GroupView), typeof(CodeDomSerializer));
if (baseSerializer != null)
{
retVal = baseSerializer.Serialize(manager, value);
if (retVal != null)
{
System.CodeDom.CodeStatementCollection stmts = retVal as System.CodeDom.CodeStatementCollection;
if (stmts != null)
{
PaletteGroupView palGrpVw = value as PaletteGroupView;
if (palGrpVw != null)
{
SymbolPalette pal = palGrpVw.Palette;
if (pal != null)
{
// Serialize the palette into the resource file
BinaryFormatter formatter = new BinaryFormatter();
System.IO.MemoryStream oStream = new System.IO.MemoryStream();
formatter.Serialize(oStream, pal);
string resName = palGrpVw.Name + "." + "Palette";
this.SerializeResource(manager, resName, oStream.GetBuffer());
oStream.Close();
// Add statements to CodeDom to load the palette from
// the resource file at run-time
string formClassName = "";
IDesignerHost designerHost = manager.GetService(typeof(IDesignerHost)) as IDesignerHost;
if (designerHost != null)
{
formClassName = designerHost.RootComponentClassName;
CodePropertyReferenceExpression exprRefGroupView = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), palGrpVw.Name);
CodeExpression[] loadPalParams = new CodeExpression[]
{
new CodePropertyReferenceExpression(new CodeTypeOfExpression(formClassName), "Assembly"),
new CodePrimitiveExpression(formClassName),
new CodePrimitiveExpression(resName)
};
CodeMethodInvokeExpression stmtLoadPalette = new CodeMethodInvokeExpression(exprRefGroupView, "LoadPalette", loadPalParams);
stmts.Add(stmtLoadPalette);
}
}
}
}
}
}
return(retVal);
}
public CodeStatementCollection GenerateCodeInvocation( AssignActivity assignActivity)
{
var invocationCodeCollection = new CodeStatementCollection();
invocationCodeCollection.AddRange(DefaultActivityBuilder.LogActivity(assignActivity));
invocationCodeCollection.AddRange(this.xslBuilder.Build(assignActivity.InputBindings));
var variableToAssignReference = new CodeFieldReferenceExpression ( new CodeThisReferenceExpression (), VariableHelper.ToVariableName(assignActivity.VariableName));
var codeInvocation = new CodeAssignStatement (variableToAssignReference, new CodeVariableReferenceExpression(VariableHelper.ToVariableName(assignActivity.VariableName)));
invocationCodeCollection.Add(codeInvocation);
return invocationCodeCollection;
}
public void Constructor1_Deny_Unrestricted ()
{
CodeStatementCollection coll = new CodeStatementCollection (array);
coll.CopyTo (array, 0);
Assert.AreEqual (1, coll.Add (cs), "Add");
Assert.AreSame (cs, coll[0], "this[int]");
coll.AddRange (array);
coll.AddRange (coll);
Assert.IsTrue (coll.Contains (cs), "Contains");
Assert.AreEqual (0, coll.IndexOf (cs), "IndexOf");
coll.Insert (0, cs);
coll.Remove (cs);
}
public CodeStatementCollection GenerateCodeInvocation(GenerateErrorActivity activity)
{
var invocationCodeCollection = new CodeStatementCollection();
// add log
invocationCodeCollection.AddRange(DefaultActivityBuilder.LogActivity(activity));
//add the input
invocationCodeCollection.AddRange(this.xslBuilder.Build(activity.InputBindings));
// Add the exception Call
invocationCodeCollection.Add(this.GenerateExceptionStatement(activity));
return invocationCodeCollection;
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(System.CodeDom.CodeTypeDeclaration codeClass, System.CodeDom.CodeStatementCollection codeStatementCollection, CodeGenerateSystem.Base.LinkPinControl element, CodeGenerateSystem.Base.GenerateCodeContext_Method context)
{
MethodInvokeParameterControl retCtrl = null;
Dictionary <BaseNodeControl, System.CodeDom.CodeExpression> paramCodeExps = new Dictionary <BaseNodeControl, System.CodeDom.CodeExpression>();
foreach (var paramNode in mChildNodes)
{
if (paramNode is MethodInvokeParameterControl)
{
var pm = paramNode as MethodInvokeParameterControl;
var param = pm.CSParam as MethodInvokeParameterControl.MethodInvokeParameterConstructionParams;
if (param.ParamInfo.ParamName == "Return")
{
retCtrl = pm;
continue;
}
if (pm.HasLink())
{
await pm.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, pm.ParamPin, context);
var exp = new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParamInfo.ParameterType, pm.GCode_CodeDom_GetValue(pm.ParamPin, context));
paramCodeExps[paramNode] = exp;
codeStatementCollection.Add(new System.CodeDom.CodeAssignStatement(
new System.CodeDom.CodeVariableReferenceExpression(param.ParamInfo.ParamName),
exp));
}
else if (mTemplateClassInstance != null)
{
var proInfo = mTemplateClassInstance.GetType().GetProperty(param.ParamInfo.ParamName);
object proValue;
if (proInfo == null)
{
proValue = CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParamInfo.ParameterType);
}
else
{
proValue = proInfo.GetValue(mTemplateClassInstance);
}
var valueExp = Program.GetValueCode(codeStatementCollection, param.ParamInfo.ParameterType, proValue);
paramCodeExps[paramNode] = valueExp;
codeStatementCollection.Add(new System.CodeDom.CodeAssignStatement(new System.CodeDom.CodeVariableReferenceExpression(param.ParamInfo.ParamName), valueExp));
}
}
else
{
throw new InvalidOperationException();
}
}
if (retCtrl != null)
{
if (retCtrl.HasLink())
{
await retCtrl.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, retCtrl.ParamPin, context);
}
System.CodeDom.CodeExpression retExp = null;
if (retCtrl.HasLink())
{
var retStatement = new System.CodeDom.CodeMethodReturnStatement();
retExp = retCtrl.GCode_CodeDom_GetValue(retCtrl.ParamPin, context);
paramCodeExps[retCtrl] = retExp;
}
else if (mTemplateClassInstance != null)
{
var param = retCtrl.CSParam as MethodInvokeParameterControl.MethodInvokeParameterConstructionParams;
var proInfo = mTemplateClassInstance.GetType().GetProperty("Return");
object proValue;
if (proInfo == null)
{
proValue = CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParamInfo.ParameterType);
}
else
{
proValue = proInfo.GetValue(mTemplateClassInstance);
}
retExp = Program.GetValueCode(codeStatementCollection, param.ParamInfo.ParameterType, proValue);
paramCodeExps[retCtrl] = retExp;
}
#region Debug
var debugCodes = CodeDomNode.BreakPoint.BeginMacrossDebugCodeStatments(codeStatementCollection);
foreach (var paramNode in mChildNodes)
{
if (paramNode is MethodInvokeParameterControl)
{
var pm = paramNode as MethodInvokeParameterControl;
System.CodeDom.CodeExpression exp;
if (paramCodeExps.TryGetValue(paramNode, out exp))
{
CodeDomNode.BreakPoint.GetGatherDataValueCodeStatement(debugCodes, pm.ParamPin.GetLinkPinKeyName(), exp, pm.GCode_GetTypeString(pm.ParamPin, context), context);
}
}
else
{
throw new InvalidOperationException("未实现");
}
}
var breakCondStatement = CodeDomNode.BreakPoint.BreakCodeStatement(codeClass, debugCodes, HostNodesContainer.GUID, Id);
CodeDomNode.BreakPoint.EndMacrossDebugCodeStatements(codeStatementCollection, debugCodes);
#endregion
var returnParam = CSParam as ReturnConstructParam;
foreach (var param in returnParam.MethodInfo.Params)
{
// ref或out，需要将displayType造成的临时变量再赋给原函数参数
if ((param.FieldDirection == FieldDirection.Out || param.FieldDirection == FieldDirection.Ref) && param.ParameterDisplayType != null)
{
codeStatementCollection.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("temp___" + param.ParamName), new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParameterType, new CodeVariableReferenceExpression(param.ParamName))));
}
}
if (returnParam.MethodInfo.ReturnType.BaseType == typeof(System.Threading.Tasks.Task))
{
var genericType = returnParam.MethodInfo.ReturnType.GetGenericArguments()[0];
codeStatementCollection.Add(new System.CodeDom.CodeMethodReturnStatement(new CodeGenerateSystem.CodeDom.CodeCastExpression(genericType, retExp)));
}
else
{
codeStatementCollection.Add(new System.CodeDom.CodeMethodReturnStatement(new CodeGenerateSystem.CodeDom.CodeCastExpression(returnParam.MethodInfo.ReturnType, retExp)));
}
}
else
{
#region Debug
var debugCodes = CodeDomNode.BreakPoint.BeginMacrossDebugCodeStatments(codeStatementCollection);
var breakCondStatement = CodeDomNode.BreakPoint.BreakCodeStatement(codeClass, debugCodes, HostNodesContainer.GUID, Id);
CodeDomNode.BreakPoint.EndMacrossDebugCodeStatements(codeStatementCollection, debugCodes);
#endregion
var returnParam = CSParam as ReturnConstructParam;
foreach (var param in returnParam.MethodInfo.Params)
{
// ref或out，需要将displayType造成的临时变量再赋给原函数参数
if ((param.FieldDirection == FieldDirection.Out || param.FieldDirection == FieldDirection.Ref) && param.ParameterDisplayType != null)
{
codeStatementCollection.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("temp___" + param.ParamName), new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParameterType, new CodeVariableReferenceExpression(param.ParamName))));
}
}
codeStatementCollection.Add(new System.CodeDom.CodeMethodReturnStatement());
}
}