protected override void WriteCommandBuilderBody(CodeMethod codeElement, RequestParams requestParams, bool isVoid, string returnType, LanguageWriter writer) { var parent = codeElement.Parent as CodeClass; var classMethods = parent.Methods; var name = codeElement.SimpleName; name = uppercaseRegex.Replace(name, "-$1").TrimStart('-').ToLower(); if (codeElement.HttpMethod == null) { // Build method // Puts together the BuildXXCommand objects. Needs a nav property name e.g. users // Command("users") -> Command("get") if (string.IsNullOrWhiteSpace(name)) { // BuildCommand function WriteUnnamedBuildCommand(codeElement, writer, parent, classMethods); } else { WriteContainerCommand(codeElement, writer, parent, name); } } else { WriteExecutableCommand(codeElement, requestParams, writer, name); } }
public void OrdersWithMethodWithinClass() { var root = CodeNamespace.InitRootNamespace(); var comparer = new CodeElementOrderComparer(); var codeClass = new CodeClass { Name = "Class" }; root.AddClass(codeClass); var method = new CodeMethod { Name = "Method" }; codeClass.AddMethod(method); method.AddParameter(new CodeParameter { Name = "param" }); var dataSet = new List <Tuple <CodeElement, CodeElement, int> > { new(null, null, 0), new(null, new CodeClass(), -1), new(new CodeClass(), null, 1), new(new CodeUsing(), new CodeProperty(), -1000), new(new CodeIndexer(), new CodeProperty(), 1000), new(method, new CodeProperty(), 1101), new(method, codeClass, -899) };
private static void AddPathQueryAndHeaderParameters(CodeMethod method) { var stringType = new CodeType { Name = "string", }; method.AddPathQueryOrHeaderParameter(new CodeParameter { Name = "q", Kind = CodeParameterKind.QueryParameter, Type = stringType, DefaultValue = "test", Description = "The q option", Optional = true }); method.AddPathQueryOrHeaderParameter(new CodeParameter { Name = "test-path", Kind = CodeParameterKind.Path, Type = stringType }); method.AddPathQueryOrHeaderParameter(new CodeParameter { Name = "Test-Header", Kind = CodeParameterKind.Headers, Type = stringType, Description = "The test header", }); }
// GET: BillPropertyModels/Edit/5 public ActionResult Edit(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } BillPropertyModels billPropertyModels = db.BillProperties.Find(id); if (billPropertyModels == null) { return(HttpNotFound()); } List <CodeMethod> list = CodeMethod.GetCodeMethod(); List <SelectListItem> item = list.Select(c => new SelectListItem { Value = c.Id, Text = c.Description }).ToList(); foreach (var tmp in item) { if (billPropertyModels.CodeMethod == tmp.Text) { tmp.Selected = true; break; } } ViewBag.List = item; return(View(billPropertyModels)); }
public static void AddAccessedProperty(this CodeMethod codeMethod) { codeMethod.AccessedProperty = new CodeProperty { Name = "someProperty" }; (codeMethod.Parent as CodeClass)?.AddProperty(codeMethod.AccessedProperty); }
public void WritesExecutableCommandForGetRequestModel() { method.Kind = CodeMethodKind.CommandBuilder; method.Description = "Test description"; method.SimpleName = "User"; method.HttpMethod = HttpMethod.Get; var userClass = root.AddClass(new CodeClass { Name = "User", Kind = CodeClassKind.Model }).First(); var stringType = new CodeType { Name = "user", TypeDefinition = userClass, }; var generatorMethod = new CodeMethod { Kind = CodeMethodKind.RequestGenerator, Name = "CreateGetRequestInformation", HttpMethod = method.HttpMethod }; method.OriginalMethod = new CodeMethod { Kind = CodeMethodKind.RequestExecutor, HttpMethod = method.HttpMethod, ReturnType = stringType, Parent = method.Parent }; var codeClass = method.Parent as CodeClass; codeClass.AddMethod(generatorMethod); AddRequestProperties(); AddRequestBodyParameters(method.OriginalMethod); AddPathQueryAndHeaderParameters(generatorMethod); writer.Write(method); var result = tw.ToString(); Assert.Contains("var command = new Command(\"user\");", result); Assert.Contains("command.Description = \"Test description\";", result); Assert.Contains("var qOption = new Option<string>(\"-q\", getDefaultValue: ()=> \"test\", description: \"The q option\")", result); Assert.Contains("qOption.IsRequired = false;", result); Assert.Contains("var jsonNoIndentOption = new Option<bool>(\"--json-no-indent\", r => {", result); Assert.Contains("command.AddOption(qOption);", result); Assert.Contains("command.AddOption(jsonNoIndentOption);", result); Assert.Contains("command.AddOption(outputOption);", result); Assert.Contains("command.SetHandler(async (invocationContext) => {", result); Assert.Contains("var q = invocationContext.ParseResult.GetValueForOption(qOption);", result); Assert.Contains("var requestInfo = CreateGetRequestInformation", result); Assert.Contains("requestInfo.PathParameters.Add(\"test%2Dpath\", testPath);", result); Assert.Contains("var response = await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, errorMapping: default, cancellationToken: cancellationToken);", result); Assert.Contains("var formatterOptions = output.GetOutputFormatterOptions(new FormatterOptionsModel(!jsonNoIndent));", result); Assert.Contains("response = await outputFilter?.FilterOutputAsync(response, query, cancellationToken)", result); Assert.Contains("await formatter.WriteOutputAsync(response, formatterOptions, cancellationToken);", result); Assert.Contains("});", result); Assert.Contains("return command;", result); }
private string GetNativeCallMehtodBody(CodeMethod caller, CodeField field, CodeType typeDecl) { var sb = new StringBuilder(); sb.Append("fixed (").Append(typeDecl.Name).Append("* self = &this)\n{\n\t"); if (caller.RetVal.Type != "void") { sb.Append("return "); } var argTypes = new List <string>(); if (caller.HasThisArg) { argTypes.Add(typeDecl.Name + "*"); } argTypes.AddRange(caller.Parameters.Select(arg => CSharpCodeGen.GetClrTypeName(arg.Type))); argTypes.Add(CSharpCodeGen.GetClrTypeName(caller.RetVal.Type)); sb.Append("((delegate* unmanaged[Stdcall]<").Append(string.Join(", ", argTypes)).Append(">)"); sb.Append(field.Name).Append(")("); var args = new List <string>(); if (caller.HasThisArg) { args.Add("self"); } args.AddRange(caller.Parameters.Select(arg => arg.Name)); sb.Append(string.Join(", ", args)); sb.Append(");"); sb.Append("\n}"); return(sb.ToString()); }
public void WriteGetterAdditionalData() { var getter = new CodeMethod() { Name = "getAdditionalData", Description = "This method gets the emailAddress", ReturnType = new CodeType() { Name = "additionalData", IsNullable = false }, Kind = CodeMethodKind.Getter, AccessedProperty = new CodeProperty() { Name = "additionalData", Access = AccessModifier.Private, Kind = CodePropertyKind.AdditionalData, Type = new CodeType { Name = "additionalData" } }, Parent = parentClass }; _codeMethodWriter.WriteCodeElement(getter, languageWriter); var result = stringWriter.ToString(); Assert.Contains("public function getAdditionalData(): array", result); Assert.Contains("return $this->additionalData;", result); }
public void WriteRequestBuilderWithParametersBody() { var codeMethod = new CodeMethod() { ReturnType = new CodeType() { Name = "MessageRequestBuilder", IsNullable = false }, Name = "messageById", Parent = parentClass, Kind = CodeMethodKind.RequestBuilderWithParameters }; codeMethod.AddParameter(new CodeParameter { Kind = CodeParameterKind.Path, Name = "id", Type = new CodeType { Name = "string" } }); _codeMethodWriter.WriteCodeElement(codeMethod, languageWriter); var result = stringWriter.ToString(); Assert.Contains("function messageById(string $id): MessageRequestBuilder {", result); Assert.Contains("return new MessageRequestBuilder($this->pathParameters, $this->requestAdapter, $id);", result); }
public void WriteConstructorBody() { var constructor = new CodeMethod() { Name = "constructor", Access = AccessModifier.Public, Description = "The constructor for this class", ReturnType = new CodeType() { Name = "void" }, Kind = CodeMethodKind.Constructor }; parentClass.AddMethod(constructor); var propWithDefaultValue = new CodeProperty() { Name = "type", DefaultValue = "\"#microsoft.graph.entity\"", Kind = CodePropertyKind.Custom }; parentClass.AddProperty(propWithDefaultValue); _codeMethodWriter.WriteCodeElement(constructor, languageWriter); var result = stringWriter.ToString(); Assert.Contains("public function __construct", result); Assert.Contains("$this->setType('#microsoft.graph.entity')", result); }
public void WriteDeserializer(CodeProperty property, string expected) { parentClass.Kind = CodeClassKind.Model; var deserializerMethod = new CodeMethod() { Name = "getDeserializationFields", Kind = CodeMethodKind.Deserializer, Description = "Just some random method", ReturnType = new CodeType { IsNullable = false, CollectionKind = CodeTypeBase.CodeTypeCollectionKind.Array, Name = "array" } }; parentClass.AddMethod(deserializerMethod); parentClass.AddProperty(property); _refiner.Refine(parentClass.Parent as CodeNamespace); languageWriter.Write(deserializerMethod); if (property.ExistsInBaseType) { Assert.DoesNotContain(expected, stringWriter.ToString()); } else { Assert.Contains(expected, stringWriter.ToString()); } }
public CodeMethodWriterTests() { languageWriter = LanguageWriter.GetLanguageWriter(GenerationLanguage.PHP, DefaultPath, DefaultName); stringWriter = new StringWriter(); languageWriter.SetTextWriter(stringWriter); root = CodeNamespace.InitRootNamespace(); root.Name = "Microsoft\\Graph"; _codeMethodWriter = new CodeMethodWriter(new PhpConventionService()); parentClass = new CodeClass() { Name = "parentClass" }; root.AddClass(parentClass); method = new CodeMethod() { Name = MethodName, IsAsync = true, Description = "This is a very good method to try all the good things" }; method.ReturnType = new CodeType() { Name = ReturnTypeName }; _refiner = new PhpRefiner(new GenerationConfiguration { Language = GenerationLanguage.PHP }); parentClass.AddMethod(method); }
public CodeMethodWriterTests() { writer = LanguageWriter.GetLanguageWriter(GenerationLanguage.Ruby, DefaultPath, DefaultName); tw = new StringWriter(); writer.SetTextWriter(tw); root = CodeNamespace.InitRootNamespace(); parentClass = new CodeClass { Name = "parentClass" }; root.AddClass(parentClass); method = new CodeMethod { Name = MethodName, }; method.ReturnType = new CodeType { Name = ReturnTypeName }; voidMethod = new CodeMethod { Name = MethodName, }; voidMethod.ReturnType = new CodeType { Name = "void" }; parentClass.AddMethod(voidMethod); parentClass.AddMethod(method); }
public void WriteDeserializerMergeWhenHasParent() { var currentClass = parentClass; currentClass.Kind = CodeClassKind.Model; var declaration = currentClass.StartBlock as ClassDeclaration; declaration.Inherits = new CodeType() { Name = "Entity", IsExternal = true, IsNullable = false }; currentClass.AddProperty( new CodeProperty() { Name = "name", Access = AccessModifier.Private, Kind = CodePropertyKind.Custom, Type = new CodeType() { Name = "string" } } ); var deserializerMethod = new CodeMethod() { Name = "getDeserializationFields", Kind = CodeMethodKind.Deserializer, Description = "Just some random method", ReturnType = new CodeType() { IsNullable = false, CollectionKind = CodeTypeBase.CodeTypeCollectionKind.Array, Name = "array" } }; var cls = new CodeClass() { Name = "ModelParent", Kind = CodeClassKind.Model, Parent = root, StartBlock = new ClassDeclaration() { Implements = { }, Name = "ModelParent", Parent = root } }; root.AddClass(cls); currentClass.StartBlock.Inherits = new CodeType() { TypeDefinition = cls }; currentClass.AddMethod(deserializerMethod); _refiner.Refine(parentClass.Parent as CodeNamespace); _codeMethodWriter.WriteCodeElement(deserializerMethod, languageWriter); var result = stringWriter.ToString(); Assert.Contains("array_merge(parent::getFieldDeserializers()", result); }
public void WritesExecutableCommandForPostRequestWithStreamBody() { method.Kind = CodeMethodKind.CommandBuilder; method.SimpleName = "User"; method.HttpMethod = HttpMethod.Post; var stringType = new CodeType { Name = "string", }; var bodyType = new CodeType { Name = "stream" }; var generatorMethod = new CodeMethod { Kind = CodeMethodKind.RequestGenerator, Name = "CreatePostRequestInformation", HttpMethod = method.HttpMethod }; method.OriginalMethod = new CodeMethod { Kind = CodeMethodKind.RequestExecutor, HttpMethod = method.HttpMethod, ReturnType = stringType, Parent = method.Parent }; method.OriginalMethod.AddParameter(new CodeParameter { Name = "body", Kind = CodeParameterKind.RequestBody, Type = bodyType, }); var codeClass = method.Parent as CodeClass; codeClass.AddMethod(generatorMethod); AddRequestProperties(); AddPathQueryAndHeaderParameters(generatorMethod); writer.Write(method); var result = tw.ToString(); Assert.Contains("var command = new Command(\"user\");", result); Assert.Contains("var qOption = new Option<string>(\"-q\", getDefaultValue: ()=> \"test\", description: \"The q option\")", result); Assert.Contains("qOption.IsRequired = false;", result); Assert.Contains("command.AddOption(qOption);", result); Assert.Contains("var fileOption = new Option<FileInfo>(\"--file\")", result); Assert.Contains("fileOption.IsRequired = true;", result); Assert.Contains("command.AddOption(fileOption);", result); Assert.Contains("var file = invocationContext.ParseResult.GetValueForOption(fileOption);", result); Assert.Contains("using var stream = file.OpenRead();", result); Assert.Contains("var requestInfo = CreatePostRequestInformation", result); Assert.Contains("requestInfo.PathParameters.Add(\"test%2Dpath\", testPath);", result); Assert.Contains("var response = await RequestAdapter.SendPrimitiveAsync<Stream>(requestInfo, errorMapping: default, cancellationToken: cancellationToken);", result); Assert.Contains("return command;", result); }
public ActionResult Edit(BillPropertyModels billPropertyModels) { if (ModelState.IsValid) { switch (billPropertyModels.CodeMethod) { case CodeMethod.Month: billPropertyModels.Year = 2; billPropertyModels.Month = 2; billPropertyModels.Day = 0; billPropertyModels.SerialNumber = 6; break; case CodeMethod.Serial: billPropertyModels.Year = 0; billPropertyModels.Month = 0; billPropertyModels.Day = 0; billPropertyModels.SerialNumber = this.GetSerialNumbers(billPropertyModels.Code); break; case CodeMethod.Manual: billPropertyModels.Year = 0; billPropertyModels.Month = 0; billPropertyModels.Day = 0; billPropertyModels.SerialNumber = 0; break; default: billPropertyModels.Year = 2; billPropertyModels.Month = 2; billPropertyModels.Day = 2; billPropertyModels.SerialNumber = 4; break; } db.Entry(billPropertyModels).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } List <CodeMethod> list = CodeMethod.GetBillType(); List <SelectListItem> item = list.Select(c => new SelectListItem { Value = c.Id, Text = c.Description }).ToList(); foreach (var tmp in item) { if (billPropertyModels.CodeMethod == tmp.Text) { tmp.Selected = true; break; } } ViewBag.List = item; return(View(billPropertyModels)); }
static void GenerateEndMethodImpl(CodeClass c, MethodInfo endProcessMethod, string name, MethodInfo mi) { CodeMethod m = c.ImplementMethod(mi); CodeBuilder b = m.CodeBuilder; ParameterInfo [] pinfos = mi.GetParameters(); ParameterInfo p = pinfos [0]; CodeArgumentReference asyncResultRef = m.GetArg(0); CodeVariableDeclaration paramsDecl = new CodeVariableDeclaration(typeof(object []), "parameters"); b.CurrentBlock.Add(paramsDecl); CodeVariableReference paramsRef = paramsDecl.Variable; b.Assign(paramsRef, new CodeNewArray(typeof(object), new CodeLiteral(pinfos.Length - 1))); /* * for (int i = 0; i < pinfos.Length - 2; i++) { * ParameterInfo par = pinfos [i]; * if (!par.IsOut) * b.Assign ( * new CodeArrayItem (paramsRef, new CodeLiteral (i)), * new CodeCast (typeof (object), * new CodeArgumentReference (par.ParameterType, par.Position + 1, "arg" + i))); * } */ #if USE_OD_REFERENCE_IN_PROXY CodePropertyReference argMethodInfo = GetOperationMethod(m, b, name, "EndMethod"); #else CodeMethodCall argMethodInfo = new CodeMethodCall(typeof(MethodBase), "GetCurrentMethod"); #endif CodeLiteral argOperName = new CodeLiteral(name); CodeVariableReference retValue = null; if (mi.ReturnType == typeof(void)) { b.Call(m.GetThis(), endProcessMethod, argMethodInfo, argOperName, paramsRef, asyncResultRef); } else { CodeVariableDeclaration retValueDecl = new CodeVariableDeclaration(mi.ReturnType, "retValue"); b.CurrentBlock.Add(retValueDecl); retValue = retValueDecl.Variable; b.Assign(retValue, new CodeCast(mi.ReturnType, b.CallFunc(m.GetThis(), endProcessMethod, argMethodInfo, argOperName, paramsRef, asyncResultRef))); } // FIXME: fill out parameters if (retValue != null) { b.Return(retValue); } }
public void Defensive() { var root = CodeNamespace.InitRootNamespace(); var method = new CodeMethod(root) { Name = "class", }; Assert.False(method.IsOfKind((CodeMethodKind[])null)); Assert.False(method.IsOfKind(new CodeMethodKind[] { })); }
public void IsOfKind() { var method = new CodeMethod { Name = "class", }; Assert.False(method.IsOfKind(CodeMethodKind.Constructor)); method.Kind = CodeMethodKind.Deserializer; Assert.True(method.IsOfKind(CodeMethodKind.Deserializer)); Assert.True(method.IsOfKind(CodeMethodKind.Deserializer, CodeMethodKind.Getter)); Assert.False(method.IsOfKind(CodeMethodKind.Getter)); }
public void WritesExecutableCommandForPostVoidRequest() { method.Kind = CodeMethodKind.CommandBuilder; method.SimpleName = "User"; method.HttpMethod = HttpMethod.Post; var stringType = new CodeType { Name = "string", }; var voidType = new CodeType { Name = "void", }; var generatorMethod = new CodeMethod { Kind = CodeMethodKind.RequestGenerator, Name = "CreatePostRequestInformation", HttpMethod = method.HttpMethod }; method.OriginalMethod = new CodeMethod { Kind = CodeMethodKind.RequestExecutor, HttpMethod = method.HttpMethod, ReturnType = voidType, Parent = method.Parent }; method.OriginalMethod.AddParameter(new CodeParameter { Name = "body", Kind = CodeParameterKind.RequestBody, Type = stringType, }); var codeClass = method.Parent as CodeClass; codeClass.AddMethod(generatorMethod); AddRequestProperties(); AddPathQueryAndHeaderParameters(generatorMethod); writer.Write(method); var result = tw.ToString(); Assert.Contains("var command = new Command(\"user\");", result); Assert.Contains("var qOption = new Option<string>(\"-q\", getDefaultValue: ()=> \"test\", description: \"The q option\")", result); Assert.Contains("qOption.IsRequired = false;", result); Assert.Contains("command.AddOption(qOption);", result); Assert.Contains("var bodyOption = new Option<string>(\"--body\")", result); Assert.Contains("bodyOption.IsRequired = true;", result); Assert.Contains("command.AddOption(bodyOption);", result); Assert.Contains("var requestInfo = CreatePostRequestInformation", result); Assert.Contains("requestInfo.PathParameters.Add(\"test%2Dpath\", testPath);", result); Assert.Contains("await RequestAdapter.SendNoContentAsync(requestInfo, errorMapping: default, cancellationToken: cancellationToken);", result); Assert.Contains("Console.WriteLine(\"Success\");", result); Assert.Contains("return command;", result); Assert.DoesNotContain("response = await outputFilter?.FilterOutputAsync(response, query, cancellationToken)", result); Assert.DoesNotContain("await formatter.WriteOutputAsync(response, formatterOptions, cancellationToken);", result); }
// GET: BillPropertyModels/Create public ActionResult Create() { List <CodeMethod> list = CodeMethod.GetCodeMethod(); List <SelectListItem> item = list.Select(c => new SelectListItem { Value = c.Id, Text = c.Description }).ToList(); ViewBag.List = item; return(View()); }
private void AddRequestBodyParameters(CodeMethod target = default, bool useComplexTypeForBody = false) { var stringType = new CodeType { Name = "string", }; target ??= method; var requestConfigClass = (target.Parent as CodeClass).AddInnerClass(new CodeClass { Name = "RequestConfig", Kind = CodeClassKind.RequestConfiguration, }).First(); requestConfigClass.AddProperty(new() { Name = "h", Kind = CodePropertyKind.Headers, Type = stringType, }, new () { Name = "q", Kind = CodePropertyKind.QueryParameters, Type = stringType, }, new () { Name = "o", Kind = CodePropertyKind.Options, Type = stringType, }); target.AddParameter(new CodeParameter { Name = "c", Kind = CodeParameterKind.RequestConfiguration, Type = new CodeType { Name = "RequestConfig", TypeDefinition = requestConfigClass, }, Optional = true, }); target.AddParameter(new CodeParameter { Name = "b", Kind = CodeParameterKind.RequestBody, Type = useComplexTypeForBody ? new CodeType { Name = "SomeComplexTypeForRequestBody", TypeDefinition = root.AddClass(new CodeClass { Name = "SomeComplexTypeForRequestBody", Kind = CodeClassKind.Model, }).First(), } : stringType, }); target.AddParameter(new CodeParameter { Name = "r", Kind = CodeParameterKind.ResponseHandler, Type = stringType, }); }
public void ParametersExtensionsReturnsValue() { var method = new CodeMethod { Name = "method1" }; method.AddParameter(new CodeParameter { Name = "param1", Kind = CodeParameterKind.Custom, }); Assert.NotNull(method.Parameters.OfKind(CodeParameterKind.Custom)); Assert.Null(method.Parameters.OfKind(CodeParameterKind.RequestBody)); }
public void Defensive() { var method = new CodeMethod { Name = "class", }; Assert.Throws <ArgumentNullException>(() => new CodeFunction(null)); Assert.Throws <InvalidOperationException>(() => new CodeFunction(method)); method.IsStatic = true; var function = new CodeFunction(method); Assert.Equal(method, function.OriginalLocalMethod); }
public CodeFunction(CodeMethod method) { if (method == null) { throw new ArgumentNullException(nameof(method)); } if (!method.IsStatic) { throw new InvalidOperationException("The original method must be static"); } EnsureElementsAreChildren(method); OriginalLocalMethod = method; }
// GET: BillPropertyModels/Create public ActionResult Create() { List <CodeMethod> list = CodeMethod.GetBillType(); List <SelectListItem> item = list.Select(c => new SelectListItem { Value = c.Id, Text = c.Description }).ToList(); ViewBag.List = item; ViewBag.BillSortList = BillSortMethod.GetBillSortMethod(base.ConnectionString); return(View()); }
public void IsOfKind() { var root = CodeNamespace.InitRootNamespace(); var method = new CodeMethod(root) { Name = "class", }; Assert.False(method.IsOfKind(CodeMethodKind.Constructor)); method.MethodKind = CodeMethodKind.Deserializer; Assert.True(method.IsOfKind(CodeMethodKind.Deserializer)); Assert.True(method.IsOfKind(CodeMethodKind.Deserializer, CodeMethodKind.Getter)); Assert.False(method.IsOfKind(CodeMethodKind.Getter)); }
private void GenerateMethodCode(CodeMethod methodDecl) { foreach (CodeComment commentDecl in methodDecl.Comments) { GenerateCommentCode(commentDecl); } WriteCustomAttributes(methodDecl.CustomAttributes); WriteAttributes(methodDecl.Attributes); Output.Write(GetClrTypeName(methodDecl.RetVal.Type)); Output.Write(" "); Output.Write(methodDecl.Name); Output.Write("("); var args = new List <string>(methodDecl.Parameters.Count); foreach (CodeMethodParameter param in methodDecl.Parameters) { string modifier = string.Empty; if (param.Direction == CodeMethodParameterDirection.Ref) { modifier = "ref "; } else if (param.Direction == CodeMethodParameterDirection.Out) { modifier = "out "; } string customAttributes = string.Join(", ", param.CustomAttributes.Select(a => a.ToString())); if (customAttributes != null && customAttributes.Length > 0) { customAttributes = "[" + customAttributes + "]"; } args.Add(string.Format("{3}{0}{1} {2}", modifier, GetClrTypeName(param.Type), param.Name, customAttributes)); } Output.Write(string.Join(", ", args)); //Output.Write(string.Join(", ", methodDecl.Parameters.Select(arg => GetClrTypeName(arg.Type) + " " + arg.Name))); Output.Write(")"); if (methodDecl.NoBody) { Output.WriteLine(";"); return; } WriteBlockStart(CodeGenBlockType.Method); GenerateMethodBodyCode(methodDecl.Body); WriteBlockEnd(CodeGenBlockType.Method); }
static void GenerateBeginMethodImpl(CodeClass c, MethodInfo beginProcessMethod, string name, MethodInfo mi) { CodeMethod m = c.ImplementMethod(mi); CodeBuilder b = m.CodeBuilder; // object [] parameters = new object [x]; // parameters [0] = arg1; // parameters [1] = arg2; // ... // (return) BeginProcess (Contract.Operations [operName].BeginMethod, operName, parameters, asyncCallback, userState); ParameterInfo [] pinfos = mi.GetParameters(); CodeVariableDeclaration paramsDecl = new CodeVariableDeclaration(typeof(object []), "parameters"); b.CurrentBlock.Add(paramsDecl); CodeVariableReference paramsRef = paramsDecl.Variable; b.Assign(paramsRef, new CodeNewArray(typeof(object), new CodeLiteral(pinfos.Length - 2))); for (int i = 0; i < pinfos.Length - 2; i++) { ParameterInfo par = pinfos [i]; if (!par.IsOut) { b.Assign( new CodeArrayItem(paramsRef, new CodeLiteral(i)), new CodeCast(typeof(object), m.GetArg(i))); } } #if USE_OD_REFERENCE_IN_PROXY CodePropertyReference argMethodInfo = GetOperationMethod(m, b, name, "BeginMethod"); #else CodeMethodCall argMethodInfo = new CodeMethodCall(typeof(MethodBase), "GetCurrentMethod"); #endif CodeLiteral argOperName = new CodeLiteral(name); ParameterInfo p = pinfos [pinfos.Length - 2]; CodeArgumentReference callbackRef = new CodeArgumentReference(typeof(AsyncCallback), p.Position + 1, p.Name); p = pinfos [pinfos.Length - 1]; CodeArgumentReference stateRef = new CodeArgumentReference(typeof(object), p.Position + 1, p.Name); CodeVariableDeclaration retValueDecl = new CodeVariableDeclaration(mi.ReturnType, "retValue"); b.CurrentBlock.Add(retValueDecl); CodeVariableReference retValue = retValueDecl.Variable; b.Assign(retValue, new CodeCast(mi.ReturnType, b.CallFunc(m.GetThis(), beginProcessMethod, argMethodInfo, argOperName, paramsRef, callbackRef, stateRef))); b.Return(retValue); }
public void ClonesParameters() { var method = new CodeMethod { Name = "method1" }; method.AddParameter(new CodeParameter { Name = "param1" }); var clone = method.Clone() as CodeMethod; Assert.Equal(method.Name, clone.Name); Assert.Single(method.Parameters); Assert.Equal(method.Parameters.First().Name, clone.Parameters.First().Name); }
protected override CodeElement CreateCodeElement(string name, string fullName, CodeLocation location, CodeElement parent) { CodeMethod method = new CodeMethod(name, fullName, location, parent); return method; }