public static CodeExpressionCollection Clone(this CodeExpressionCollection collection) { if (collection == null) return null; CodeExpressionCollection c = new CodeExpressionCollection(); foreach (CodeExpression expression in collection) c.Add(expression.Clone()); return c; }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeBinaryOperatorExpression expression2 = (CodeBinaryOperatorExpression) expression; RuleBinaryExpressionInfo info = analysis.Validation.ExpressionInfo(expression2) as RuleBinaryExpressionInfo; if (info != null) { MethodInfo methodInfo = info.MethodInfo; if (methodInfo != null) { List<CodeExpression> attributedExprs = new List<CodeExpression>(); CodeExpressionCollection argExprs = new CodeExpressionCollection(); argExprs.Add(expression2.Left); argExprs.Add(expression2.Right); CodeExpression targetExpr = new CodeTypeReferenceExpression(methodInfo.DeclaringType); analysis.AnalyzeRuleAttributes(methodInfo, targetExpr, qualifier, argExprs, methodInfo.GetParameters(), attributedExprs); } } RuleExpressionWalker.AnalyzeUsage(analysis, expression2.Left, true, false, null); RuleExpressionWalker.AnalyzeUsage(analysis, expression2.Right, true, false, null); }
public void Constructor1_Deny_Unrestricted () { CodeExpressionCollection coll = new CodeExpressionCollection (array); coll.CopyTo (array, 0); Assert.AreEqual (1, coll.Add (ce), "Add"); Assert.AreSame (ce, coll[0], "this[int]"); coll.AddRange (array); coll.AddRange (coll); Assert.IsTrue (coll.Contains (ce), "Contains"); Assert.AreEqual (0, coll.IndexOf (ce), "IndexOf"); coll.Insert (0, ce); coll.Remove (ce); }
private static void AddTypes(string prepend, bool nested, CodeTypeDeclarationCollection types, CodeExpressionCollection into) { foreach (CodeTypeDeclaration t in types) { into.Add(new CodeTypeOfExpression( ((prepend == null || prepend == "") ? "" : (prepend + (nested ? "+" : "."))) + t.Name)); CodeTypeDeclarationCollection ctd = new CodeTypeDeclarationCollection(); foreach (CodeTypeMember m in t.Members) { if (m is CodeTypeDeclaration) ctd.Add((CodeTypeDeclaration)m); } AddTypes( ((prepend == null || prepend == "") ? "" : (prepend + (nested ? "+" : "."))) + t.Name, true, ctd, into); } }
public override void GenerateMethods(IDLInterface idlIntf) { if (idlIntf.Methods != null) // If got methods { bAddNamespace = idlIntf.Methods.Count > 0; foreach (IDLMethod idlMethod in idlIntf.Methods) { // Structs for capturing input/output from method. Udbus.Parsing.CodeTypeDeferredStructHolder paramsHolder = new Udbus.Parsing.CodeTypeDeferredStructHolder(idlMethod.Name + "AsyncParams"); Udbus.Parsing.CodeTypeDeferredStructHolder resultHolder = new Udbus.Parsing.CodeTypeDeferredStructHolder(idlMethod.Name + "AsyncResult"); CodeConstructor constructorResults = new CodeConstructor(); CodeConstructor constructorParams = new CodeConstructor(); constructorResults.Attributes = constructorParams.Attributes = MemberAttributes.Public; // Create Call method. CodeMemberMethod methodCall = new CodeMemberMethod(); methodCall.Name = "Call" + idlMethod.Name; // Actual call to proxy arguments will be added to as we parse IDL arguments. CodeExpressionCollection callParameters = new CodeExpressionCollection(); CodeExpressionCollection callResultArgs = new CodeExpressionCollection(); CodeExpressionCollection interfaceCallArgs = new CodeExpressionCollection(); CodeArgumentReferenceExpression argrefCallData = new CodeArgumentReferenceExpression(dataName); // Event Args string eventName = idlMethod.Name + "EventArgs"; CodeTypeDeclaration typeEvent = new CodeTypeDeclaration(eventName); typeEvent.IsClass = true; typeEvent.TypeAttributes = TypeAttributes.Public; typeEvent.BaseTypes.Add(new CodeTypeReference(typeof(AsyncCompletedEventArgs))); CodeConstructor constructorEventArgs = new CodeConstructor(); eventsDeclarationHolder.Add(typeEvent); CodeExpressionCollection makeEventArgs = new CodeExpressionCollection(); // Event Raiser... string raiserName = "raiser" + idlMethod.Name; CodeTypeReference raiserRef = new CodeTypeReference("AsyncOperationEventRaiser", new CodeTypeReference(eventName)); CodeMemberField fieldRaiser = new CodeMemberField(raiserRef, raiserName); fieldRaiser.InitExpression = new CodeObjectCreateExpression(raiserRef); fieldRaiser.Attributes = MemberAttributes.Private; typeProxy.Members.Add(fieldRaiser); // Event raiser EventCompleted Property - unfortunately CodeMemberEvent is useless here since can't add custom add/remove. // So anything other than CSharp is now a bust. Brilliant. CodeSnippetTypeMember eventRaiser = new CodeSnippetTypeMember(); eventRaiser.Text = string.Format(@" public event System.EventHandler<{0}> {1}Completed {{ add {{ this.{2}.CompletedEvent += value; }} remove {{ this.{2}.CompletedEvent -= value; }} }} ", eventName, idlMethod.Name, raiserName ); // Adding text here. //CodeMemberEvent eventRaiser = new CodeMemberEvent(); //eventRaiser.Attributes = MemberAttributes.Public; //CodeParamDeclaredType declaredType = new CodeParamDeclaredType(typeEvent); //eventRaiser.Type = new CodeTypeReference(CodeBuilderCommon.EventHandlerType.Name, declaredType.CodeType); //eventRaiser.Name = idlMethod.Name + "Completed"; typeProxy.Members.Add(eventRaiser); // Async method. CodeMemberMethod methodAsync = new CodeMemberMethod(); methodAsync.Name = idlMethod.Name + "Async"; methodAsync.Attributes = MemberAttributes.Public; // Straight-forward interface method. CodeMemberMethod methodInterface = new CodeMemberMethod(); methodInterface.Name = idlMethod.Name; methodInterface.Attributes = MemberAttributes.Public; // CodeComment commentMethod = new CodeComment(idlMethod.Name); // method.Comments.Add(new CodeCommentStatement(idlMethod.Name)); CodeExpressionCollection asyncArgs = new CodeExpressionCollection(); Udbus.Parsing.BuildContext context = new Udbus.Parsing.BuildContext(contextDeclarationHolder); foreach (IDLMethodArgument idlMethodArg in idlMethod.Arguments) { CodeCommentStatement commentMethod = new CodeCommentStatement(string.Format("{0} {1} \"{2}\"", idlMethodArg.Direction, idlMethodArg.Name, idlMethodArg.Type)); methodAsync.Comments.Add(commentMethod); methodInterface.Comments.Add(commentMethod); // Parse the type string for the argument, creating required structs as we go, and returning a type for the argument. Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new IDLMethodArgumentTypeNameBuilder(idlIntf, idlMethod); ParamCodeTypeFactory paramtypeHolder = new ParamCodeTypeFactory(CodeTypeFactory.Default, idlMethodArg.Direction == "out" ? FieldDirection.Out : FieldDirection.In); Udbus.Parsing.CodeBuilderHelper.BuildCodeParamType(paramtypeHolder, nameBuilder, idlMethodArg.Type, context); Udbus.Parsing.ICodeParamType paramtype = paramtypeHolder.paramtype; // Arguments. CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(paramtype.CodeType, idlMethodArg.Name); CodeVariableReferenceExpression varrefMethodArg = new CodeVariableReferenceExpression(idlMethodArg.Name); if (idlMethodArg.Direction == "out") // If out argument { // Add to interface parameters. interfaceCallArgs.Add(new CodeDirectionExpression(FieldDirection.Out, varrefMethodArg)); // Put into result holding struct... param.Direction = FieldDirection.Out; methodInterface.Parameters.Add(param); CodeTypeReference argType = CodeBuilderCommon.GetReadOnlyCodeReference(paramtypeHolder.paramtype.CodeType); CodeMemberField fieldResultArg = new CodeMemberField(argType, idlMethodArg.Name); fieldResultArg.Attributes = MemberAttributes.Public; resultHolder.CodeType.Members.Add(fieldResultArg); constructorResults.Parameters.Add(new CodeParameterDeclarationExpression(paramtype.CodeType, idlMethodArg.Name)); CodeFieldReferenceExpression thisArg = new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), idlMethodArg.Name ); constructorResults.Statements.Add(new CodeAssignStatement(thisArg, new CodeArgumentReferenceExpression(idlMethodArg.Name))); // Add placeholder variables to call method. methodCall.Statements.Add(new CodeVariableDeclarationStatement(paramtype.CodeType, idlMethodArg.Name)); // Add appropriate parameter in actual call to interface. callParameters.Add(new CodeDirectionExpression(FieldDirection.Out, varrefMethodArg)); // Add appropriate parameter in call to result constructor. callResultArgs.Add(new CodeArgumentReferenceExpression(idlMethodArg.Name)); // Put into event args class... string fieldEventArgName = idlMethodArg.Name + "_"; CodeMemberField fieldEventArg = new CodeMemberField(paramtype.CodeType, fieldEventArgName); fieldEventArg.Attributes = MemberAttributes.Private; typeEvent.Members.Add(fieldEventArg); // Add argument property to EventArgs. CodeMemberProperty propEventArg = new CodeMemberProperty(); propEventArg.Attributes = MemberAttributes.Public | MemberAttributes.Final; propEventArg.Name = idlMethodArg.Name; propEventArg.HasGet = true; propEventArg.Type = paramtype.CodeType; propEventArg.GetStatements.Add(new CodeMethodInvokeExpression(null, "RaiseExceptionIfNecessary")); propEventArg.GetStatements.Add(new CodeMethodReturnStatement(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), fieldEventArgName))); typeEvent.Members.Add(propEventArg); // Add constructor parameter and statement to EventArgs. constructorEventArgs.Parameters.Add(new CodeParameterDeclarationExpression(paramtype.CodeType, idlMethodArg.Name)); constructorEventArgs.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldEventArgName), new CodeArgumentReferenceExpression(idlMethodArg.Name) )); // Add as parameter in call to EventArgs constructor. makeEventArgs.Add(new CodeFieldReferenceExpression(new CodeArgumentReferenceExpression(resultName), idlMethodArg.Name)); } // Ends if out argument else // Else in argument { // Add to interface parameters. interfaceCallArgs.Add(varrefMethodArg); // Put into parameter holding struct. CodeMemberField fieldArg = new CodeMemberField(CodeBuilderCommon.GetReadOnlyCodeReference(paramtype.CodeType), idlMethodArg.Name); fieldArg.Attributes = MemberAttributes.Public; paramsHolder.CodeType.Members.Add(fieldArg); constructorParams.Parameters.Add(new CodeParameterDeclarationExpression(paramtype.CodeType, idlMethodArg.Name)); CodeFieldReferenceExpression thisArg = new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), idlMethodArg.Name ); constructorParams.Statements.Add(new CodeAssignStatement(thisArg, new CodeArgumentReferenceExpression(idlMethodArg.Name))); // Add appropriate parameter in actual call to interface. callParameters.Add(new CodeFieldReferenceExpression(argrefCallData, idlMethodArg.Name)); // Add appropriate parameter to async method parameters constructor call. asyncArgs.Add(new CodeArgumentReferenceExpression(idlMethodArg.Name)); // Add parameter to async method. methodAsync.Parameters.Add(param); // Add parameter to interface method. methodInterface.Parameters.Add(param); } // Ends else in argument } // Ends loop over method arguments methodAsync.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "userState")); // Add method body, then sort out arguments code... CodeFieldReferenceExpression thisRaiser = new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), raiserName ); CodeTypeReference typerefResult = null; if (idlMethod.Return != null) // If method has return type { // Add result to Result type. // TODO replace typeof(string) with actual return type. typerefResult = new CodeTypeReference("???"); } CodeTypeReference typerefResults = null; CodeTypeReference typerefParams = null; CodeExpression exprAsyncParamValue = null; string asyncMethodName = "AsyncFuncImpl"; // Default is assuming that function returns something. if (paramsHolder.QuType()) // If got params type { typerefParams = new CodeTypeReference(paramsHolder.CodeType.Name); // Add proxy field to params struct. CodeMemberField memberParamsProxy = new CodeMemberField(new CodeTypeReference("readonly " + genInterfaceName), proxyName); memberParamsProxy.Attributes = MemberAttributes.Public; paramsHolder.CodeType.Members.Insert(0, memberParamsProxy); // TODO: Going to need a using or a fully qualified name. // Add initialisation to constructor constructorParams.Parameters.Insert(0, paramProxy); // Constructor will take proxy as first argument. constructorParams.Statements.Insert(0, assignProxy); paramsHolder.CodeType.TypeAttributes = TypeAttributes.NestedPrivate; paramsHolder.CodeType.IsStruct = true; constructorParams.Attributes = MemberAttributes.Public; paramsHolder.CodeType.Members.Add(constructorParams); typeProxy.Members.Add(paramsHolder.CodeType); asyncArgs.Insert(0, thisProxyFieldRef); exprAsyncParamValue = new CodeObjectCreateExpression(typerefParams, asyncArgs.Cast<CodeExpression>().ToArray()); } // Ends if got params type if (resultHolder.QuType()) // If got results type { typerefResults = new CodeTypeReference(resultHolder.CodeType.Name); methodCall.ReturnType = typerefResults; // Setup call method parameters. if (idlMethod.Return != null) { // Add result field to EventArgs. CodeMemberField fieldResult = new CodeMemberField(typerefResult, resultName); fieldResult.Attributes = MemberAttributes.Private; typeEvent.Members.Insert(0, fieldResult); // Add result property to EventArgs. CodeMemberProperty propResult = new CodeMemberProperty(); propResult.Attributes = MemberAttributes.Public; propResult.Name = resultName; propResult.HasGet = true; propResult.Type = typerefResult; propResult.GetStatements.Add(new CodeMethodInvokeExpression(null, "RaiseExceptionIfNecessary")); propResult.GetStatements.Add(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), resultName)); typeEvent.Members.Add(propResult); // Add suitable parameter as first EventArgs constructor argument. constructorEventArgs.Parameters.Insert(0, new CodeParameterDeclarationExpression(typerefResult, resultName)); // Add statement to initialise result member. CodeFieldReferenceExpression thisArg = new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), resultName ); // Include result in parameters to EventArgs in MakeEventArgs statements. makeEventArgs.Insert(0, new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), resultName)); // Add result to Result type. CodeTypeReference typerefReadOnlyResult = CodeBuilderCommon.GetReadOnlyCodeReference(typerefResult); CodeMemberField fieldReadOnlyResult = new CodeMemberField(typerefReadOnlyResult, resultName); fieldResult.Attributes = MemberAttributes.Public; resultHolder.CodeType.Members.Insert(0, fieldReadOnlyResult); // Add suitable parameter as first constructor argument. constructorResults.Parameters.Insert(0, new CodeParameterDeclarationExpression(typerefResult, resultName)); // Add statement to initialise result member. constructorResults.Statements.Insert(0, new CodeAssignStatement(thisArg, new CodeArgumentReferenceExpression(resultName))); } // End if there is a return statement resultHolder.CodeType.TypeAttributes = TypeAttributes.NestedPrivate; resultHolder.CodeType.IsStruct = true; resultHolder.CodeType.Members.Add(constructorResults); typeProxy.Members.Add(resultHolder.CodeType); } // Ends if got results type else // Else no results type { // Absolutely no results (including out parameters) means it's an Action. asyncMethodName = "AsyncActionImpl"; } // Ends else no results type // Time to bite the bullet. CodeTypeReference typerefEvent = new CodeTypeReference(typeEvent.Name); CodeMemberMethod methodMakeEventArgs = new CodeMemberMethod(); methodMakeEventArgs.Name = "Make" + idlMethod.Name + "AsyncEventArgs"; // Add missing parameters to EventArgs... constructorEventArgs.Parameters.Add(CodeBuilderCommon.paramdeclException); constructorEventArgs.Parameters.Add(CodeBuilderCommon.paramdeclCancelled); constructorEventArgs.Parameters.Add(CodeBuilderCommon.paramdeclUserState); // Pass through to base class. constructorEventArgs.BaseConstructorArgs.Add(CodeBuilderCommon.argrefException); constructorEventArgs.BaseConstructorArgs.Add(CodeBuilderCommon.argrefCancelled); constructorEventArgs.BaseConstructorArgs.Add(CodeBuilderCommon.argrefUserState); // Add MakeEventArgs method... // Create MakeEventArgs method. methodMakeEventArgs.Attributes = MemberAttributes.Private | MemberAttributes.Static; if (typerefParams != null) // If got params type { methodMakeEventArgs.Parameters.Add(new CodeParameterDeclarationExpression(typerefParams, dataName)); } else // Else no params type { // The interface will be passed as the first parameter. methodMakeEventArgs.Parameters.Add(paramProxy); } // Ends else no params type if (typerefResults != null) // If got results type { methodMakeEventArgs.Parameters.Add(new CodeParameterDeclarationExpression(typerefResults, resultName)); } methodMakeEventArgs.Parameters.Add(CodeBuilderCommon.paramdeclException); methodMakeEventArgs.Parameters.Add(CodeBuilderCommon.paramdeclCancelled); methodMakeEventArgs.Parameters.Add(CodeBuilderCommon.paramdeclUserState); makeEventArgs.Add(CodeBuilderCommon.argrefException); makeEventArgs.Add(CodeBuilderCommon.argrefCancelled); makeEventArgs.Add(CodeBuilderCommon.argrefUserState); methodMakeEventArgs.Statements.Add(new CodeMethodReturnStatement( new CodeObjectCreateExpression( typerefEvent, makeEventArgs.Cast<CodeExpression>().ToArray() ) )); methodMakeEventArgs.ReturnType = typerefEvent; typeProxy.Members.Add(methodMakeEventArgs); // Setup call method parameters. methodCall.Attributes = MemberAttributes.Private | MemberAttributes.Static; CodeExpression exprProxyRef; //methodCall.ReturnType = new CodeTypeReference(resultHolder.CodeType.Name); if (typerefParams != null) // If passing parameters { methodCall.Parameters.Add(new CodeParameterDeclarationExpression(typerefParams, dataName)); exprProxyRef = new CodeFieldReferenceExpression(argrefCallData, proxyName); } // Ends if passing parameters else // Else just passing proxy { methodCall.Parameters.Add(new CodeParameterDeclarationExpression(genInterfaceName, proxyName)); exprProxyRef = new CodeArgumentReferenceExpression(proxyName); } // Ends else just passing proxy // Add call method body... // Invocation to proxy. CodeMethodReferenceExpression methodProxy = new CodeMethodReferenceExpression(exprProxyRef, idlMethod.Name); CodeMethodInvokeExpression invokeProxy = new CodeMethodInvokeExpression(methodProxy, callParameters.Cast<CodeExpression>().ToArray()); if (idlMethod.Return != null) // If got return type { // TODO - return values. // Add invocation of actual interface method and store result. CodeVariableDeclarationStatement exprResult = new CodeVariableDeclarationStatement(typerefResult, resultName, invokeProxy); methodCall.Statements.Add(exprResult); // Initialise result parameter in Result struct. callResultArgs.Insert(0, new CodeArgumentReferenceExpression(resultName)); } // Ends if got return type else // Else no return type { // Add invocation of actual interface method and ignore result. methodCall.Statements.Add(invokeProxy); } // Ends else no return type if (typerefResults != null) // If got result type { // Create Call return statement. CodeMethodReturnStatement retCall = new CodeMethodReturnStatement( new CodeObjectCreateExpression(typerefResults, callResultArgs.Cast<CodeExpression>().ToArray()) ); methodCall.Statements.Add(retCall); } // Ends if got result type // Add call method to type. typeProxy.Members.Add(methodCall); // Add async method implementation... if (exprAsyncParamValue == null) // If no params { // Just pass the proxy. exprAsyncParamValue = thisProxyFieldRef; } // Ends if no params methodAsync.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(thisRaiser, asyncMethodName) , new CodeArgumentReferenceExpression("userState") , exprAsyncParamValue , new CodeMethodReferenceExpression(null, methodCall.Name) , new CodeMethodReferenceExpression(null, methodMakeEventArgs.Name) )); methodInterface.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(thisProxyFieldRef, idlMethod.Name) , interfaceCallArgs.Cast<CodeExpression>().ToArray() )); // Finish up. typeEvent.Members.Add(constructorEventArgs); constructorEventArgs.Attributes = MemberAttributes.Public; ns.Types.Add(typeEvent); typeProxy.Members.Add(methodAsync); typeProxy.Members.Add(methodInterface); } // Ends loop over methods } // Ends if got methods }
private void AddParam(CodeExpressionCollection @params, Expression par) { try { object v = CodeDom.Eval(par); if (v == null && par != null) @params.Add(_Visit(par)); else @params.Add(GetFromPrimitive(v)); } catch (Exception) { @params.Add(_Visit(par)); } }
//public CodeExpressionCollection VisitExpressionList(System.Collections.ObjectModel.ReadOnlyCollection<Expression> original) public CodeExpressionCollection VisitExpressionList(IEnumerable<Expression> original) { CodeExpressionCollection list = new CodeExpressionCollection(); foreach (Expression e in original) { list.Add(_Visit(e)); } return list; }
private void GenerateEntityQueryMethod(DomainOperationEntry domainOperationEntry) { string queryMethodName = domainOperationEntry.Name + QuerySuffix; Type entityType = TypeUtility.GetElementType(domainOperationEntry.ReturnType); CodeMemberMethod queryMethod = new CodeMemberMethod(); queryMethod.Name = queryMethodName; queryMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final; // Final needed, else becomes virtual queryMethod.ReturnType = CodeGenUtilities.GetTypeReference(TypeConstants.EntityQueryTypeFullName, this._domainServiceDescription.DomainServiceType.Namespace, false); queryMethod.ReturnType.TypeArguments.Add(CodeGenUtilities.GetTypeReference(entityType.FullName, this._domainServiceDescription.DomainServiceType.Namespace, true)); DomainOperationParameter[] domainOperationEntryParameters = domainOperationEntry.Parameters.ToArray(); // Generate <summary> doc comment string comment = string.Format(CultureInfo.CurrentCulture, Resource.EntityCodeGen_ConstructorComments_Summary_DomainContext, entityType.Name, domainOperationEntry.Name); queryMethod.Comments.AddRange(CodeGenUtilities.GenerateSummaryCodeComment(comment, this.ClientProxyGenerator.IsCSharp)); // Generate <param> doc comments foreach (DomainOperationParameter paramInfo in domainOperationEntryParameters) { comment = string.Format(CultureInfo.CurrentCulture, Resource.CodeGen_Query_Method_Parameter_Comment, paramInfo.Name); queryMethod.Comments.AddRange(CodeGenUtilities.GenerateParamCodeComment(paramInfo.Name, comment, this.ClientProxyGenerator.IsCSharp)); } // Generate <returns> doc comments comment = string.Format(CultureInfo.CurrentCulture, Resource.CodeGen_Query_Method_Returns_Comment, domainOperationEntry.AssociatedType.Name); queryMethod.Comments.AddRange(CodeGenUtilities.GenerateReturnsCodeComment(comment, this.ClientProxyGenerator.IsCSharp)); // Propagate custom validation attributes IEnumerable<Attribute> methodAttributes = domainOperationEntry.Attributes.Cast<Attribute>(); CustomAttributeGenerator.GenerateCustomAttributes( this.ClientProxyGenerator, this._proxyClass, ex => string.Format(CultureInfo.CurrentCulture, Resource.ClientCodeGen_Attribute_ThrewException_CodeMethod, ex.Message, queryMethod.Name, this._proxyClass.Name, ex.InnerException.Message), methodAttributes, queryMethod.CustomAttributes, queryMethod.Comments); // add any domain operation entry parameters first CodeVariableReferenceExpression paramsRef = new CodeVariableReferenceExpression("parameters"); if (domainOperationEntryParameters.Length > 0) { // need to generate the user parameters dictionary CodeTypeReference dictionaryTypeReference = CodeGenUtilities.GetTypeReference( typeof(Dictionary<string, object>), this.ClientProxyGenerator, this._proxyClass); CodeVariableDeclarationStatement paramsDef = new CodeVariableDeclarationStatement( dictionaryTypeReference, "parameters", new CodeObjectCreateExpression(dictionaryTypeReference, new CodeExpression[0])); queryMethod.Statements.Add(paramsDef); } foreach (DomainOperationParameter paramInfo in domainOperationEntryParameters) { CodeParameterDeclarationExpression paramDecl = new CodeParameterDeclarationExpression( CodeGenUtilities.GetTypeReference( CodeGenUtilities.TranslateType(paramInfo.ParameterType), this.ClientProxyGenerator, this._proxyClass), paramInfo.Name); // Propagate parameter level validation attributes IEnumerable<Attribute> paramAttributes = paramInfo.Attributes.Cast<Attribute>(); string commentHeader = string.Format( CultureInfo.CurrentCulture, Resource.ClientCodeGen_Attribute_Parameter_FailedToGenerate, paramInfo.Name); CustomAttributeGenerator.GenerateCustomAttributes( this.ClientProxyGenerator, this._proxyClass, ex => string.Format(CultureInfo.CurrentCulture, Resource.ClientCodeGen_Attribute_ThrewException_CodeMethodParameter, ex.Message, paramDecl.Name, queryMethod.Name, this._proxyClass.Name, ex.InnerException.Message), paramAttributes, paramDecl.CustomAttributes, queryMethod.Comments, commentHeader); // add the parameter to the query method queryMethod.Parameters.Add(paramDecl); // add the parameter and value to the params dictionary queryMethod.Statements.Add(new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(paramsRef, "Add"), new CodePrimitiveExpression(paramInfo.Name), new CodeVariableReferenceExpression(paramInfo.Name))); } // add argument for queryName CodeExpressionCollection arguments = new CodeExpressionCollection(); arguments.Add(new CodePrimitiveExpression(domainOperationEntry.Name)); // add argument for parameters if (domainOperationEntryParameters.Length > 0) { arguments.Add(paramsRef); } else { arguments.Add(new CodePrimitiveExpression(null)); } // add argument for hasSideEffects QueryAttribute queryAttribute = (QueryAttribute)domainOperationEntry.OperationAttribute; arguments.Add(new CodePrimitiveExpression(queryAttribute.HasSideEffects)); // add argument for isComposable arguments.Add(new CodePrimitiveExpression(queryAttribute.IsComposable)); // this.ValidateMethod("methodName", parameters); CodeExpression paramsExpr = new CodePrimitiveExpression(null); if (domainOperationEntryParameters.Length > 0) { paramsExpr = paramsRef; } CodeExpressionStatement validateMethodCall = new CodeExpressionStatement( new CodeMethodInvokeExpression( new CodeThisReferenceExpression(), "ValidateMethod", new CodeExpression[] { new CodePrimitiveExpression(queryMethodName), paramsExpr })); queryMethod.Statements.Add(validateMethodCall); // ---------------------------------------------------------------- // method call: base.CreateQuery(arguments...) // ---------------------------------------------------------------- CodeTypeReference entityTypeRef = CodeGenUtilities.GetTypeReference(entityType.FullName, this._domainServiceDescription.DomainServiceType.Namespace, true); CodeMethodReferenceExpression createQueryMethod = new CodeMethodReferenceExpression(new CodeBaseReferenceExpression(), "CreateQuery", entityTypeRef); CodeMethodReturnStatement createQueryCall = new CodeMethodReturnStatement(new CodeMethodInvokeExpression(createQueryMethod, arguments.Cast<CodeExpression>().ToArray())); queryMethod.Statements.Add(createQueryCall); this._proxyClass.Members.Add(queryMethod); }
public void Remove () { CodeExpression ce1 = new CodeExpression (); CodeExpression ce2 = new CodeExpression (); CodeExpressionCollection coll = new CodeExpressionCollection (); coll.Add (ce1); coll.Add (ce2); Assert.AreEqual (2, coll.Count, "#1"); Assert.AreEqual (0, coll.IndexOf (ce1), "#2"); Assert.AreEqual (1, coll.IndexOf (ce2), "#3"); coll.Remove (ce1); Assert.AreEqual (1, coll.Count, "#4"); Assert.AreEqual (-1, coll.IndexOf (ce1), "#5"); Assert.AreEqual (0, coll.IndexOf (ce2), "#6"); }
private string WriteEventMulticaster(CodeNamespace ns) { string clsName = this.axctl + "EventMulticaster"; if (!this.ClassAlreadyExistsInNamespace(ns, clsName)) { CodeTypeDeclaration cls = new CodeTypeDeclaration { Name = clsName }; cls.BaseTypes.Add(this.axctlEvents); CodeAttributeDeclarationCollection declarations = new CodeAttributeDeclarationCollection(); CodeAttributeDeclaration declaration2 = new CodeAttributeDeclaration("System.Runtime.InteropServices.ClassInterface", new CodeAttributeArgument[] { new CodeAttributeArgument(new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(null, "System.Runtime.InteropServices.ClassInterfaceType"), "None")) }); declarations.Add(declaration2); cls.CustomAttributes = declarations; CodeMemberField field = new CodeMemberField(this.axctl, "parent") { Attributes = MemberAttributes.Private | MemberAttributes.Final }; cls.Members.Add(field); CodeConstructor constructor = new CodeConstructor { Attributes = MemberAttributes.Public }; constructor.Parameters.Add(this.CreateParamDecl(this.axctl, "parent", false)); CodeFieldReferenceExpression left = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "parent"); CodeFieldReferenceExpression right = new CodeFieldReferenceExpression(null, "parent"); constructor.Statements.Add(new CodeAssignStatement(left, right)); cls.Members.Add(constructor); MethodInfo[] methods = this.axctlEventsType.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); int num = 0; for (int i = 0; i < methods.Length; i++) { AxParameterData[] dataArray = AxParameterData.Convert(methods[i].GetParameters()); CodeMemberMethod method = new CodeMemberMethod { Name = methods[i].Name, Attributes = MemberAttributes.Public, ReturnType = new CodeTypeReference(MapTypeName(methods[i].ReturnType)) }; for (int j = 0; j < dataArray.Length; j++) { CodeParameterDeclarationExpression expression3 = this.CreateParamDecl(MapTypeName(dataArray[j].ParameterType), dataArray[j].Name, dataArray[j].IsOptional); expression3.Direction = dataArray[j].Direction; method.Parameters.Add(expression3); } CodeFieldReferenceExpression expression4 = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "parent"); if (!this.IsEventPresent(methods[i])) { EventEntry entry = (EventEntry) this.events[num++]; CodeExpressionCollection expressions = new CodeExpressionCollection(); expressions.Add(expression4); if (entry.eventCls.Equals("EventArgs")) { expressions.Add(new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(null, "EventArgs"), "Empty")); CodeExpression[] array = new CodeExpression[expressions.Count]; ((ICollection) expressions).CopyTo(array, 0); CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(expression4, entry.invokeMethodName, array); if (methods[i].ReturnType == typeof(void)) { method.Statements.Add(new CodeExpressionStatement(expression)); } else { method.Statements.Add(new CodeMethodReturnStatement(expression)); } } else { CodeObjectCreateExpression expression6 = new CodeObjectCreateExpression(entry.eventCls, new CodeExpression[0]); for (int k = 0; k < entry.parameters.Length; k++) { if (!entry.parameters[k].IsOut) { expression6.Parameters.Add(new CodeFieldReferenceExpression(null, entry.parameters[k].Name)); } } CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(entry.eventCls, entry.eventParam) { InitExpression = expression6 }; method.Statements.Add(statement); expressions.Add(new CodeFieldReferenceExpression(null, entry.eventParam)); CodeExpression[] expressionArray2 = new CodeExpression[expressions.Count]; ((ICollection) expressions).CopyTo(expressionArray2, 0); CodeMethodInvokeExpression expression7 = new CodeMethodInvokeExpression(expression4, entry.invokeMethodName, expressionArray2); if (methods[i].ReturnType == typeof(void)) { method.Statements.Add(new CodeExpressionStatement(expression7)); } else { CodeVariableDeclarationStatement statement2 = new CodeVariableDeclarationStatement(entry.retType, entry.invokeMethodName); method.Statements.Add(statement2); method.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(null, statement2.Name), expression7)); } for (int m = 0; m < dataArray.Length; m++) { if (dataArray[m].IsByRef) { method.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(null, dataArray[m].Name), new CodeFieldReferenceExpression(new CodeFieldReferenceExpression(null, statement.Name), dataArray[m].Name))); } } if (methods[i].ReturnType != typeof(void)) { method.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, entry.invokeMethodName))); } } } else { CodeExpressionCollection expressions2 = new CodeExpressionCollection(); for (int n = 0; n < dataArray.Length; n++) { expressions2.Add(new CodeFieldReferenceExpression(null, dataArray[n].Name)); } CodeExpression[] expressionArray3 = new CodeExpression[expressions2.Count]; ((ICollection) expressions2).CopyTo(expressionArray3, 0); CodeMethodInvokeExpression expression8 = new CodeMethodInvokeExpression(expression4, "RaiseOn" + methods[i].Name, expressionArray3); if (methods[i].ReturnType == typeof(void)) { method.Statements.Add(new CodeExpressionStatement(expression8)); } else { method.Statements.Add(new CodeMethodReturnStatement(expression8)); } } cls.Members.Add(method); } this.AddClassToNamespace(ns, cls); } return clsName; }
/// <summary> /// Generates code for the specified assignment statement. /// </summary> /// <remarks><c>LEFT = RIGHT</c> or <c>LEFT.TARGET->set_Item(LEFT.INDICES, RIGHT)</c></remarks> protected override void GenerateAssignStatement(CodeAssignStatement e) { // indexer "set" hack CodeIndexerExpression indexer_exp = e.Left as CodeIndexerExpression; if (indexer_exp != null) { CodeExpressionCollection setter_args = new CodeExpressionCollection(); foreach (CodeExpression exp in indexer_exp.Indices) setter_args.Add(exp); setter_args.Add(e.Right); OutputInvocation(new CodeMethodReferenceExpression(indexer_exp.TargetObject, SpecialWords.IndexerSet), setter_args); } else { GenerateExpression(e.Left); Output.Write(WhiteSpace.Space + Tokens.Assignment + WhiteSpace.Space); GenerateExpression(e.Right); } Output.WriteLine(Tokens.Semicolon); }
private void BuildParameters(CodeStatementCollection statements, MethodInfo method, object[] paramValues, CodeExpressionCollection parameters) { ParameterInfo[] infoArray1 = method.GetParameters(); for (int num1 = 0; num1 < infoArray1.Length; num1++) { ParameterInfo info1 = infoArray1[num1]; Type type1 = infoArray1[num1].ParameterType; FieldDirection direction1 = FieldDirection.In; if (type1.IsByRef) { direction1 = FieldDirection.Ref; type1 = type1.GetElementType(); } CodeExpression expression1 = null; if (!info1.IsOut) { expression1 = BuildObject(statements, info1.Name, paramValues[num1]); } else { direction1 = FieldDirection.Out; } if (direction1 != FieldDirection.In) { if ((expression1 == null) || !(expression1 is CodeVariableReferenceExpression)) { CodeVariableDeclarationStatement statement1 = new CodeVariableDeclarationStatement(type1.FullName, info1.Name); if (expression1 != null) { statement1.InitExpression = expression1; } statements.Add(statement1); expression1 = new CodeVariableReferenceExpression(statement1.Name); } expression1 = new CodeDirectionExpression(direction1, expression1); } parameters.Add(expression1); } }
private void GenerateMethod(IDLInterface idlIntf, IDLMethod idlMethod , Udbus.Parsing.ICodeTypeDeclarationHolder contextDeclarationHolder , CodeTypeReference typerefDbusInterface , CodeTypeReference typerefDbusMarshal , CodeTypeDeclaration typeProxy) { // Straight-forward interface method. CodeMemberMethod methodInterface = new CodeMemberMethod(); CodeExpressionCollection interfaceCallArgs = new CodeExpressionCollection(); methodInterface.Name = idlMethod.Name; methodInterface.Attributes = MemberAttributes.Public; Udbus.Parsing.BuildContext context = new Udbus.Parsing.BuildContext(contextDeclarationHolder); #region Methods args foreach (IDLMethodArgument idlMethodArg in idlMethod.Arguments) { CodeCommentStatement commentMethod = new CodeCommentStatement(string.Format("{0} {1} \"{2}\"", idlMethodArg.Direction, idlMethodArg.Name, idlMethodArg.Type)); methodInterface.Comments.Add(commentMethod); // Parse the type string for the argument, creating required structs as we go, and returning a type for the argument. Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new IDLMethodArgumentTypeNameBuilder(idlIntf, idlMethod); ParamCodeTypeFactory paramtypeHolder = new ParamCodeTypeFactory(CodeTypeFactory.Default, idlMethodArg.Direction == "out" ? FieldDirection.Out : FieldDirection.In); Udbus.Parsing.CodeBuilderHelper.BuildCodeParamType(paramtypeHolder, nameBuilder, idlMethodArg.Type, context); Udbus.Parsing.ICodeParamType paramtype = paramtypeHolder.paramtype; // Arguments. CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(paramtype.CodeType, idlMethodArg.Name); CodeVariableReferenceExpression varrefMethodArg = new CodeVariableReferenceExpression(idlMethodArg.Name); if (idlMethodArg.Direction == "out") { // Add to interface parameters. interfaceCallArgs.Add(new CodeDirectionExpression(FieldDirection.Out, varrefMethodArg)); // Add parameter to interface method. param.Direction = FieldDirection.Out; } else { interfaceCallArgs.Add(varrefMethodArg); } methodInterface.Parameters.Add(param); } // Ends loop over method arguments #endregion methodInterface.Statements.Add(this.DeclareTargetVariable(typerefDbusInterface, typerefDbusMarshal)); methodInterface.Statements.Add(new CodeMethodInvokeExpression(varrefTarget, idlMethod.Name, interfaceCallArgs.Cast<CodeExpression>().ToArray())); //methodInterface.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(thisProxyFieldRef, idlMethod.Name) // , interfaceCallArgs.Cast<CodeExpression>().ToArray() //)); // Finish up. typeProxy.Members.Add(methodInterface); }
internal void AddDeclaredParameters(CodeTypeDeclaration classDeclaration, IMethod method, CodeMemberMethod member, CodeExpressionCollection constructorParameters, bool addOptionalParameters) { if (method.Parameters == null) { return; } // Add all parameters to the method. foreach (var param in method.GetAllParametersSorted()) { if (!addOptionalParameters && !param.IsRequired) { continue; } // Generate a safe parameter name which was not yet used. // Also exclude method name as VB can not have parameterName the same as method name. string parameterName = GeneratorUtils.GetParameterName( param, method.Parameters.Keys.Without(param.Name).Concat(method.Name)); // Declare the parameter, and add it to the list of constructor parameters of the request class. member.Parameters.Add(DeclareInputParameter(classDeclaration, param, method)); constructorParameters.Add(new CodeVariableReferenceExpression(parameterName)); AddParameterComment(commentCreator, member, param, parameterName); } }
public CodeMemberMethod CreateMethod(CodeTypeDeclaration classDeclaration, IResource resource, IMethod method, bool addOptionalParameters, MethodType methodType) { // Create a new method and make it public. var member = new CodeMemberMethod(); member.Name = GeneratorUtils.GetMethodName(method, resource.Methods.Keys.Without(method.Name)); member.Attributes = MemberAttributes.Public; if (commentCreator != null) { member.Comments.AddRange(commentCreator.CreateMethodComment(method)); } // Check if this method has a body. CodeExpressionCollection constructorParameters = new CodeExpressionCollection(); constructorParameters.Add(new CodeVariableReferenceExpression(ServiceFieldName)); if (method.HasBody) { // If so, add a body parameter. ResourceCallAddBodyDeclaration(method, member, GetBodyType(method), false); } // If a body parameter or similar parameters were added, also add them to the constructor. foreach (CodeParameterDeclarationExpression existingParameter in member.Parameters) { constructorParameters.Add(new CodeVariableReferenceExpression(existingParameter.Name)); } // Add all request parameters to this method. AddDeclaredParameters( classDeclaration, method, member, constructorParameters, addOptionalParameters); string requestClassNamingScheme = RequestClassGenerator.RequestClassNamingScheme; // If this is the media-upload convenience method, add the stream and content-type // parameters. if (methodType == MethodType.Media) { member.Parameters.Add(new CodeParameterDeclarationExpression( typeof(System.IO.Stream), StreamParameterName)); member.Parameters.Add(new CodeParameterDeclarationExpression( typeof(System.String), ContentTypeParameterName)); constructorParameters.Add(new CodeVariableReferenceExpression(StreamParameterName)); constructorParameters.Add(new CodeVariableReferenceExpression(ContentTypeParameterName)); requestClassNamingScheme = RequestClassGenerator.MediaUploadClassNamingScheme; } // new ...Request(paramOne, paramTwo, paramThree) // TODO(mlinder): add method signature collision checking here. CodeTypeReference requestType = new CodeTypeReference( RequestClassGenerator.GetProposedName( method, requestClassNamingScheme)); member.ReturnType = requestType; var newRequest = new CodeObjectCreateExpression(requestType); newRequest.Parameters.AddRange(constructorParameters); // return ...; var returnStatment = new CodeMethodReturnStatement(newRequest); member.Statements.Add(returnStatment); return member; }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeBinaryOperatorExpression binaryExpr = (CodeBinaryOperatorExpression)expression; // Get the method info from the validation so we can look for [RuleRead] and [RuleWrite] attributes. RuleBinaryExpressionInfo expressionInfo = analysis.Validation.ExpressionInfo(binaryExpr) as RuleBinaryExpressionInfo; if (expressionInfo != null) { // we may be calling a method, not a default operator MethodInfo method = expressionInfo.MethodInfo; if (method != null) { List<CodeExpression> attributedExprs = new List<CodeExpression>(); CodeExpressionCollection arguments = new CodeExpressionCollection(); arguments.Add(binaryExpr.Left); arguments.Add(binaryExpr.Right); CodeExpression targetObject = new CodeTypeReferenceExpression(method.DeclaringType); analysis.AnalyzeRuleAttributes(method, targetObject, qualifier, arguments, method.GetParameters(), attributedExprs); } } // Analyze the left & right children. RuleExpressionWalker.AnalyzeUsage(analysis, binaryExpr.Left, true, false, null); RuleExpressionWalker.AnalyzeUsage(analysis, binaryExpr.Right, true, false, null); }
protected void CreateRegistrationParameters(CodeExpressionCollection methodParameters, XmlNodeList scriptParameters) { CodeExpression[] initializers = new CodeExpression[scriptParameters.Count]; for (int i = 0; i < scriptParameters.Count; i++) { XmlElement element = scriptParameters.Item(i) as XmlElement; if (PARAMETER.Equals(element.Name)) { string key = element.GetAttribute(KEY); if (key != string.Empty) { initializers[i] = new CodeObjectCreateExpression( typeof (ComponentParameter), new CodeExpression[] {new CodePrimitiveExpression(key)}); } else if (element.InnerText != string.Empty) { initializers[i] = new CodeObjectCreateExpression( typeof (ConstantParameter), new CodeExpression[] {new CodeSnippetExpression(element.InnerText)}); } else { throw new PicoCompositionException("Parameter not set"); } } } methodParameters.Add(new CodeArrayCreateExpression( "IParameter", initializers)); }
public void Constructor2 () { CodeExpression exp1 = new CodeExpression (); CodeExpression exp2 = new CodeExpression (); CodeExpressionCollection c = new CodeExpressionCollection (); c.Add (exp1); c.Add (exp2); CodeExpressionCollection coll = new CodeExpressionCollection (c); Assert.AreEqual (2, coll.Count, "#1"); Assert.AreEqual (0, coll.IndexOf (exp1), "#2"); Assert.AreEqual (1, coll.IndexOf (exp2), "#3"); }
private void BuildParameters(CodeStatementCollection statements, MethodInfo method, object[] paramValues, CodeExpressionCollection parameters) { ParameterInfo[] infoArray = method.GetParameters(); for (int i = 0; i < infoArray.Length; i++) { ParameterInfo info = infoArray[i]; Type parameterType = infoArray[i].ParameterType; FieldDirection @in = FieldDirection.In; if (parameterType.IsByRef) { @in = FieldDirection.Ref; parameterType = parameterType.GetElementType(); } CodeExpression expression = null; if (!info.IsOut) { expression = this.BuildObject(statements, info.Name, paramValues[i]); } else { @in = FieldDirection.Out; } if (@in != FieldDirection.In) { if ((expression == null) || !(expression is CodeVariableReferenceExpression)) { CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(parameterType.FullName, info.Name); if (expression != null) { statement.InitExpression = expression; } statements.Add(statement); expression = new CodeVariableReferenceExpression(statement.Name); } expression = new CodeDirectionExpression(@in, expression); } parameters.Add(expression); } }
public static void GetCreateValueExpression( object value, ClrSimpleTypeInfo typeDef, CodeExpressionCollection collection) { if (value == null) { collection.Add(new CodePrimitiveExpression(value)); return; } switch(typeDef.Variety) { case XmlSchemaDatatypeVariety.List: string str = ListSimpleTypeValidator.ToString(value); collection.Add(new CodePrimitiveExpression(str)); break; case XmlSchemaDatatypeVariety.Atomic: if (value is string) { collection.Add(new CodePrimitiveExpression(value)); } else { collection.Add(CreateTypedValueExpression( typeDef.InnerType.Datatype, value)); } break; case XmlSchemaDatatypeVariety.Union: GetCreateUnionValueExpression( value, typeDef as UnionSimpleTypeInfo, collection); break; default: break; } }
public void AddRange () { CodeExpression exp1 = new CodeExpression (); CodeExpression exp2 = new CodeExpression (); CodeExpression exp3 = new CodeExpression (); CodeExpressionCollection coll1 = new CodeExpressionCollection (); coll1.Add (exp1); coll1.Add (exp2); CodeExpressionCollection coll2 = new CodeExpressionCollection (); coll2.Add (exp3); coll2.AddRange (coll1); Assert.AreEqual (3, coll2.Count, "#1"); Assert.AreEqual (1, coll2.IndexOf (exp1), "#2"); Assert.AreEqual (2, coll2.IndexOf (exp2), "#3"); Assert.AreEqual (0, coll2.IndexOf (exp3), "#4"); CodeExpressionCollection coll3 = new CodeExpressionCollection (); coll3.Add (exp3); coll3.AddRange (new CodeExpression[] { exp1, exp2 }); Assert.AreEqual (3, coll2.Count, "#5"); Assert.AreEqual (1, coll2.IndexOf (exp1), "#6"); Assert.AreEqual (2, coll2.IndexOf (exp2), "#7"); Assert.AreEqual (0, coll2.IndexOf (exp3), "#8"); }
private void WriteEvents(CodeNamespace ns, CodeTypeDeclaration cls) { for (int i = 0; (this.events != null) && (i < this.events.Count); i++) { EventEntry entry = (EventEntry) this.events[i]; CodeMemberEvent event2 = new CodeMemberEvent { Name = entry.resovledEventName, Attributes = entry.eventFlags, Type = new CodeTypeReference(entry.eventHandlerCls) }; cls.Members.Add(event2); CodeMemberMethod method = new CodeMemberMethod { Name = entry.invokeMethodName, ReturnType = new CodeTypeReference(entry.retType), Attributes = MemberAttributes.Assembly | MemberAttributes.Final }; method.Parameters.Add(this.CreateParamDecl(MapTypeName(typeof(object)), "sender", false)); method.Parameters.Add(this.CreateParamDecl(entry.eventCls, "e", false)); CodeFieldReferenceExpression left = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), entry.resovledEventName); CodeBinaryOperatorExpression expression2 = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)); CodeConditionStatement statement = new CodeConditionStatement { Condition = expression2 }; CodeExpressionCollection expressions = new CodeExpressionCollection(); expressions.Add(new CodeFieldReferenceExpression(null, "sender")); expressions.Add(new CodeFieldReferenceExpression(null, "e")); CodeExpression[] array = new CodeExpression[expressions.Count]; ((ICollection) expressions).CopyTo(array, 0); CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), entry.resovledEventName, array); if (entry.retType == typeof(void)) { statement.TrueStatements.Add(new CodeExpressionStatement(expression)); } else { statement.TrueStatements.Add(new CodeMethodReturnStatement(expression)); statement.FalseStatements.Add(new CodeMethodReturnStatement(this.GetInitializer(entry.retType))); } method.Statements.Add(statement); cls.Members.Add(method); } this.WriteEventMulticaster(ns); }
private void SerializeResumeLayout(IDesignerSerializationManager manager, CodeStatementCollection statements, object control) { CodeExpressionCollection parameters = new CodeExpressionCollection(); parameters.Add(new CodePrimitiveExpression(false)); System.Type[] paramTypes = new System.Type[] { typeof(bool) }; this.SerializeMethodInvocation(manager, statements, control, "ResumeLayout", parameters, paramTypes, StatementOrdering.Append); }
public void Insert () { CodeExpression exp1 = new CodeExpression (); CodeExpression exp2 = new CodeExpression (); CodeExpressionCollection coll = new CodeExpressionCollection (); coll.Add (exp1); Assert.AreEqual (1, coll.Count, "#1"); Assert.AreEqual (0, coll.IndexOf (exp1), "#2"); coll.Insert (0, exp2); Assert.AreEqual (2, coll.Count, "#3"); Assert.AreEqual (1, coll.IndexOf (exp1), "#4"); Assert.AreEqual (0, coll.IndexOf (exp2), "#5"); }
public void AddRange_Self () { CodeExpressionCollection coll = new CodeExpressionCollection (); coll.Add (new CodeExpression ()); Assert.AreEqual (1, coll.Count, "#1"); coll.AddRange (coll); Assert.AreEqual (2, coll.Count, "#2"); }
private void CreateRegistrationParameters(CodeExpressionCollection methodParameters, XmlNodeList scriptParameters) { CodeExpression[] initializers = new CodeExpression[scriptParameters.Count]; for (int i = 0; i < scriptParameters.Count; i++) { if (scriptParameters.Item(i) is XmlElement) { XmlElement element = (XmlElement) scriptParameters.Item(i); if (PARAMETER.Equals(element.Name)) { string key = element.GetAttribute(KEY); if (key != null && key.Length != 0) { initializers[i] = new CodeObjectCreateExpression( typeof (ComponentParameter), new CodeExpression[] {new CodePrimitiveExpression(key)}); } else if (element.Value != null && element.Value.Length != 0) { initializers[i] = new CodeObjectCreateExpression( typeof (ConstantParameter), new CodeExpression[] {new CodeTypeOfExpression(element.Value)}); } else { throw new PicoCompositionException("Parameter not set"); } } } } methodParameters.Add(new CodeArrayCreateExpression( "IParameter", initializers)); }
/// <summary>Converts a list of expressions to CodeDom expressions.</summary> void ConvertExpressions(CodeExpressionCollection args, ExpressionCollection expressions) { foreach (Expression e in expressions) { _expression = null; e.Accept(this); args.Add(_expression); } }
protected void Rewrite(CodeExpressionCollection target, CodeExpressionCollection source, ref bool didRewrite) { foreach (CodeExpression item in source) { target.Add(this.Rewrite(item, ref didRewrite)); } }
public void Add_Null () { CodeExpressionCollection coll = new CodeExpressionCollection (); coll.Add ((CodeExpression) null); }