public void Constructor0 () { CodeParameterDeclarationExpression cpde = new CodeParameterDeclarationExpression (); Assert.IsNotNull (cpde.CustomAttributes, "#1"); Assert.AreEqual (0, cpde.CustomAttributes.Count, "#2"); Assert.AreEqual (FieldDirection.In, cpde.Direction, "#3"); Assert.IsNotNull (cpde.Name, "#4"); Assert.AreEqual (string.Empty, cpde.Name, "#5"); Assert.IsNotNull (cpde.Type, "#6"); Assert.AreEqual (typeof (void).FullName, cpde.Type.BaseType, "#7"); cpde.Direction = FieldDirection.Out; Assert.AreEqual (FieldDirection.Out, cpde.Direction, "#8"); string name = "mono"; cpde.Name = name; Assert.AreSame (name, cpde.Name, "#9"); cpde.Name = null; Assert.IsNotNull (cpde.Name, "#10"); Assert.AreEqual (string.Empty, cpde.Name, "#11"); CodeTypeReference type = new CodeTypeReference ("mono"); cpde.Type = type; Assert.AreSame (type, cpde.Type, "#12"); cpde.Type = null; Assert.IsNotNull (cpde.Type, "#13"); Assert.AreEqual (typeof (void).FullName, cpde.Type.BaseType, "#14"); }
// Builds a codedom delegate expression and attaches it to the given codedom namespace. public static void Emit(CodeNamespace codeNamespace, DelegateDeclaration del) { // Create the codedom delegate and attach it to the namespace. var codeDelegate = new CodeTypeDelegate(); codeNamespace.Types.Add(codeDelegate); // Assign the name of the delegate codeDelegate.Name = del.Name; // Set the type of the delegate: make sure to check for null if (del.ReturnTypeName == "void") codeDelegate.ReturnType = null; else codeDelegate.ReturnType = new CodeTypeReference(del.ReturnTypeName); // Translate the accessibililty of the delegate MemberAttributes attributes = MemberAttributes.Public; switch(del.Accessibility) { case Accessibility.Public: attributes = MemberAttributes.Public; break; case Accessibility.Protected: attributes = MemberAttributes.Family; break; case Accessibility.Private: attributes = MemberAttributes.Private; break; case Accessibility.Internal: attributes = MemberAttributes.FamilyAndAssembly; break; } // Shared = static if (del.IsShared) attributes |= MemberAttributes.Static; codeDelegate.Attributes = attributes; // Translate the parameters of the delegate. foreach (Expression p in del.Parameters) { if (p is SimpleParameter) // ex "int i" codeDelegate.Parameters.Add(new CodeParameterDeclarationExpression((p as SimpleParameter).TypeName, (p as SimpleParameter).Name)); if (p is DirectionedParameter) // ex "ref int t" { var codeParameter = new CodeParameterDeclarationExpression((p as DirectionedParameter).TypeName, (p as DirectionedParameter).Name); switch ((p as DirectionedParameter).Direction) { case ParameterDirection.Out: codeParameter.Direction = FieldDirection.Out; break; case ParameterDirection.Ref: codeParameter.Direction = FieldDirection.Ref; break; } codeDelegate.Parameters.Add(codeParameter); } } }
public override void DeclareCodeType(IDLInterface idlIntf) { // Proxy class. typeProxy = new CodeTypeDeclaration(name + "Proxy"); typeProxy.IsClass = true; typeProxy.TypeAttributes = TypeAttributes.Public; eventsDeclarationHolder = new CodeTypeDeferredNamespaceDeclarationHolderEvents(idlIntf); typeProxy.BaseTypes.Add(genInterfaceName); // Interface field. CodeMemberField memberProxy = new CodeMemberField(genInterfaceName, proxyName); memberProxy.Attributes = MemberAttributes.Private; typeProxy.Members.Add(memberProxy); // TODO: Going to need a using or a fully qualified name. // Constructor. CodeConstructor constructor = new CodeConstructor(); constructor.Attributes = MemberAttributes.Public; // TODO - use the actual interface type rather than a string. paramProxy = new CodeParameterDeclarationExpression(genInterfaceName, proxyName); constructor.Parameters.Add(paramProxy); thisProxyFieldRef = new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), proxyName ); assignProxy = new CodeAssignStatement(thisProxyFieldRef, new CodeArgumentReferenceExpression(proxyName)); constructor.Statements.Add(assignProxy); typeProxy.Members.Add(constructor); declarationHolder = new CodeTypeIgnoredNamespaceDeclarationHolderParams(idlIntf); contextDeclarationHolder = declarationHolder; bAddNamespace = false; }
internal BindingElementExtensionSectionGenerator(Type bindingElementType, Assembly userAssembly, CodeDomProvider provider) { this.bindingElementType = bindingElementType; this.userAssembly = userAssembly; this.provider = provider; string typePrefix = bindingElementType.Name.Substring(0, bindingElementType.Name.IndexOf(TypeNameConstants.BindingElement)); this.generatedClassName = typePrefix + Constants.ElementSuffix; this.constantsClassName = bindingElementType.Name.Substring(0, bindingElementType.Name.IndexOf(TypeNameConstants.BindingElement)) + Constants.ConfigurationStrings; this.defaultValuesClassName = bindingElementType.Name.Substring(0, bindingElementType.Name.IndexOf(TypeNameConstants.BindingElement)) + Constants.Defaults; this.customBEVarInstance = Helpers.TurnFirstCharLower(bindingElementType.Name); customBEArgRef = new CodeArgumentReferenceExpression(customBEVarInstance); this.customBETypeRef = new CodeTypeReference(bindingElementType.Name); this.customBETypeOfRef = new CodeTypeOfExpression(customBETypeRef); this.customBENewVarAssignRef = new CodeVariableDeclarationStatement( customBETypeRef, customBEVarInstance, new CodeObjectCreateExpression(customBETypeRef)); this.bindingElementMethodParamRef = new CodeParameterDeclarationExpression( CodeDomHelperObjects.bindingElementTypeRef, Constants.bindingElementParamName); }
internal CodeConstructor CreateRequiredConstructor(CodeTypeDeclaration resourceClass, IMethod request, bool addOptionalParameters) { var constructor = new CodeConstructor(); constructor.Attributes = MemberAttributes.Public; // IRequestProvider service var serviceArg = new CodeParameterDeclarationExpression(typeof(IRequestProvider), ServiceName); constructor.Parameters.Add(serviceArg); // : base(service, "path", "HTTPMETHOD") constructor.BaseConstructorArgs.Add( new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(ServiceName), BaseUriName)); constructor.BaseConstructorArgs.Add(new CodePrimitiveExpression(request.MediaUpload.Simple.Path)); constructor.BaseConstructorArgs.Add(new CodePrimitiveExpression(request.HttpMethod)); // Add all required arguments to the constructor. AddBodyParameter(constructor, request); // Add common upload arguements. constructor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(StreamParameterName)); constructor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(ContentTypeParameterName)); AddAuthorizationAssignment(constructor); AddRequestParameters(resourceClass, request, constructor, addOptionalParameters); constructor.Parameters.Add(new CodeParameterDeclarationExpression( new CodeTypeReference(typeof(System.IO.Stream)), StreamParameterName)); constructor.Parameters.Add(new CodeParameterDeclarationExpression( new CodeTypeReference(typeof(System.String)), ContentTypeParameterName)); return constructor; }
public void Visit(ProcedureDefinition statement) { var argList = new List<CodeParameterDeclarationExpression>(); foreach (var arg in statement.Args) { var variableType = TablePrimitive.FromString(arg.Type).Type; var codeParam = new CodeParameterDeclarationExpression(variableType, arg.Variable); Scope.Current.RegisterPrimitive(codeParam.Name, variableType, codeParam.Type); Scope.Current.Type.Type.Members.Add(new CodeMemberField() { Name = codeParam.Name, Type = codeParam.Type, Attributes = MemberAttributes.Public | MemberAttributes.Final }); var assignment = new CodeAssignStatement(new CodeVariableReferenceExpression("_" + Scope.Current.ScopeIdentifier + "." + codeParam.Name), new CodeVariableReferenceExpression(codeParam.Name)); _mainType.Constructor.Statements.Add(assignment); argList.Add(codeParam); } _mainType.Type.Name = statement.Name; _mainType.Constructor.Parameters.Clear(); _mainType.Constructor.BaseConstructorArgs.Clear(); _mainType.Constructor.Parameters.AddRange(argList.ToArray()); _mainType.Constructor.BaseConstructorArgs.Add(new CodeArrayCreateExpression(new CodeTypeReference(typeof(string[])), 0)); //visit block var blockArgs = VisitChild(statement.Block); _codeStack.Peek().ParentStatements.AddRange(blockArgs.ParentStatements); }
// Generates a codedom constructor expression and attaches it to the given type. public static void Emit(CodeTypeDeclaration codeTypeDeclaration, Constructor ctor) { // Create the codedom constructor var codeCtor = new CodeConstructor(); codeTypeDeclaration.Members.Add(codeCtor); // Translate accessibility of the constructor MemberAttributes memberAttributes = MemberAttributes.Public; switch (ctor.Accessibility) { case Accessibility.Internal: memberAttributes |= MemberAttributes.FamilyAndAssembly; break; case Accessibility.Private: memberAttributes |= MemberAttributes.Private; break; case Accessibility.Protected: memberAttributes |= MemberAttributes.Family; break; case Accessibility.Public: memberAttributes |= MemberAttributes.Public; break; } codeCtor.Attributes = memberAttributes; // Translate the parameters of the constructor foreach (Expression p in ctor.Parameters) { if (p is SimpleParameter) // ex "int i" codeCtor.Parameters.Add(new CodeParameterDeclarationExpression((p as SimpleParameter).TypeName, (p as SimpleParameter).Name)); if (p is DirectionedParameter) // ex "ref int i" { var codeParameter = new CodeParameterDeclarationExpression((p as DirectionedParameter).TypeName, (p as DirectionedParameter).Name); switch ((p as DirectionedParameter).Direction) { case ParameterDirection.Out: codeParameter.Direction = FieldDirection.Out; break; case ParameterDirection.Ref: codeParameter.Direction = FieldDirection.Ref; break; } codeCtor.Parameters.Add(codeParameter); } } // Add call to a constructor of the base class or another in the same class. foreach (var a in ctor.SubParameters.ChildExpressions) { if (ctor.Sub) codeCtor.ChainedConstructorArgs.Add(CodeDomEmitter.EmitCodeExpression(a)); else codeCtor.BaseConstructorArgs.Add(CodeDomEmitter.EmitCodeExpression(a)); } // Add all the statements in the body of the constructor foreach (var e in ctor.ChildExpressions) codeCtor.Statements.Add(CodeDomEmitter.EmitCodeStatement(e)); }
/// <devdoc> /// <para>Copies the elements of an array to the end of the <see cref='System.CodeDom.CodeParameterDeclarationExpressionCollection'/>.</para> /// </devdoc> public void AddRange(CodeParameterDeclarationExpression[] value) { if (value == null) { throw new ArgumentNullException("value"); } for (int i = 0; ((i) < (value.Length)); i = ((i) + (1))) { this.Add(value[i]); } }
private static CodeParameterDeclarationExpression GetParameterExpression(ParameterInfo parameter) { var p = new CodeParameterDeclarationExpression(); p.Name = parameter.Name; p.Type = new CodeTypeReference(parameter.ParameterType); return p; }
public void Constructor1_NullItem () { CodeParameterDeclarationExpression[] parameters = new CodeParameterDeclarationExpression[] { new CodeParameterDeclarationExpression (), null }; CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection ( parameters); }
CodeMemberMethod LocalMethod(string name) { var method = new CodeMemberMethod { Name = name, ReturnType = new CodeTypeReference(typeof(object)) }; var param = new CodeParameterDeclarationExpression(typeof(object[]), args); param.UserData.Add(Parser.RawData, typeof(object[])); method.Parameters.Add(param); return method; }
internal DesignTimeParameterInfo(CodeParameterDeclarationExpression codeParameter, int position, MemberInfo member) { this.MemberImpl = member; this.NameImpl = Helper.EnsureTypeName(codeParameter.Name); this.codeParameterType = codeParameter.Type; this.AttrsImpl = Helper.ConvertToParameterAttributes(codeParameter.Direction); this.isRef = (codeParameter.Direction == FieldDirection.Ref); this.PositionImpl = position; }
public void Visit(CaseVariableStatement statement) { var domArg = new CodeDomArg(); CodeMemberMethod method = new CodeMemberMethod(); method.Name = "Case_" + domArg.MethodIdentifier; method.Attributes = MemberAttributes.Private; method.ReturnType = new CodeTypeReference(typeof(object)); GenerateCallStatement(method.Statements, statement.Line.Line); var caseArgs = VisitChild(statement.Case, new CodeDomArg() { Scope = _codeStack.Peek().Scope }); if (caseArgs.Tag != null) _codeStack.Peek().Tag = caseArgs.Tag; method.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(object)), "var", caseArgs.CodeExpression)); foreach (var childArg in statement.BooleanStatements) { domArg = VisitChild(childArg, new CodeDomArg() { Scope = _codeStack.Peek().Scope }); if (domArg.Tag != null) _codeStack.Peek().Tag = domArg.Tag; method.Statements.AddRange(domArg.ParentStatements); } if (statement.ElseStatement == null) method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null))); else { domArg = VisitChild(statement.ElseStatement, new CodeDomArg() { Scope = _codeStack.Peek().Scope }); if (domArg.Tag != null) _codeStack.Peek().Tag = domArg.Tag; method.Statements.Add(new CodeMethodReturnStatement(domArg.CodeExpression)); } _mainType.Type.Members.Add(method); var methodcall = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(null, method.Name)); var rowParam = new CodeParameterDeclarationExpression(_codeStack.Peek().Scope.CodeDomReference.TypeArguments[0], "row"); method.Parameters.Add(rowParam); methodcall.Parameters.Add(new CodeVariableReferenceExpression("row")); if(_codeStack.Peek().Tag != null) //pick statement { var htmlNodeParam = new CodeParameterDeclarationExpression(new CodeTypeReference("HtmlNode"), "node"); methodcall.Parameters.Add(new CodeVariableReferenceExpression("node")); method.Parameters.Add(htmlNodeParam); } _codeStack.Peek() .ParentStatements.Add(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("result"), "AddColumn", new CodePrimitiveExpression("(No column name)"))); _codeStack.Peek().CodeExpression = methodcall; }
public TypescriptParameterDeclarationExpression( CodeParameterDeclarationExpression codeExpression, CodeGeneratorOptions options, ITypescriptTypeMapper typescriptTypeMapper) { _codeExpression = codeExpression; _options = options; _typescriptTypeMapper = typescriptTypeMapper; System.Diagnostics.Debug.WriteLine("TypescriptParameterDeclarationExpression Created"); }
public void AddRange (CodeParameterDeclarationExpression [] value ) { if (value == null) { throw new ArgumentNullException ("value"); } for (int i = 0; i < value.Length; i++) { Add (value[i]); } }
public CodeMemberOperatorOverride(OperatorType type, CodeParameterDeclarationExpression[] parameters, CodeTypeReference returnType, params CodeStatement[] statements) { m_operator = type; m_parameters = parameters; m_returnType = returnType; m_statements = statements; }
public static CodeParameterDeclarationExpression Clone(this CodeParameterDeclarationExpression expression) { if (expression == null) return null; CodeParameterDeclarationExpression e = new CodeParameterDeclarationExpression(); e.CustomAttributes = expression.CustomAttributes.Clone(); e.Direction = expression.Direction; e.Name = expression.Name; e.Type = expression.Type.Clone(); e.UserData.AddRange(expression.UserData); return e; }
public void Constructor2_Deny_Unrestricted () { CodeParameterDeclarationExpression cpde = new CodeParameterDeclarationExpression ("System.Int32", "mono"); Assert.AreEqual (0, cpde.CustomAttributes.Count, "CustomAttributes"); cpde.CustomAttributes = new CodeAttributeDeclarationCollection (); Assert.AreEqual (FieldDirection.In, cpde.Direction, "Direction"); cpde.Direction = FieldDirection.Out; Assert.AreEqual ("mono", cpde.Name, "Name"); cpde.Name = String.Empty; Assert.AreEqual ("System.Int32", cpde.Type.BaseType, "Type"); cpde.Type = new CodeTypeReference ("System.Int32"); }
public void Constructor1 () { CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression (); CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression (); CodeParameterDeclarationExpression[] parameters = new CodeParameterDeclarationExpression[] { param1, param2 }; CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection ( parameters); Assert.AreEqual (2, coll.Count, "#1"); Assert.AreEqual (0, coll.IndexOf (param1), "#2"); Assert.AreEqual (1, coll.IndexOf (param2), "#3"); }
private CodeMemberMethod GenerateInterfaceImplementationForOperationContract(MethodInfo method) { var genMethod = new CodeMemberMethod(); genMethod.ReturnType = new CodeTypeReference(method.ReturnType); genMethod.Name = method.Name; genMethod.Attributes = MemberAttributes.Public; foreach (var parameter in method.GetParameters()) { var genParam = new CodeParameterDeclarationExpression(parameter.ParameterType, parameter.Name); genMethod.Parameters.Add(genParam); } PreventInliningOfGeneratedMethod(genMethod); //Now generate the implementation, we just want to call into the base.CreateRestRequestForparentMethod(new object[]{arg0, arg1, arg2} ) CodeMethodInvokeExpression invokeExpression = null; if (this.IsAsync(method)) { if (method.ReturnType.IsGenericType) { invokeExpression = new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(new CodeBaseReferenceExpression(), "CreateAndInvokeRestRequestForParentMethodAsync", new CodeTypeReference( method.ReturnType.GetGenericArguments().Single()))); } else { invokeExpression = new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(new CodeBaseReferenceExpression(), "CreateAndInvokeRestRequestForParentMethodAsync")); } } else { invokeExpression = new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), "CreateAndInvokeRestRequestForParentMethod"); } //Now add the arguments of parent method in the same order in the end of the invocation foreach (ParameterInfo parameter in method.GetParameters()) { invokeExpression.Parameters.Add(new CodeVariableReferenceExpression(parameter.Name)); } GenerateAddReturnStatementFromInvokeExpressionIfNeeded(method, genMethod, invokeExpression); return genMethod; }
public void Constructor2 () { CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression (); CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression (); CodeParameterDeclarationExpressionCollection c = new CodeParameterDeclarationExpressionCollection (); c.Add (param1); c.Add (param2); CodeParameterDeclarationExpressionCollection coll = new CodeParameterDeclarationExpressionCollection (c); Assert.AreEqual (2, coll.Count, "#1"); Assert.AreEqual (0, coll.IndexOf (param1), "#2"); Assert.AreEqual (1, coll.IndexOf (param2), "#3"); }
protected override void Constructor(CodeTypeDeclaration typeProxy, CodeTypeReference typerefDbusInterface) { CodeConstructor constructor = new CodeConstructor(); constructor.Attributes = MemberAttributes.Public; CodeParameterDeclarationExpression paramProxy = new CodeParameterDeclarationExpression(typerefDbusInterface, CodeBuilderCommon.targetName); constructor.Parameters.Add(paramProxy); CodeFieldReferenceExpression thisProxyFieldRef = new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), CodeBuilderCommon.targetName ); CodeAssignStatement assignProxy = new CodeAssignStatement(thisProxyFieldRef, new CodeArgumentReferenceExpression(CodeBuilderCommon.targetName)); constructor.Statements.Add(assignProxy); typeProxy.Members.Add(constructor); }
/// <summary> /// /// </summary> /// <param name="member"></param> /// <param name="inner"></param> /// <param name="attrs"></param> /// <returns></returns> public CodeTypeMember CreateMember(MemberInfo member, CodeFieldReferenceExpression inner, MemberAttributes attrs) { Debug.Assert(member is MethodInfo); MethodInfo method = member as MethodInfo; CodeMemberMethod codeMethod = new CodeMemberMethod(); codeMethod.Name = method.Name; codeMethod.ReturnType = new CodeTypeReference(method.ReturnType); codeMethod.Attributes = attrs; // try CodeTryCatchFinallyStatement tryCode = new CodeTryCatchFinallyStatement(); // decleare parameters List<CodeArgumentReferenceExpression> codeParamiteRefrs = new List<CodeArgumentReferenceExpression>(); foreach (ParameterInfo codeParameter in method.GetParameters()) { CodeParameterDeclarationExpression codeParameterDeclare = new CodeParameterDeclarationExpression(codeParameter.ParameterType, codeParameter.Name); codeMethod.Parameters.Add(codeParameterDeclare); codeParamiteRefrs.Add(new CodeArgumentReferenceExpression(codeParameter.Name)); } // invoke CodeMethodInvokeExpression invokeMethod = new CodeMethodInvokeExpression( inner, method.Name, codeParamiteRefrs.ToArray()); if (method.ReturnType.Name.ToLower() == "void") { tryCode.TryStatements.Add(invokeMethod); } else { CodeVariableDeclarationStatement var = new CodeVariableDeclarationStatement(method.ReturnType, "returnObject", invokeMethod); //CodeAssignStatement assign = new CodeAssignStatement(var, invokeMethod); tryCode.TryStatements.Add(var); CodeCommentStatement todo = new CodeCommentStatement("TODO: your code", false); tryCode.TryStatements.Add(todo); CodeVariableReferenceExpression varRef = new CodeVariableReferenceExpression("returnObject"); CodeMethodReturnStatement codeReturn = new CodeMethodReturnStatement(varRef); tryCode.TryStatements.Add(codeReturn); } // catch CodeTypeReference codeTypeRef = new CodeTypeReference(typeof(Exception)); CodeCatchClause catchClause = new CodeCatchClause("ex", codeTypeRef); catchClause.Statements.Add(new CodeThrowExceptionStatement()); tryCode.CatchClauses.Add(catchClause); codeMethod.Statements.Add(tryCode); return codeMethod; }
public CodeParameterDeclarationExpressionCollection GenerateMethodsParameters() { var sqlQuery = new CodeParameterDeclarationExpression ("System.String", "query"); var sqlQueryParameter = new CodeParameterDeclarationExpression () { Type = new CodeTypeReference ("System.Object"), Name = "paramater = null", // TODO : find a way to do it properly // CustomAttributes = new CodeAttributeDeclarationCollection { // new CodeAttributeDeclaration ("Optional") // } }; var parameters = new CodeParameterDeclarationExpressionCollection (); parameters.Add (sqlQuery); parameters.Add (sqlQueryParameter); return parameters; }
/*private void GenerateMethods(CodeTypeDeclaration tgtType) { foreach (GMethod method in type.Methods) { CreateMethodSignature(tgtType, method, false); } }*/ private CodeMemberMethod CreateConstructorHelper(GMethod constructor, string uName) { var tgtMethod = new CodeMemberMethod(); tgtMethod.Name = uName; tgtMethod.Attributes = MemberAttributes.Static | MemberAttributes.Private | MemberAttributes.New; Utils.AddAttribute(tgtMethod, "net.sf.jni4net.attributes.ClrMethod", constructor.CLRSignature); // inject thiz parameter var tgtParameter = new CodeParameterDeclarationExpression(); tgtParameter.Name = "thiz"; tgtParameter.Type = constructor.Type.CLRReference; tgtMethod.Parameters.Add(tgtParameter); GenerateParameters(constructor, tgtMethod); return tgtMethod; }
private CodeMemberMethod ApplyMethod(ParseTreeNode node) { var parameterType = new CodeTypeReference(typeof (IActivityContext)); var returnType = new CodeTypeReference(typeof (bool)); var contextParameter = new CodeParameterDeclarationExpression(parameterType, "context"); var method = new CodeMemberMethod { Attributes = MemberAttributes.Public | MemberAttributes.Override, Name = "Apply", ReturnType = returnType }; method.Parameters.Add(contextParameter); method.Statements.Add(new CodeMethodReturnStatement(Generate(node))); return method; }
internal StandardBindingSectionGenerator(Type standardBindingType, Assembly userAssembly, CodeDomProvider provider) { this.standardBindingType = standardBindingType; this.userAssembly = userAssembly; this.provider = provider; this.generatedElementClassName = standardBindingType.Name + Constants.ElementSuffix; this.constantsClassName = standardBindingType.Name.Substring(0, standardBindingType.Name.IndexOf(TypeNameConstants.Binding)) + Constants.ConfigurationStrings; this.defaultValuesClassName = standardBindingType.Name.Substring(0, standardBindingType.Name.IndexOf(TypeNameConstants.Binding)) + Constants.Defaults; this.generatedCollectionElementClassName = standardBindingType.Name + Constants.CollectionElementSuffix; this.customSBTypeRef = new CodeTypeReference(standardBindingType.Name); this.customSBTypeOfRef = new CodeTypeOfExpression(customSBTypeRef); this.bindingMethodParamRef = new CodeParameterDeclarationExpression( CodeDomHelperObjects.bindingTypeRef, Constants.bindingParamName); }
public static void GenerateConstructor(CodeTypeDeclaration classDecl) { CodeConstructor constructorMember = new CodeConstructor() ; constructorMember.Attributes = MemberAttributes.Public; CodeParameterDeclarationExpression parameter = new CodeParameterDeclarationExpression(new CodeTypeReference("IContext"), "context"); constructorMember.Parameters.Add(parameter); CodeThisReferenceExpression thisExp = new CodeThisReferenceExpression(); CodeFieldReferenceExpression ctxFieldExp = new CodeFieldReferenceExpression(thisExp, "context"); CodeArgumentReferenceExpression argExp = new CodeArgumentReferenceExpression("context"); CodeAssignStatement assignStatement = new CodeAssignStatement(ctxFieldExp, argExp); constructorMember.Statements.Add(assignStatement); classDecl.Members.Add(constructorMember); }
/// <summary> /// /// </summary> /// <param name="table"></param> /// <returns></returns> public CodeMemberMethod BuildSelectBE(TableViewTableTypeBase table) { CodeMemberMethod cmSelect = new CodeMemberMethod(); cmSelect.Attributes = MemberAttributes.Public; cmSelect.ReturnType = new CodeTypeReference("System.Data.DataSet"); String cp_name = "ssp_" + table.Name; String PocoTypeName = table.Name; String FullPocoTypeName = PocoTypeName; CodeParameterDeclarationExpression cpdePoco = new CodeParameterDeclarationExpression(); cpdePoco.Name = "query"; cpdePoco.Type = new CodeTypeReference(table.Name); cpdePoco.Direction = FieldDirection.In; cmSelect.Parameters.Add(cpdePoco); cmSelect.Attributes = MemberAttributes.Public; cmSelect.Name = "Select"; cmSelect.Statements.Add(new CodeSnippetExpression("this.Access.CreateProcedureCommand(\"" + cp_name + "\")")); foreach (Column c in table.Columns) { MemberGraph mGraph = new MemberGraph(c); String DotNetTypeName = TypeConvertor.ToNetType(c.DataType.SqlDataType).ToString(); System.CodeDom.CodeConditionStatement ccsField = new CodeConditionStatement(); if (mGraph.IsNullable) { ccsField.Condition = new CodeSnippetExpression("query." + mGraph.PropertyName() + ".HasValue"); ccsField.TrueStatements.Add(new CodeSnippetExpression("this.Access.AddParameter(\"" + mGraph.PropertyName() + "\",query." + mGraph.PropertyName() + ".Value, ParameterDirection.Input)")); ccsField.FalseStatements.Add(new CodeSnippetExpression("this.Access.AddParameter(\"" + mGraph.PropertyName() + "\", null , ParameterDirection.Input)")); } else { ccsField.Condition = new CodeSnippetExpression("query." + mGraph.PropertyName() + " == null"); ccsField.TrueStatements.Add(new CodeSnippetExpression("this.Access.AddParameter(\"" + mGraph.PropertyName() + "\", null , ParameterDirection.Input)")); ccsField.FalseStatements.Add(new CodeSnippetExpression("this.Access.AddParameter(\"" + mGraph.PropertyName() + "\",query." + mGraph.PropertyName() + ", ParameterDirection.Input)")); } cmSelect.Statements.Add(ccsField); } cmSelect.Statements.Add(new CodeSnippetExpression("return this.Access.ExecuteDataSet()")); cmSelect.Comments.Add(new CodeCommentStatement("Select by Object [Implements Query By Example], returns DataSet")); return cmSelect; }
/// <summary> /// Defines and returns a constructor for the given type /// </summary> /// <param name="container"></param> /// <param name="modifier"></param> /// <param name="parameters"></param> /// <returns></returns> public static CodeConstructor DefineConstructor(CodeTypeDeclaration container, ModifierEnum modifier, params ParameterInfo[] parameters) { CodeConstructor ctor = new CodeConstructor(); ctor.Attributes = (ctor.Attributes & ~MemberAttributes.AccessMask) | (MemberAttributes)modifier; if (parameters != null) { foreach (ParameterInfo parameter in parameters) { CodeParameterDeclarationExpression codeParameter = new CodeParameterDeclarationExpression( parameter.ParameterType, parameter.Name); ctor.Parameters.Add(codeParameter); } } container.Members.Add(ctor); return ctor; }
private CodeParam CloneParamImpl(CodeParam param, bool copyAttrib) { if (param == null) { return(null); } CodeParam clone = new CodeParam(); clone.Name = param.Name; clone.Direction = param.Direction; clone.Type = CloneTypeReference(param.Type); if (copyAttrib) { CloneCustomAttributes(param.CustomAttributes, clone.CustomAttributes); } return(clone); }
public async System.Threading.Tasks.Task GCode_CodeDom_GenerateMethodCode(CodeTypeDeclaration codeClass, LinkPinControl element, GenerateCodeContext_Class context, MethodGenerateData data) { var csParam = CSParam as MethodOverrideConstructParam; Type[] paramTypes = new Type[csParam.MethodInfo.Params.Count]; for (int i = 0; i < paramTypes.Length; i++) { switch (csParam.MethodInfo.Params[i].FieldDirection) { case FieldDirection.In: if (csParam.MethodInfo.Params[i].IsParamsArray) { throw new InvalidOperationException("未实现"); } else { paramTypes[i] = csParam.MethodInfo.Params[i].ParameterType; } break; case FieldDirection.Out: case FieldDirection.Ref: if (csParam.MethodInfo.Params[i].IsParamsArray) { throw new InvalidOperationException("未实现"); } else { paramTypes[i] = csParam.MethodInfo.Params[i].ParameterType.MakeByRefType(); } break; } } EngineNS.Editor.MacrossMemberAttribute.enMacrossType macrossType = EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Overrideable; if (csParam.MethodInfo.IsFromMacross) { macrossType |= EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Callable; } else { var methodInfo = csParam.MethodInfo.ParentClassType.GetMethod(csParam.MethodInfo.MethodName, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static, null, paramTypes, null); var atts = methodInfo.GetCustomAttributes(typeof(EngineNS.Editor.MacrossMemberAttribute), false); if (atts.Length > 0) { var macrossMemberAtt = atts[0] as EngineNS.Editor.MacrossMemberAttribute; macrossType = macrossMemberAtt.MacrossType; } } if (element == null || element == mCtrlMethodPin_Next) { var methodCode = new CodeGenerateSystem.CodeDom.CodeMemberMethod(); methodCode.Attributes = MemberAttributes.Override; //if (mMethodInfo != null) //{ if (csParam.MethodInfo.IsFamily) { methodCode.Attributes |= MemberAttributes.Family; } if (csParam.MethodInfo.IsFamilyAndAssembly) { methodCode.Attributes |= MemberAttributes.FamilyAndAssembly; } if (csParam.MethodInfo.IsFamilyOrAssembly) { methodCode.Attributes |= MemberAttributes.FamilyOrAssembly; } if (csParam.MethodInfo.IsPublic) { methodCode.Attributes |= MemberAttributes.Public; } //} //else // methodCode.Attributes |= MemberAttributes.Public; methodCode.Name = NodeName; var mcType = EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Unknow; if (csParam.MethodInfo.MC_Callable) { mcType = mcType | EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Callable; } if (csParam.MethodInfo.MC_Overrideable) { mcType = mcType | EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Overrideable; } if (mcType != EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Unknow) { methodCode.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(EngineNS.Editor.MacrossMemberAttribute)), new CodeAttributeArgument(new CodePrimitiveExpression(mcType)))); } if (data != null) { foreach (var localParam in data.LocalParams) { var defVal = CodeGenerateSystem.Program.GetDefaultValueFromType(localParam.ParamType); var initExp = Program.GetValueCode(methodCode.Statements, localParam.ParamType, defVal); methodCode.Statements.Add(new CodeVariableDeclarationStatement(localParam.ParamType, localParam.ParamName, initExp)); } } string paramPreStr = "temp___"; //bool needUnsafeFlag = false; string catchParamName = "("; foreach (var paramNode in mChildNodes) { var paramExp = new System.CodeDom.CodeParameterDeclarationExpression(); if (paramNode is MethodInvokeParameterControl) { var pm = paramNode as MethodInvokeParameterControl; var pmParam = pm.CSParam as MethodInvokeParameterControl.MethodInvokeParameterConstructionParams; paramExp.Direction = pm.ParamFlag; if (pmParam.ParamInfo.ParameterDisplayType != null) { paramExp.Name = paramPreStr + pmParam.ParamInfo.ParamName; paramExp.Type = new CodeTypeReference(pmParam.ParamInfo.ParameterType); } else { paramExp.Name = pmParam.ParamInfo.ParamName; paramExp.Type = new System.CodeDom.CodeTypeReference(pm.ParamType); } //if (pm.ParamType.IsPointer) // needUnsafeFlag = true; } else if (paramNode is ParamParameterControl) { var pm = paramNode as ParamParameterControl; paramExp.Name = pm.ParamName; paramExp.Type = new System.CodeDom.CodeTypeReference(pm.ParamType); //if (pm.ParamType.IsPointer) // needUnsafeFlag = true; } else if (paramNode is MethodInvoke_DelegateControl) { var pm = paramNode as MethodInvoke_DelegateControl; paramExp.Name = pm.ParamName; paramExp.Type = new System.CodeDom.CodeTypeReference(pm.ParamType); } methodCode.Parameters.Add(paramExp); catchParamName += paramExp.Type + " " + paramExp.Name + ","; } // 所有函数全部unsafe //if (needUnsafeFlag) { //var typeName = MethodReturnType.FullName; methodCode.ReturnType = new CodeTypeReference(MethodReturnType); if (MethodReturnType == typeof(System.Threading.Tasks.Task) || MethodReturnType.BaseType == typeof(System.Threading.Tasks.Task)) { methodCode.IsAsync = true; } else { if (EngineNS.Editor.MacrossMemberAttribute.HasType(macrossType, EngineNS.Editor.MacrossMemberAttribute.enMacrossType.Unsafe)) { methodCode.IsUnsafe = true; } } } //else // methodCode.ReturnType = new CodeTypeReference(MethodReturnType); catchParamName = catchParamName.TrimEnd(','); catchParamName += ")"; var tryCatchExp = new System.CodeDom.CodeTryCatchFinallyStatement(); tryCatchExp.TryStatements.Add(new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeVariableReferenceExpression(context.ScopFieldName), "Begin", new CodeExpression[0])); var exName = "ex_" + EngineNS.Editor.Assist.GetValuedGUIDString(Id); var cah = new System.CodeDom.CodeCatchClause(exName); cah.Statements.Add(new System.CodeDom.CodeExpressionStatement( new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression( new System.CodeDom.CodeSnippetExpression("EngineNS.Profiler.Log"), "WriteException", new System.CodeDom.CodeVariableReferenceExpression(exName), new CodePrimitiveExpression("Macross异常")))); tryCatchExp.CatchClauses.Add(cah); tryCatchExp.FinallyStatements.Add(new CodeGenerateSystem.CodeDom.CodeMethodInvokeExpression(new CodeVariableReferenceExpression(context.ScopFieldName), "End", new CodeExpression[0])); string paramComment = ""; // 设置out参数默认值 foreach (var param in csParam.MethodInfo.Params) { if (param.ParameterDisplayType != null) { if (param.FieldDirection == FieldDirection.Out) { methodCode.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(paramPreStr + param.ParamName), new CodePrimitiveExpression(CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParameterType)))); } methodCode.Statements.Add(new CodeVariableDeclarationStatement(param.ParameterDisplayType, param.ParamName, new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParameterDisplayType, new CodeVariableReferenceExpression(paramPreStr + param.ParamName)))); } else { if (param.FieldDirection == FieldDirection.Out) { methodCode.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(param.ParamName), new CodePrimitiveExpression(CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParameterType)))); } } paramComment += param.FieldDirection + "," + param.ParameterType.FullName + "|"; } paramComment = paramComment.TrimEnd('|'); methodCode.Statements.Add(tryCatchExp); foreach (var param in csParam.MethodInfo.Params) { // ref或out,需要将displayType造成的临时变量再赋给原函数参数 if ((param.FieldDirection == FieldDirection.Out || param.FieldDirection == FieldDirection.Ref) && param.ParameterDisplayType != null) { methodCode.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(paramPreStr + param.ParamName), new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParameterType, new CodeVariableReferenceExpression(param.ParamName)))); } } if (csParam.MethodInfo.ReturnType != typeof(void) && csParam.MethodInfo.ReturnType != typeof(System.Threading.Tasks.Task)) { var retVal = CodeGenerateSystem.Program.GetDefaultValueFromType(csParam.MethodInfo.ReturnType); methodCode.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(retVal))); } if (csParam.MethodInfo.IsFromMacross) { codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideStart {csParam.MethodInfo.FuncId.ToString()} {NodeName} {paramComment}")); codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning disable 1998")); codeClass.Members.Add(methodCode); codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning restore 1998")); codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideEnd {csParam.MethodInfo.FuncId.ToString()} {NodeName}")); } else { codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideStart {NodeName} {paramComment}")); codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning disable 1998")); codeClass.Members.Add(methodCode); codeClass.Members.Add(new CodeSnippetTypeMember("#pragma warning restore 1998")); codeClass.Members.Add(new CodeSnippetTypeMember($"// OverrideEnd {NodeName}")); } var methodContext = new CodeGenerateSystem.Base.GenerateCodeContext_Method(context, methodCode); // 收集用于调试的数据的代码 var debugCodes = CodeDomNode.BreakPoint.BeginMacrossDebugCodeStatments(tryCatchExp.TryStatements); foreach (var paramNode in mChildNodes) { if (paramNode is MethodInvokeParameterControl) { var paramCtrl = paramNode as MethodInvokeParameterControl; CodeDomNode.BreakPoint.GetGatherDataValueCodeStatement(debugCodes, paramCtrl.ParamPin.GetLinkPinKeyName(), paramCtrl.GCode_CodeDom_GetValue(paramCtrl.ParamPin, methodContext), paramCtrl.GCode_GetTypeString(paramCtrl.ParamPin, methodContext), methodContext); } else if (paramNode is ParamParameterControl) { throw new InvalidOperationException(); } } // 断点 var breakCondStatement = CodeDomNode.BreakPoint.BreakCodeStatement(codeClass, debugCodes, HostNodesContainer.GUID, Id); // 设置数据 foreach (var paramNode in mChildNodes) { if (paramNode is MethodInvokeParameterControl) { var paramCtrl = paramNode as MethodInvokeParameterControl; CodeDomNode.BreakPoint.GetSetDataValueCodeStatement(breakCondStatement.TrueStatements, paramCtrl.ParamPin.GetLinkPinKeyName(), paramCtrl.GCode_CodeDom_GetValue(paramCtrl.ParamPin, methodContext), paramCtrl.GCode_GetType(paramCtrl.ParamPin, methodContext)); } else if (paramNode is ParamParameterControl) { throw new InvalidOperationException(); } } CodeDomNode.BreakPoint.EndMacrossDebugCodeStatements(tryCatchExp.TryStatements, debugCodes); if (mCtrlMethodPin_Next.HasLink) { methodContext.ReturnValueType = MethodReturnType; await mCtrlMethodPin_Next.GetLinkedObject(0, false).GCode_CodeDom_GenerateCode(codeClass, tryCatchExp.TryStatements, mCtrlMethodPin_Next.GetLinkedPinControl(0, false), methodContext); } } }
public int Add(CodeParameterDeclarationExpression value) => List.Add(value);
public bool Contains(CodeParameterDeclarationExpression value) => List.Contains(value);
public int IndexOf(CodeParameterDeclarationExpression value) => List.IndexOf(value);
/// <include file='doc\CodeParameterDeclarationExpressionCollection.uex' path='docs/doc[@for="CodeParameterDeclarationExpressionCollection.Remove"]/*' /> /// <devdoc> /// <para> Removes a specific <see cref='System.CodeDom.CodeParameterDeclarationExpression'/> from the /// <see cref='System.CodeDom.CodeParameterDeclarationExpressionCollection'/> .</para> /// </devdoc> public void Remove(CodeParameterDeclarationExpression value) { List.Remove(value); }
/// <include file='doc\CodeParameterDeclarationExpressionCollection.uex' path='docs/doc[@for="CodeParameterDeclarationExpressionCollection.Contains"]/*' /> /// <devdoc> /// <para>Gets a value indicating whether the /// <see cref='System.CodeDom.CodeParameterDeclarationExpressionCollection'/> contains the specified <see cref='System.CodeDom.CodeParameterDeclarationExpression'/>.</para> /// </devdoc> public bool Contains(CodeParameterDeclarationExpression value) { return(List.Contains(value)); }
/// <include file='doc\CodeParameterDeclarationExpressionCollection.uex' path='docs/doc[@for="CodeParameterDeclarationExpressionCollection.IndexOf"]/*' /> /// <devdoc> /// <para>Returns the index of a <see cref='System.CodeDom.CodeParameterDeclarationExpression'/> in /// the <see cref='System.CodeDom.CodeParameterDeclarationExpressionCollection'/> .</para> /// </devdoc> public int IndexOf(CodeParameterDeclarationExpression value) { return(List.IndexOf(value)); }
public CodeParam CloneParam(CodeParam param) { return(CloneParamImpl(param, true)); }
public CodeParam CloneParamNoAttributes(CodeParam param) { return(CloneParamImpl(param, false)); }
/// <include file='doc\CodeParameterDeclarationExpressionCollection.uex' path='docs/doc[@for="CodeParameterDeclarationExpressionCollection.Add"]/*' /> /// <devdoc> /// <para>Adds a <see cref='System.CodeDom.CodeParameterDeclarationExpression'/> with the specified value to the /// <see cref='System.CodeDom.CodeParameterDeclarationExpressionCollection'/> .</para> /// </devdoc> public int Add(CodeParameterDeclarationExpression value) { return(List.Add(value)); }
public bool Contains(CodeParameterDeclarationExpression value) { return(default(bool)); }
public int Add(CodeParameterDeclarationExpression value) { return(default(int)); }
/// <include file='doc\CodeParameterDeclarationExpressionCollection.uex' path='docs/doc[@for="CodeParameterDeclarationExpressionCollection.Insert"]/*' /> /// <devdoc> /// <para>Inserts a <see cref='System.CodeDom.CodeParameterDeclarationExpression'/> into the <see cref='System.CodeDom.CodeParameterDeclarationExpressionCollection'/> at the specified index.</para> /// </devdoc> public void Insert(int index, CodeParameterDeclarationExpression value) { List.Insert(index, value); }