public void Constructor0 ()
{
CodeMethodReferenceExpression cmre = new CodeMethodReferenceExpression ();
Assert.IsNotNull (cmre.MethodName, "#1");
Assert.AreEqual (string.Empty, cmre.MethodName, "#2");
Assert.IsNull (cmre.TargetObject, "#3");
#if NET_2_0
Assert.IsNotNull (cmre.TypeArguments, "#4");
Assert.AreEqual (0, cmre.TypeArguments.Count, "#5");
#endif
string methodName = "mono";
cmre.MethodName = methodName;
Assert.IsNotNull (cmre.MethodName, "#6");
Assert.AreSame (methodName, cmre.MethodName, "#7");
cmre.MethodName = null;
Assert.IsNotNull (cmre.MethodName, "#8");
Assert.AreEqual (string.Empty, cmre.MethodName, "#9");
CodeExpression expression = new CodeExpression ();
cmre.TargetObject = expression;
Assert.IsNotNull (cmre.TargetObject, "#10");
Assert.AreSame (expression, cmre.TargetObject, "#11");
cmre.TargetObject = null;
Assert.IsNull (cmre.TargetObject, "#12");
}
public CodeMethodInvokeExpression (CodeExpression targetObject,
string methodName,
params CodeExpression [] parameters)
{
this.method = new CodeMethodReferenceExpression( targetObject, methodName );
this.Parameters.AddRange (parameters);
}
public override CodeExpression GCode_CodeDom_GetValue(CodeGenerateSystem.Base.LinkControl element, CodeGenerateSystem.Base.GenerateCodeContext_Method context)
{
RefreshValueFromTemplateClass2PropertyInfoList();
if (element == mCtrlreturnLink)
{
var info = GetLinkObjInfo(mCtrlparamLink);
string value = "CSUtility.Data.DataTemplateManager<";
value += mParamType.FullName + ", " + mReturnType.FullName + ">.Instance";
System.CodeDom.CodeMethodReferenceExpression methodRef = new System.CodeDom.CodeMethodReferenceExpression();
methodRef.TargetObject = new System.CodeDom.CodeSnippetExpression(value);
methodRef.MethodName = "GetDataTemplate";
CodeExpression[] exps = new CodeExpression[1];
if (info.HasLink)
{
var ep = info.GetLinkObject(0, true).GCode_CodeDom_GetValue(info.GetLinkElement(0, true), context);
exps[0] = ep;
}
else
{
foreach (var proInfo in mCustomPropertyInfos)
{
if (proInfo.PropertyName == "Id")
{
exps[0] = new CodePrimitiveExpression(proInfo.CurrentValue);
break;
}
}
}
return(new System.CodeDom.CodeMethodInvokeExpression(methodRef, exps));
}
return(base.GCode_CodeDom_GetValue(element, context));
}
public void Constructor0 ()
{
CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression ();
Assert.IsNotNull (cmie.Method, "#1");
Assert.AreEqual (string.Empty, cmie.Method.MethodName, "#2");
Assert.IsNull (cmie.Method.TargetObject, "#3");
#if NET_2_0
Assert.AreEqual (0, cmie.Method.TypeArguments.Count, "#4");
#endif
Assert.IsNotNull (cmie.Parameters, "#5");
Assert.AreEqual (0, cmie.Parameters.Count, "#6");
CodeMethodReferenceExpression method = new CodeMethodReferenceExpression ();
cmie.Method = method;
Assert.IsNotNull (cmie.Method, "#7");
Assert.AreSame (method, cmie.Method, "#8");
cmie.Method = null;
Assert.IsNotNull (cmie.Method, "#9");
Assert.AreEqual (string.Empty, cmie.Method.MethodName, "#10");
Assert.IsNull (cmie.Method.TargetObject, "#11");
#if NET_2_0
Assert.AreEqual (0, cmie.Method.TypeArguments.Count, "#12");
#endif
}
protected override CodeMemberMethod CreateService(CodeTypeReference typerefWCFService, CodeTypeReference typerefService)
{
CodeTypeReferenceExpression typerefexprService = new CodeTypeReferenceExpression(typerefService);
CodeMethodReferenceExpression methodrefDbusServiceCreate = new CodeMethodReferenceExpression(typerefexprService, "Create");
CodeMemberMethod methodCreateService = new CodeMemberMethod();
methodCreateService.Name = CreateServiceName;
methodCreateService.ReturnType = typerefWCFService;
methodCreateService.Attributes = MemberAttributes.Static;
methodCreateService.Parameters.Add(new CodeParameterDeclarationExpression(CodeBuilderCommon.typerefWCFServiceParams, nameWCFServiceParamsArg));
CodeMethodReferenceExpression methodrefCreateDbusService = new CodeMethodReferenceExpression(CodeBuilderCommon.typerefexprLookupTargetFunctions, CodeBuilderCommon.CreateDbusService);
methodrefCreateDbusService.TypeArguments.Add(typerefService);
methodCreateService.Statements.Add(new CodeVariableDeclarationStatement(typerefService, dbusService, // * <dbus_service> dbusService =
new CodeMethodInvokeExpression(methodrefCreateDbusService // * Udbus.WCF.Dbus.Service.LookupTargetFunctions.CreateDbusService(
, argrefWCFServiceParams // * wcfserviceparams
, methodrefDbusServiceCreate // * , <dbus_service>.Create // createService1
, methodrefDbusServiceCreate // * , <dbus_service>.Create // createService2
, new CodePropertyReferenceExpression(typerefexprService, CodeBuilderCommon.DefaultConnectionParameters) // * <dbus_service>.DefaultConnectionParameters);
)
));
// * <wcfservice> wcfService = new <wcfservice>(dbusservice);
methodCreateService.Statements.Add(new CodeVariableDeclarationStatement(typerefWCFService, wcfService
, new CodeObjectCreateExpression(typerefWCFService, varrefDbusService)
));
// return wcfService;
methodCreateService.Statements.Add(new CodeMethodReturnStatement(varrefWcfService));
return methodCreateService;
}
CodeMemberMethod CreateMethod()
{
CodeMemberMethod method = new CodeMemberMethod();
// BeginInit method call.
CodeExpressionStatement statement = new CodeExpressionStatement();
CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression();
statement.Expression = methodInvoke;
CodeMethodReferenceExpression methodRef = new CodeMethodReferenceExpression();
methodRef.MethodName = "BeginInit";
CodeCastExpression cast = new CodeCastExpression();
cast.TargetType = new CodeTypeReference();
cast.TargetType.BaseType = "System.ComponentModel.ISupportInitialize";
CodeFieldReferenceExpression fieldRef = new CodeFieldReferenceExpression();
fieldRef.FieldName = "pictureBox1";
fieldRef.TargetObject = new CodeThisReferenceExpression();
cast.Expression = fieldRef;
methodRef.TargetObject = cast;
methodInvoke.Method = methodRef;
method.Statements.Add(statement);
return method;
}
public void Constructor1_Deny_Unrestricted ()
{
CodeMethodReferenceExpression method = new CodeMethodReferenceExpression ();
CodeExpression[] parameters = new CodeExpression[1] { new CodeExpression () };
CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression (method, parameters);
Assert.AreSame (method, cmie.Method, "Method");
cmie.Method = new CodeMethodReferenceExpression ();
Assert.AreEqual (1, cmie.Parameters.Count, "Parameters");
}
public override void Generate(object codeObject, Entity entity)
{
var propNode = (CodeMemberProperty) codeObject;
var property = (GenericProperty) entity;
var getPropertyValueMethod = new CodeMethodReferenceExpression(null, "GetValue", propNode.Type);
var getPropertyValueCall = new CodeMethodInvokeExpression(getPropertyValueMethod, new CodePrimitiveExpression(property.Alias));
propNode.GetStatements.Add(new CodeMethodReturnStatement(getPropertyValueCall));
}
public void Constructor0_Deny_Unrestricted ()
{
CodeMethodReferenceExpression cmre = new CodeMethodReferenceExpression ();
Assert.AreEqual (String.Empty, cmre.MethodName, "MethodName");
cmre.MethodName = "mono";
Assert.IsNull (cmre.TargetObject, "TargetObject");
cmre.TargetObject = new CodeExpression ();
Assert.AreEqual (0, cmre.TypeArguments.Count, "TypeArguments");
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
PropertyDescriptor descriptor = (PropertyDescriptor) manager.Context[typeof(PropertyDescriptor)];
ExpressionContext context = (ExpressionContext) manager.Context[typeof(ExpressionContext)];
bool flag = (value != null) ? CodeDomSerializerBase.GetReflectionTypeHelper(manager, value).IsSerializable : true;
bool flag2 = !flag;
bool flag3 = (descriptor != null) && descriptor.Attributes.Contains(DesignerSerializationVisibilityAttribute.Content);
if (!flag2)
{
flag2 = ((context != null) && (context.PresetValue != null)) && (context.PresetValue == value);
}
if (((this._model == CodeDomLocalizationModel.PropertyReflection) && !flag3) && !flag2)
{
CodeStatementCollection statements = (CodeStatementCollection) manager.Context[typeof(CodeStatementCollection)];
bool flag4 = false;
ExtenderProvidedPropertyAttribute attribute = null;
if (descriptor != null)
{
attribute = descriptor.Attributes[typeof(ExtenderProvidedPropertyAttribute)] as ExtenderProvidedPropertyAttribute;
if ((attribute != null) && (attribute.ExtenderProperty != null))
{
flag4 = true;
}
}
if ((!flag4 && (context != null)) && (statements != null))
{
string name = manager.GetName(context.Owner);
CodeExpression expression = base.SerializeToExpression(manager, context.Owner);
if ((name != null) && (expression != null))
{
RootContext context2 = manager.Context[typeof(RootContext)] as RootContext;
if ((context2 != null) && (context2.Value == context.Owner))
{
name = "$this";
}
base.SerializeToResourceExpression(manager, value, false);
if (this.EmitApplyMethod(manager, context.Owner))
{
ResourceManager manager2 = manager.Context[typeof(ResourceManager)] as ResourceManager;
CodeMethodReferenceExpression expression3 = new CodeMethodReferenceExpression(base.GetExpression(manager, manager2), "ApplyResources");
CodeMethodInvokeExpression expression4 = new CodeMethodInvokeExpression {
Method = expression3
};
expression4.Parameters.Add(expression);
expression4.Parameters.Add(new CodePrimitiveExpression(name));
statements.Add(expression4);
}
return null;
}
}
}
if (flag2)
{
return this._currentSerializer.Serialize(manager, value);
}
return base.SerializeToResourceExpression(manager, value);
}
public static CodeMethodReferenceExpression Clone(this CodeMethodReferenceExpression expression)
{
if (expression == null) return null;
CodeMethodReferenceExpression e = new CodeMethodReferenceExpression();
e.MethodName = expression.MethodName;
e.TargetObject = expression.TargetObject.Clone();
e.TypeArguments.AddRange(expression.TypeArguments.Clone());
e.UserData.AddRange(expression.UserData);
return e;
}
public TypescriptMethodReferenceExpression(
IExpressionFactory expressionFactory,
CodeMethodReferenceExpression codeExpression,
CodeGeneratorOptions options)
{
_expressionFactory = expressionFactory;
_codeExpression = codeExpression;
_options = options;
System.Diagnostics.Debug.WriteLine("TypescriptMethodReferenceExpression Created");
}
public void Constructor1_Deny_Unrestricted ()
{
CodeExpression target = new CodeExpression ();
CodeMethodReferenceExpression cmre = new CodeMethodReferenceExpression (target, "mono");
Assert.AreEqual ("mono", cmre.MethodName, "MethodName");
cmre.MethodName = String.Empty;
Assert.AreSame (target, cmre.TargetObject, "TargetObject");
cmre.TargetObject = new CodeExpression ();
Assert.AreEqual (0, cmre.TypeArguments.Count, "TypeArguments");
}
private static CodeMethodReferenceExpression CloneMethodReference(CodeMethodReferenceExpression oldReference)
{
CodeMethodReferenceExpression result = new CodeMethodReferenceExpression {
MethodName = oldReference.MethodName,
TargetObject = RuleExpressionWalker.Clone(oldReference.TargetObject)
};
foreach (CodeTypeReference reference in oldReference.TypeArguments)
{
result.TypeArguments.Add(TypeReferenceExpression.CloneType(reference));
}
ConditionHelper.CloneUserData(oldReference, result);
return result;
}
public Script(string namespaceToGen, string className)
{
this.compileUnit = new CodeCompileUnit();
this.codeNamespace = new CodeNamespace(namespaceToGen);
this.compileUnit.Namespaces.Add(this.codeNamespace);
this.codeClass = new CodeTypeDeclaration(className);
this.codeNamespace.Types.Add(this.codeClass);
this.proxySetting = ProxySettings.RequiredHeaders;
this.mainMethod = new CodeEntryPointMethod();
this.mainMethod.Name = "Main";
this.mainMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static;
this.codeClass.Members.Add(this.mainMethod);
this.dumpMethodRef = this.BuildDumper();
}
private CodeThrowExceptionStatement GenerateExceptionStatement(GenerateErrorActivity activity)
{
var parameters = DefaultActivityBuilder.GenerateParameters(new List<string> {
@"""Message : {0}\nMessage code : {1} """
}, activity);
CodeMethodInvokeExpression stringFormatCall = new CodeMethodInvokeExpression();
stringFormatCall.Parameters.AddRange(parameters);
CodeMethodReferenceExpression formatMethod = new CodeMethodReferenceExpression();
formatMethod.MethodName = "Format";
CodeVariableReferenceExpression stringObject = new CodeVariableReferenceExpression();
stringObject.VariableName = "String";
formatMethod.TargetObject = stringObject;
stringFormatCall.Method = formatMethod;
CodeThrowExceptionStatement throwException = new CodeThrowExceptionStatement(new CodeObjectCreateExpression(new CodeTypeReference(typeof(System.Exception)), stringFormatCall));
return throwException;
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
object obj2 = null;
StringDictionary dictionary = value as StringDictionary;
if (dictionary == null)
{
return obj2;
}
object current = manager.Context.Current;
ExpressionContext context = current as ExpressionContext;
if ((context != null) && (context.Owner == value))
{
current = context.Expression;
}
CodePropertyReferenceExpression targetObject = current as CodePropertyReferenceExpression;
if (targetObject == null)
{
return obj2;
}
object component = base.DeserializeExpression(manager, null, targetObject.TargetObject);
if ((component == null) || (TypeDescriptor.GetProperties(component)[targetObject.PropertyName] == null))
{
return obj2;
}
CodeStatementCollection statements = new CodeStatementCollection();
CodeMethodReferenceExpression expression2 = new CodeMethodReferenceExpression(targetObject, "Add");
foreach (DictionaryEntry entry in dictionary)
{
CodeExpression expression3 = base.SerializeToExpression(manager, entry.Key);
CodeExpression expression4 = base.SerializeToExpression(manager, entry.Value);
if ((expression3 != null) && (expression4 != null))
{
CodeMethodInvokeExpression expression5 = new CodeMethodInvokeExpression {
Method = expression2
};
expression5.Parameters.Add(expression3);
expression5.Parameters.Add(expression4);
statements.Add(expression5);
}
}
return statements;
}
public void Constructor1 ()
{
CodeMethodReferenceExpression method1 = new CodeMethodReferenceExpression ();
CodeExpression param1 = new CodeExpression ();
CodeExpression param2 = new CodeExpression ();
CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression (
method1, param1, param2);
Assert.IsNotNull (cmie.Method, "#1");
Assert.AreSame (method1, cmie.Method, "#2");
cmie.Method = null;
Assert.IsNotNull (cmie.Method, "#3");
Assert.AreEqual (string.Empty, cmie.Method.MethodName, "#4");
Assert.IsNull (cmie.Method.TargetObject, "#5");
#if NET_2_0
Assert.AreEqual (0, cmie.Method.TypeArguments.Count, "#6");
#endif
CodeMethodReferenceExpression method2 = new CodeMethodReferenceExpression ();
cmie.Method = method2;
Assert.IsNotNull (cmie.Method, "#7");
Assert.AreSame (method2, cmie.Method, "#8");
Assert.IsNotNull (cmie.Parameters, "#9");
Assert.AreEqual (2, cmie.Parameters.Count, "#10");
Assert.AreEqual (0, cmie.Parameters.IndexOf (param1), "#11");
Assert.AreEqual (1, cmie.Parameters.IndexOf (param2), "#12");
cmie = new CodeMethodInvokeExpression ((CodeMethodReferenceExpression) null,
param2);
Assert.IsNotNull (cmie.Method, "#13");
Assert.AreEqual (string.Empty, cmie.Method.MethodName, "#14");
Assert.IsNull (cmie.Method.TargetObject, "#15");
#if NET_2_0
Assert.AreEqual (0, cmie.Method.TypeArguments.Count, "#16");
#endif
Assert.IsNotNull (cmie.Parameters, "#17");
Assert.AreEqual (1, cmie.Parameters.Count, "#18");
Assert.AreEqual (0, cmie.Parameters.IndexOf (param2), "#19");
}
private CodeMethodInvokeExpression GenerateLoggerCodeInvocation(WriteToLogActivity activity)
{
var parameters = DefaultActivityBuilder.GenerateParameters(new List<string> {
@"""Message : {0}\nMessage code : {1} """
}, activity);
CodeMethodInvokeExpression stringFormatCall = new CodeMethodInvokeExpression();
stringFormatCall.Parameters.AddRange(parameters);
CodeMethodReferenceExpression formatMethod = new CodeMethodReferenceExpression();
formatMethod.MethodName = "Format";
CodeVariableReferenceExpression stringObject = new CodeVariableReferenceExpression();
stringObject.VariableName = "String";
formatMethod.TargetObject = stringObject;
stringFormatCall.Method = formatMethod;
var loggerReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), VariableHelper.ToVariableName("logger"));
var methodInvocation = new CodeMethodInvokeExpression(loggerReference, activity.Role, stringFormatCall);
return methodInvocation;
}
public void Constructor1 ()
{
CodeExpression expression = new CodeExpression ();
string methodName = "mono";
CodeMethodReferenceExpression cmre = new CodeMethodReferenceExpression (
expression, methodName);
Assert.IsNotNull (cmre.MethodName, "#1");
Assert.AreSame (methodName, cmre.MethodName, "#2");
Assert.IsNotNull (cmre.TargetObject, "#3");
Assert.AreSame (expression, cmre.TargetObject, "#4");
Assert.IsNotNull (cmre.TypeArguments, "#5");
Assert.AreEqual (0, cmre.TypeArguments.Count, "#6");
cmre = new CodeMethodReferenceExpression ((CodeExpression) null,
(string) null);
Assert.IsNotNull (cmre.MethodName, "#7");
Assert.AreEqual (string.Empty, cmre.MethodName, "#8");
Assert.IsNull (cmre.TargetObject, "#9");
}
internal void GenerateOverrideMatchedHeaders(CodeTypeDeclaration typeDeclaration)
{
CodeMemberMethod method = new CodeMemberMethod {
Name = "PopulateMatchedHeaders",
Attributes = MemberAttributes.Family | MemberAttributes.Override,
ReturnType = new CodeTypeReference(typeof(void))
};
CodeParameterDeclarationExpression expression = new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(IDictionary)), "dictionary");
method.Parameters.Add(expression);
typeDeclaration.Members.Add(method);
CodeMethodReferenceExpression expression2 = new CodeMethodReferenceExpression(new CodeBaseReferenceExpression(), "PopulateMatchedHeaders");
CodeMethodInvokeExpression expression3 = new CodeMethodInvokeExpression(expression2, new CodeExpression[] { this._dictionaryRefExpr });
method.Statements.Add(expression3);
foreach (string str in (IEnumerable) this._headers)
{
CodeAssignStatement statement = new CodeAssignStatement {
Left = new CodeIndexerExpression(this._dictionaryRefExpr, new CodeExpression[] { new CodePrimitiveExpression(str) }),
Right = new CodePrimitiveExpression(null)
};
method.Statements.Add(statement);
}
}
internal void GenerateOverrideBrowserElements(CodeTypeDeclaration typeDeclaration)
{
if (this._browserDefinitionCollection != null)
{
CodeMemberMethod method = new CodeMemberMethod {
Name = "PopulateBrowserElements",
Attributes = MemberAttributes.Family | MemberAttributes.Override,
ReturnType = new CodeTypeReference(typeof(void))
};
CodeParameterDeclarationExpression expression = new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(IDictionary)), "dictionary");
method.Parameters.Add(expression);
typeDeclaration.Members.Add(method);
CodeMethodReferenceExpression expression2 = new CodeMethodReferenceExpression(new CodeBaseReferenceExpression(), "PopulateBrowserElements");
CodeMethodInvokeExpression expression3 = new CodeMethodInvokeExpression(expression2, new CodeExpression[] { this._dictionaryRefExpr });
method.Statements.Add(expression3);
foreach (BrowserDefinition definition in this._browserDefinitionCollection)
{
if (definition.IsDeviceNode)
{
CodeAssignStatement statement = new CodeAssignStatement {
Left = new CodeIndexerExpression(this._dictionaryRefExpr, new CodeExpression[] { new CodePrimitiveExpression(definition.ID) }),
Right = new CodeObjectCreateExpression(typeof(Triplet), new CodeExpression[] { new CodePrimitiveExpression(definition.ParentName), new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(string)), "Empty"), new CodePrimitiveExpression(definition.Depth) })
};
method.Statements.Add(statement);
}
}
for (int i = 0; i < this._customTreeNames.Count; i++)
{
foreach (BrowserDefinition definition2 in (BrowserDefinitionCollection) this._customBrowserDefinitionCollections[i])
{
if (definition2.IsDeviceNode)
{
CodeAssignStatement statement2 = new CodeAssignStatement {
Left = new CodeIndexerExpression(this._dictionaryRefExpr, new CodeExpression[] { new CodePrimitiveExpression(definition2.ID) }),
Right = new CodeObjectCreateExpression(typeof(Triplet), new CodeExpression[] { new CodePrimitiveExpression(definition2.ParentName), new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(string)), "Empty"), new CodePrimitiveExpression(definition2.Depth) })
};
method.Statements.Add(statement2);
}
}
}
}
}
private void ReturnIfHeaderValueEmpty(CodeMemberMethod cmm, CodeVariableReferenceExpression varExpr)
{
CodeConditionStatement statement = new CodeConditionStatement();
CodeMethodReferenceExpression method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(string)), "IsNullOrEmpty");
CodeMethodInvokeExpression expression2 = new CodeMethodInvokeExpression(method, new CodeExpression[] { varExpr });
statement.Condition = expression2;
statement.TrueStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(false)));
cmm.Statements.Add(statement);
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public CodeMethodInvokeExpression(CodeExpression targetObject, string methodName, params CodeExpression[] parameters)
{
this.method = new CodeMethodReferenceExpression(targetObject, methodName);
Parameters.AddRange(parameters);
}
/// <devdoc>
/// <para>
/// Initializes a new instance of <see cref='System.CodeDom.CodeMethodInvokeExpression'/> using the specified target object, method name
/// and parameters.
/// </para>
/// </devdoc>
public CodeMethodInvokeExpression(CodeMethodReferenceExpression method, params CodeExpression[] parameters)
{
this.method = method;
Parameters.AddRange(parameters);
}
protected override void GenerateMethodReferenceExpression(CodeMethodReferenceExpression e)
{
Output.Write("[CodeMethodReferenceExpression: Name={0}, Target=", e.MethodName);
this.GenerateExpression(e.TargetObject);
Output.Write("]");
}
private CodeMethodInvokeExpression GenerateInvokeCallOnJavaClass(CodeVariableReferenceExpression javaClassReference)
{
CodeMethodInvokeExpression invokeCall = new CodeMethodInvokeExpression();
invokeCall.Parameters.AddRange(new CodeExpression[0]);
CodeMethodReferenceExpression invokeMethod = new CodeMethodReferenceExpression();
invokeMethod.MethodName = InvokeMethodName;
invokeMethod.TargetObject = javaClassReference;
invokeCall.Method = invokeMethod;
return invokeCall;
}
public CodeMethodInvokeExpression(CodeMethodReferenceExpression method, params CodeExpression[] parameters)
{
this.parameters = new CodeExpressionCollection();
this.method = method;
this.Parameters.AddRange(parameters);
}
public CodeMethodInvokeExpression(ILInstruction inline, CodeExpression targetObject, string methodName, params CodeExpression[] parameters) : base(inline)
{
_method = new CodeMethodReferenceExpression(inline, targetObject, methodName);
Parameters.AddRange(parameters);
}
protected override void AddStatementsToFrameworkInitialize (CodeMemberMethod method)
{
string responseEncoding = pageParser.ResponseEncoding;
if (responseEncoding != null)
method.Statements.Add (CreatePropertyAssign ("ResponseEncoding", responseEncoding));
int codepage = pageParser.CodePage;
if (codepage != -1)
method.Statements.Add (CreatePropertyAssign ("CodePage", codepage));
string contentType = pageParser.ContentType;
if (contentType != null)
method.Statements.Add (CreatePropertyAssign ("ContentType", contentType));
if (pageParser.OutputCache) {
CodeMethodReferenceExpression init = new CodeMethodReferenceExpression (null,
"InitOutputCache");
CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression (init,
OutputCacheParams ());
method.Statements.Add (invoke);
}
int lcid = pageParser.LCID;
if (lcid != -1)
method.Statements.Add (CreatePropertyAssign ("LCID", lcid));
string culture = pageParser.Culture;
if (culture != null)
method.Statements.Add (CreatePropertyAssign ("Culture", culture));
culture = pageParser.UICulture;
if (culture != null)
method.Statements.Add (CreatePropertyAssign ("UICulture", culture));
string errorPage = pageParser.ErrorPage;
if (errorPage != null)
method.Statements.Add (CreatePropertyAssign ("ErrorPage", errorPage));
if (pageParser.HaveTrace) {
CodeAssignStatement stmt = new CodeAssignStatement ();
stmt.Left = new CodePropertyReferenceExpression (thisRef, "TraceEnabled");
stmt.Right = new CodePrimitiveExpression (pageParser.Trace);
method.Statements.Add (stmt);
}
if (pageParser.TraceMode != TraceMode.Default) {
CodeAssignStatement stmt = new CodeAssignStatement ();
CodeTypeReferenceExpression tm = new CodeTypeReferenceExpression ("System.Web.TraceMode");
stmt.Left = new CodePropertyReferenceExpression (thisRef, "TraceModeValue");
stmt.Right = new CodeFieldReferenceExpression (tm, pageParser.TraceMode.ToString ());
method.Statements.Add (stmt);
}
if (pageParser.NotBuffer) {
CodeAssignStatement stmt = new CodeAssignStatement ();
stmt.Left = new CodePropertyReferenceExpression (thisRef, "Buffer");
stmt.Right = new CodePrimitiveExpression (false);
method.Statements.Add (stmt);
}
#if NET_1_1
if (pageParser.ValidateRequest) {
CodeMethodInvokeExpression expr = new CodeMethodInvokeExpression ();
CodePropertyReferenceExpression prop;
prop = new CodePropertyReferenceExpression (thisRef, "Request");
expr.Method = new CodeMethodReferenceExpression (prop, "ValidateInput");
method.Statements.Add (expr);
}
#endif
base.AddStatementsToFrameworkInitialize (method);
}
private static void AddEntityOptionSetEnumDeclaration(CodeTypeDeclarationCollection types)
{
var enumClass = new CodeTypeDeclaration("EntityOptionSetEnum")
{
IsClass = true,
TypeAttributes = TypeAttributes.Sealed | TypeAttributes.NotPublic,
};
// public static int? GetEnum(Microsoft.Xrm.Sdk.Entity entity, string attributeLogicalName)
var get = new CodeMemberMethod
{
Name = "GetEnum",
ReturnType = new CodeTypeReference(typeof(int?)),
// ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
Attributes = System.CodeDom.MemberAttributes.Static | System.CodeDom.MemberAttributes.Public,
};
get.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Microsoft.Xrm.Sdk.Entity), "entity"));
get.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "attributeLogicalName"));
// entity.Attributes.ContainsKey(attributeLogicalName)
var entityAttributesContainsKey =
new CodeMethodReferenceExpression(
new CodePropertyReferenceExpression(
new CodeArgumentReferenceExpression("entity"),
"Attributes"),
"ContainsKey");
var invokeContainsKey = new CodeMethodInvokeExpression(entityAttributesContainsKey, new CodeArgumentReferenceExpression("attributeLogicalName"));
// Microsoft.Xrm.Sdk.OptionSetValue value = entity.GetAttributeValue<Microsoft.Xrm.Sdk.OptionSetValue>(attributeLogicalName).Value;
var declareAndSetValue =
new CodeVariableDeclarationStatement
{
Type = new CodeTypeReference(typeof(OptionSetValue)),
Name = "value",
InitExpression = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeArgumentReferenceExpression("entity"), "GetAttributeValue", new CodeTypeReference(typeof(OptionSetValue))),
new CodeArgumentReferenceExpression("attributeLogicalName"))
};
// value != null
var valueNeNull = new CodeSnippetExpression("value != null");
// value.Value
var invokeValueGetValue = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("value"), "Value");
// if(invokeContainsKey){return invokeGetAttributeValue;}else{return null}
get.Statements.Add(new CodeConditionStatement(invokeContainsKey, declareAndSetValue,
new CodeConditionStatement(valueNeNull, new CodeMethodReturnStatement(invokeValueGetValue))));
// return null;
get.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
enumClass.Members.Add(get);
types.Add(enumClass);
}
private CodeStatementCollection GenerateInputCallOnJavaClass(JavaActivity javaActivity, CodeVariableReferenceExpression javaClassReference)
{
var invocationCodeCollection = new CodeStatementCollection();
foreach (var parameter in javaActivity.Parameters)
{
CodeMethodInvokeExpression setterCall = new CodeMethodInvokeExpression();
setterCall.Parameters.AddRange(new List<CodeExpression> {
new CodeSnippetExpression(parameter.Name)
}.ToArray());
CodeMethodReferenceExpression setterMethod = new CodeMethodReferenceExpression();
setterMethod.MethodName = "set" + parameter.Name;
setterMethod.TargetObject = javaClassReference;
setterCall.Method = setterMethod;
invocationCodeCollection.Add(setterCall);
}
return invocationCodeCollection;
}
public CodeMethodInvokeExpression(CodeMethodReferenceExpression method, params CodeExpression[] parameters)
{
throw new NotImplementedException();
}
private CodeStatementCollection GenerateOutputCallOnJavaClass(JavaActivity javaActivity, CodeVariableReferenceExpression javaClassReference, CodeVariableReferenceExpression activityClassReference)
{
var invocationCodeCollection = new CodeStatementCollection();
foreach (var parameter in javaActivity.OutputData)
{
CodeAssignStatement _assign1 = new CodeAssignStatement();
CodePropertyReferenceExpression _prop1 = new CodePropertyReferenceExpression();
_prop1.PropertyName = parameter.Name;
_prop1.TargetObject = activityClassReference;
_assign1.Left = _prop1;
// CodePrimitiveExpression _value1 = new CodePrimitiveExpression();
// _value1.Value = "testvalue";
// _assign1.Right = _value1;
// __ctor_ctor1.Statements.Add(_assign1);
CodeMethodInvokeExpression getterCall = new CodeMethodInvokeExpression();
getterCall.Parameters.AddRange(new CodeExpression[0]);
CodeMethodReferenceExpression getterMethod = new CodeMethodReferenceExpression();
getterMethod.MethodName = "get" + parameter.Name;
getterMethod.TargetObject = javaClassReference;
getterCall.Method = getterMethod;
_assign1.Right = getterCall;
invocationCodeCollection.Add(_assign1);
}
return invocationCodeCollection;
}
protected override void GenerateMethodReferenceExpression(System.CodeDom.CodeMethodReferenceExpression e)
{
throw new Exception("The method or operation is not implemented.");
}
public override void WriteCode(TemplateContext ctx, ActionNode node)
{
var codeMethodReferenceExpression = new CodeMethodReferenceExpression(
new CodeSnippetExpression(SystemType.FullName),
Method.Name);
if (this.InstanceInfo != null)
{
var instanceVar = node.InputVars.FirstOrDefault(p => p.ActionFieldInfo == this.InstanceInfo);
if (instanceVar != null)
{
codeMethodReferenceExpression = new CodeMethodReferenceExpression(new CodeSnippetExpression(instanceVar.VariableName),Method.Name);
}
}
var _currentActionInvoker =
new CodeMethodInvokeExpression(
codeMethodReferenceExpression);
foreach (var x in Method.GetParameters())
{
var item = node.GraphItems.OfType<IActionItem>().FirstOrDefault(p => p.Name == x.Name);
var input = item as IActionIn;
if (input != null)
{
if (input.ActionFieldInfo == InstanceInfo) continue;
if (input.ActionFieldInfo.IsGenericArgument)
{
}
else
{
_currentActionInvoker.Parameters.Add(
new CodeSnippetExpression((input.ActionFieldInfo.IsByRef ? "ref " : string.Empty) +
string.Format("{0}", input.VariableName)));
}
}
var @out = item as ActionOut;
if (@out != null)
{
if (@out.ActionFieldInfo != null && @out.ActionFieldInfo.IsReturn)
{
continue;
}
_currentActionInvoker.Parameters.Add(
new CodeSnippetExpression(string.Format("out {0}", @out.VariableName)));
}
var branch = item as ActionBranch;
if (branch != null)
{
if (DebugSystem.IsDebugMode)
{
_currentActionInvoker.Parameters.Add(
new CodeSnippetExpression(string.Format("()=> {{ System.StartCoroutine({0}()); }}",
branch.VariableName)));
}
else
{
_currentActionInvoker.Parameters.Add(
new CodeSnippetExpression(string.Format("{0}", branch.VariableName)));
}
}
}
var resultOut = node.GraphItems.OfType<IActionItem>().FirstOrDefault(p => p.ActionFieldInfo != null && p.ActionFieldInfo.IsReturn);
if (resultOut == null)
{
ctx.CurrentStatements.Add(_currentActionInvoker);
}
else
{
var assignResult = new CodeAssignStatement(
new CodeSnippetExpression(resultOut.VariableName), _currentActionInvoker);
ctx.CurrentStatements.Add(assignResult);
}
}
public CodeMethodInvokeExpression(ILInstruction inline, CodeMethodReferenceExpression method, params CodeExpression[] parameters) : base(inline)
{
_method = method;
Parameters.AddRange(parameters);
}
public override bool AddEventHandler(EventDescription eventDescription, string objectName, string methodName)
{
const string Init = "__init__";
//This is not the most optimal solution for WPF since we will call FindLogicalNode for each event handler,
//but it simplifies the code generation for now.
CodeDomDocDataAdapter adapter = GetDocDataAdapterForPyFile();
//Find the __init__ method
CodeMemberMethod method = null;
foreach(CodeTypeMember ctMember in adapter.TypeDeclaration.Members)
{
if (ctMember is CodeConstructor)
{
if (ctMember.Name == Init)
{
method = ctMember as CodeMemberMethod;
break;
}
}
}
if (method == null)
{
method = new CodeConstructor();
method.Name = Init;
}
//Create a code statement which looks like: LogicalTreeHelper.FindLogicalNode(self.Root, "button1").Click += self.button1_Click
CodeTypeReferenceExpression logicalTreeHelper = new CodeTypeReferenceExpression("LogicalTreeHelper");
CodeMethodReferenceExpression findLogicalNodeMethod = new CodeMethodReferenceExpression(logicalTreeHelper, "FindLogicalNode");
CodeFieldReferenceExpression selfWindow = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Root");
CodeMethodInvokeExpression findLogicalNodeInvoke = new CodeMethodInvokeExpression( findLogicalNodeMethod, selfWindow, new CodeSnippetExpression("\'" + objectName + "\'"));
CodeDelegateCreateExpression createDelegateExpression = new CodeDelegateCreateExpression(new CodeTypeReference("System.EventHandler"), new CodeThisReferenceExpression(), methodName);
CodeAttachEventStatement attachEvent = new CodeAttachEventStatement(findLogicalNodeInvoke, eventDescription.Name, createDelegateExpression);
method.Statements.Add(attachEvent);
adapter.Generate();
return true;
}
public CodeMethodInvokeExpression(CodeMethodReferenceExpression method, CodeExpression[] parameters)
{
}