/// <summary> /// Obtiene una tabla con los métodos /// </summary> private void GetTableMethods(MLNode objMLRoot, DocumentFileModel objDocument) { LanguageStructModelCollection objColStructs = base.SelectItemsForGeneration(objDocument, LanguageStructModel.StructType.Method); if (objColStructs != null && objColStructs.Count > 0) { MLNode objMLTable; // Cabecera objMLRoot.Nodes.Add("br"); objMLRoot.Nodes.Add("h3", "Métodos"); // Cabecera de tabla objMLTable = MLBuilder.AddTable(objMLRoot, "Ambito", "Nombre", "Descripción"); // Recorre los métodos foreach (LanguageStructModel objStruct in objColStructs) { MethodModel objMethod = objStruct as MethodModel; // Añade los datos del método if (objMethod != null) { // Cabecera MLBuilder.AddRowTable(objMLTable, MLBuilderHelper.GetModifierText(objMethod.Modifier), objMethod.Name, objMethod.RemarksXml.Summary); // Comentarios AddRowRemarks(objMLTable, objMethod.RemarksXml.Remarks, 1, 2); // Prototipo AddRowRemarks(objMLTable, MLBuilderHelper.GetMethodPrototype(objMethod, objMethod.IsAsync, objMethod.ReturnType), 1, 2); // Argumentos if (objMethod.Arguments.Count > 0) { MLBuilder.AddRowNode(objMLTable, GetListArguments(objMethod), 1, 2); } // Valor devuelto MLBuilder.AddRowNode(objMLTable, GetListReturnData(objMethod, objMethod.ReturnType), 1, 2); } } } }
private void ValidatePathParams(MethodModel method, string?path) { if (path == null) { path = string.Empty; } var pathParams = method.Parameters.Where(x => x.PathAttribute != null).ToList(); // Check that there are no duplicate param names in the attributes var duplicateParams = pathParams.GroupBy(x => x.PathAttributeName !).Where(x => x.Count() > 1); foreach (var @params in duplicateParams) { this.diagnostics.ReportMultiplePathParametersForKey(method, @params.Key, @params); } // Check that each placeholder has a matching attribute, and vice versa // We allow a property param to fill in for a missing path param, but we allow them to duplicate // each other (the path param takes precedence), and allow a property param which doesn't have a placeholder. var placeholders = pathParamMatch.Matches(path).Cast <Match>().Select(x => x.Groups[1].Value).ToList(); var missingParams = placeholders .Except(pathParams.Select(x => x.PathAttributeName !).Concat(this.typeModel.Properties.Select(x => x.PathAttributeName !))); foreach (string missingParam in missingParams) { this.diagnostics.ReportMissingPathPropertyOrParameterForPlaceholder(method, missingParam); } var missingPlaceholders = pathParams.Select(x => x.PathAttributeName !).Except(placeholders); foreach (string missingPlaceholder in missingPlaceholders) { var parameters = pathParams.Where(x => x.PathAttributeName == missingPlaceholder); this.diagnostics.ReportMissingPlaceholderForPathParameter(method, missingPlaceholder, parameters); } }
public void ComplexMethodOne() { var disposable = MethodModel.MethodThree(); SerialDisposable.Disposable = disposable; // First Disposable DisposableTestContainer.Add( Subject .StartWith("TestString") .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(_ => { // Second disposable; note the StartWith meaning the subject doesn't have to fire for this to be hit MethodOne(); _intValue = MultiplyByTwo(73); }, exception => { }, () => _intValue = MultiplyByTwo(_intValue))); // Third disposable DisposableTestContainer.Add(disposable); }
private MethodModel GetMethod(MethodInfo methodInfo) { var model = new MethodModel(methodInfo) { RequestAttribute = Get <RequestAttributeBase>(), AllowAnyStatusCodeAttribute = Get <AllowAnyStatusCodeAttribute>(), SerializationMethodsAttribute = Get <SerializationMethodsAttribute>(), IsDisposeMethod = methodInfo == MethodInfos.IDisposable_Dispose, }; model.HeaderAttributes.AddRange(methodInfo.GetCustomAttributes <HeaderAttribute>() .Select(x => AttributeModel.Create(x, methodInfo))); model.Parameters.AddRange(methodInfo.GetParameters().Select(this.GetParameter)); return(model); AttributeModel <T>?Get <T>() where T : Attribute { var attribute = methodInfo.GetCustomAttribute <T>(); return(attribute == null ? null : AttributeModel.Create(attribute, methodInfo)); } }
protected virtual M GenerateMethod <M>(MethodModel model, M method) where M : BaseMethodDeclarationSyntax { method = GenerateMemberAttributes(model, method); foreach (var p in model.Parameters) { var parameter = _syntaxGenerator.ParameterDeclaration(p.Name, p.Type.Syntax) as ParameterSyntax; method = method.AddParameterListParameters(parameter) as M; } if (!model.IsAbstract) { if (model.Body != null) { method = method.AddBodyStatements(model.Body.ToArray()) as M; } } else { method = method.WithBody(null).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)) as M; } return(method); }
public BaseMethodModel MapDown(MethodModel model, Type methodModelType) { object methodModel = Activator.CreateInstance(methodModelType); PropertyInfo nameProperty = methodModelType.GetProperty("Name"); PropertyInfo extensionProperty = methodModelType.GetProperty("Extension"); PropertyInfo genericArgumentsProperty = methodModelType.GetProperty("GenericArguments", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); PropertyInfo modifiersProperty = methodModelType.GetProperty("Modifiers"); PropertyInfo parametersProperty = methodModelType.GetProperty("Parameters", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); PropertyInfo returnTypeProperty = methodModelType.GetProperty("ReturnType", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); nameProperty?.SetValue(methodModel, model.Name); extensionProperty?.SetValue(methodModel, model.Extension); if (model.GenericArguments != null) { genericArgumentsProperty?.SetValue(methodModel, HelperClass.ConvertList(genericArgumentsProperty.PropertyType.GetGenericArguments()[0], model.GenericArguments.Select(t => TypeModelMapper.EmitBaseType(t, genericArgumentsProperty.PropertyType.GetGenericArguments()[0])).ToList())); } modifiersProperty?.SetValue(methodModel, model.Modifiers); if (model.Parameters != null) { parametersProperty?.SetValue(methodModel, HelperClass.ConvertList(parametersProperty.PropertyType.GetGenericArguments()[0], model.Parameters.Select(p => new ParameterModelMapper().MapDown(p, parametersProperty.PropertyType.GetGenericArguments()[0])).ToList())); } if (model.ReturnType != null) { returnTypeProperty?.SetValue(methodModel, returnTypeProperty.PropertyType.Cast(TypeModelMapper.EmitBaseType(model.ReturnType, returnTypeProperty.PropertyType))); } return((BaseMethodModel)methodModel); }
protected string GetMethodName(MethodModel methodModel) { var name = methodModel.Name.ToLower(); switch (name) { case "get": return("getBy" + GetPascalCase(methodModel.Parameters.FirstOrDefault()?.Name)); case "post": return("post" + GetPascalCase(methodModel.Parameters.FirstOrDefault()?.Name)); case "put": var parameter = methodModel.Parameters.FirstOrDefault(); if (methodModel.Parameters.Count > 1 && parameter?.Name.ToLower() == "id") { parameter = methodModel.Parameters[1]; } return("put" + GetPascalCase(parameter?.Name)); default: return(GetCamelCase(methodModel.Name)); } }
public static MethodDbModel EmitUniqueType(MethodModel model) { return(UniqueEmitter.EmitType(model, propertyModel => new MethodDbModel(propertyModel))); }
private static ApiDescription CreateApiDescription( RouteEndpoint routeEndpoint, MethodModel methodModel, HttpMethodAttribute httpMethodAttribute) { var apiDescription = new ApiDescription { HttpMethod = httpMethodAttribute.Method, ActionDescriptor = new ActionDescriptor { RouteValues = new Dictionary <string, string> { // Swagger uses this to group endpoints together. // Group methods together using the service name. ["controller"] = methodModel.MethodInfo.DeclaringType?.Name ?? string.Empty } }, RelativePath = routeEndpoint.RoutePattern.RawText?.TrimStart('/') ?? string.Empty }; apiDescription.SupportedRequestFormats.Add(new ApiRequestFormat { MediaType = "application/json" }); var responseTypes = methodModel.MethodInfo .GetCustomAttributes(typeof(ProducesResponseTypeAttribute), false) .OfType <ProducesResponseTypeAttribute>(); var addDefaultResponseType = true; foreach (var responseType in responseTypes) { addDefaultResponseType = false; apiDescription.SupportedResponseTypes.Add(new ApiResponseType { ApiResponseFormats = { new ApiResponseFormat { MediaType = "application/json" } }, ModelMetadata = responseType.Type == null ? null : new ExpressModelMetadata(responseType.Type), StatusCode = responseType.StatusCode, }); } if (addDefaultResponseType) { apiDescription.SupportedResponseTypes.Add(new ApiResponseType { ApiResponseFormats = { new ApiResponseFormat { MediaType = "application/json" } }, StatusCode = 200, }); } foreach (var parameter in methodModel.Parameters) { apiDescription.ParameterDescriptions.Add(new ApiParameterDescription { Name = parameter.Name ?? "Input", ModelMetadata = new ExpressModelMetadata(parameter.ParameterType), Source = parameter.GetBindingSource() }); } return(apiDescription); }
private void Generate(MethodModel method) { // [DebuggerStepThrough] WriteLine($"[{typeof(DebuggerStepThroughAttribute)}]"); var methodStartIndex = _codeBuilder.Length + 4 * _indent; WriteLine($"public async {typeof(Task)} {method.UniqueName}({typeof(HttpContext)} httpContext)"); WriteLine("{"); Indent(); var ctors = _model.HandlerType.GetConstructors(); if (!method.MethodInfo.IsStatic) { if (ctors.Length > 1 || ctors[0].GetParameters().Length > 0) { // Lazy, defer to DI system if WriteLine($"var handler = ({S(_model.HandlerType)})_factory(httpContext.RequestServices, {typeof(Array)}.Empty<{typeof(object)}>());"); } else { WriteLine($"var handler = new {S(_model.HandlerType)}();"); } } // Declare locals var hasAwait = false; var hasFromBody = false; var hasFromForm = false; foreach (var parameter in method.Parameters) { var parameterName = "arg_" + parameter.Name.Replace("_", "__"); if (parameter.ParameterType.Equals(typeof(HttpContext))) { WriteLine($"var {parameterName} = httpContext;"); } else if (parameter.ParameterType.Equals(typeof(IFormCollection))) { WriteLine($"var {parameterName} = await httpContext.Request.ReadFormAsync();"); hasAwait = true; } else if (parameter.FromRoute != null) { GenerateConvert(parameterName, parameter.ParameterType, parameter.FromRoute, "httpContext.Request.RouteValues", nullable: true); } else if (parameter.FromQuery != null) { GenerateConvert(parameterName, parameter.ParameterType, parameter.FromQuery, "httpContext.Request.Query"); } else if (parameter.FromHeader != null) { GenerateConvert(parameterName, parameter.ParameterType, parameter.FromHeader, "httpContext.Request.Headers"); } else if (parameter.FromServices) { WriteLine($"var {parameterName} = httpContext.RequestServices.GetRequiredService<{S(parameter.ParameterType)}>();"); } else if (parameter.FromForm != null) { if (!hasFromForm) { WriteLine($"var formCollection = await httpContext.Request.ReadFormAsync();"); hasAwait = true; hasFromForm = true; } GenerateConvert(parameterName, parameter.ParameterType, parameter.FromForm, "formCollection"); } else if (parameter.FromBody) { if (!hasFromBody) { hasFromBody = true; } if (!parameter.ParameterType.Equals(typeof(JsonElement))) { FromBodyTypes.Add(parameter.ParameterType); } WriteLine($"var {parameterName} = await httpContext.Request.ReadFromJsonAsync<{S(parameter.ParameterType)}>();"); hasAwait = true; } else { WriteLine($"{S(parameter.ParameterType)} {parameterName} = default;"); } } AwaitableInfo awaitableInfo = default; // Populate locals if (method.MethodInfo.ReturnType.Equals(typeof(void))) { Write(""); } else { if (AwaitableInfo.IsTypeAwaitable(method.MethodInfo.ReturnType, out awaitableInfo)) { if (awaitableInfo.ResultType.Equals(typeof(void))) { if (hasAwait) { Write("await "); } else { Write("return "); } } else { Write("var result = await "); hasAwait = true; } } else { Write("var result = "); } } WriteNoIndent($"{(method.MethodInfo.IsStatic ? S(_model.HandlerType) : "handler")}.{method.MethodInfo.Name}("); bool first = true; foreach (var parameter in method.Parameters) { var parameterName = "arg_" + parameter.Name.Replace("_", "__"); if (!first) { WriteNoIndent(", "); } WriteNoIndent(parameterName); first = false; } WriteLineNoIndent(");"); if (!hasAwait) { // Remove " async" from method signature. _codeBuilder.Remove(methodStartIndex + 6, 6); } void AwaitOrReturn(string executeAsync) { if (hasAwait) { Write("await "); } else { Write("return "); } WriteLineNoIndent(executeAsync); } var unwrappedType = awaitableInfo.ResultType ?? method.MethodInfo.ReturnType; if (_metadataLoadContext.Resolve <IResult>().IsAssignableFrom(unwrappedType)) { AwaitOrReturn("result.ExecuteAsync(httpContext);"); } else if (unwrappedType.Equals(typeof(string))) { AwaitOrReturn($"httpContext.Response.WriteAsync(result);"); } else if (!unwrappedType.Equals(typeof(void))) { AwaitOrReturn($"httpContext.Response.WriteAsJsonAsync(result);"); } else if (!hasAwait && method.MethodInfo.ReturnType.Equals(typeof(void))) { // If awaitableInfo.ResultType is void, we've already returned the awaitable directly. WriteLine($"return {typeof(Task)}.CompletedTask;"); } Unindent(); WriteLine("}"); WriteLine(""); }
public async Task <IActionResult> AddMethod([FromBody] MethodModel method) { logger.LogWarning($"POST: Methods: MethodName: {method.Name}"); return(Json(await tests.SaveMethod(method))); }
public void CanConstruct() { var instance = new MethodModel(_name, _parameters, _node, _model); Assert.That(instance, Is.Not.Null); }
private void GenerateMethodParameters(MethodEmitter methodEmitter, MethodModel method, ResolvedSerializationMethods serializationMethods) { foreach (var parameter in method.Parameters) { var attributes = parameter.GetAllSetAttributes().ToList(); if (parameter.IsByRef) { this.diagnostics.ReportParameterMustNotBeByRef(method, parameter); } if (parameter.IsCancellationToken) { if (attributes.Count > 0) { this.diagnostics.ReportCancellationTokenMustHaveZeroAttributes(method, parameter); } methodEmitter.EmitSetCancellationToken(parameter); } else { if (attributes.Count > 1) { this.diagnostics.ReportParameterMustHaveZeroOrOneAttributes(method, parameter, attributes); } if (parameter.HeaderAttribute != null) { if (parameter.HeaderAttribute.Attribute.Value != null) { this.diagnostics.ReportHeaderParameterMustNotHaveValue(method, parameter); } if (parameter.HeaderAttribute.Attribute.Name.Contains(":")) { this.diagnostics.ReportHeaderParameterMustNotHaveColonInName(method, parameter); } methodEmitter.EmitAddHeaderParameter(parameter); } else if (parameter.PathAttribute != null) { methodEmitter.EmitAddPathParameter( parameter, serializationMethods.ResolvePath(parameter.PathAttribute.Attribute.SerializationMethod)); } else if (parameter.QueryAttribute != null) { methodEmitter.EmitAddQueryParameter( parameter, serializationMethods.ResolveQuery(parameter.QueryAttribute.Attribute.SerializationMethod)); } else if (parameter.HttpRequestMessagePropertyAttribute != null) { methodEmitter.EmitAddHttpRequestMessagePropertyParameter(parameter); } else if (parameter.RawQueryStringAttribute != null) { methodEmitter.EmitAddRawQueryStringParameter(parameter); } else if (parameter.QueryMapAttribute != null) { if (!methodEmitter.TryEmitAddQueryMapParameter(parameter, serializationMethods.ResolveQuery(parameter.QueryMapAttribute.Attribute.SerializationMethod))) { this.diagnostics.ReportQueryMapParameterIsNotADictionary(method, parameter); } } else if (parameter.BodyAttribute != null) { methodEmitter.EmitSetBodyParameter( parameter, serializationMethods.ResolveBody(parameter.BodyAttribute.Attribute.SerializationMethod)); } else { methodEmitter.EmitAddQueryParameter(parameter, serializationMethods.ResolveQuery(QuerySerializationMethod.Default)); } } } }
private void Generate(MethodModel method) { // [DebuggerStepThrough] WriteLine($"[{S(typeof(DebuggerStepThroughAttribute))}]"); WriteLine($"public async {S(typeof(Task))} {method.MethodInfo.Name}({S(typeof(HttpContext))} httpContext)"); WriteLine("{"); Indent(); var ctors = _model.HandlerType.GetConstructors(); if (ctors.Length > 1 || ctors[0].GetParameters().Length > 0) { // Lazy, defer to DI system if WriteLine($"var handler = ({S(_model.HandlerType)})_factory(httpContext.RequestServices, {S(typeof(Array))}.Empty<{S(typeof(object))}>());"); } else { WriteLine($"var handler = new {S(_model.HandlerType)}();"); } // Declare locals var hasFromBody = false; var hasFromForm = false; foreach (var parameter in method.Parameters) { var parameterName = "arg_" + parameter.Name.Replace("_", "__"); if (parameter.ParameterType.Equals(typeof(HttpContext))) { WriteLine($"var {parameterName} = httpContext;"); } else if (parameter.ParameterType.Equals(typeof(IFormCollection))) { WriteLine($"var {parameterName} = await httpContext.Request.ReadFormAsync();"); } else if (parameter.FromRoute != null) { GenerateConvert(parameterName, parameter.ParameterType, parameter.FromRoute, "httpContext.Request.RouteValues", nullable: true); } else if (parameter.FromQuery != null) { GenerateConvert(parameterName, parameter.ParameterType, parameter.FromQuery, "httpContext.Request.Query"); } else if (parameter.FromHeader != null) { GenerateConvert(parameterName, parameter.ParameterType, parameter.FromHeader, "httpContext.Request.Headers"); } else if (parameter.FromServices) { WriteLine($"var {parameterName} = httpContext.RequestServices.GetRequiredService<{S(parameter.ParameterType)}>();"); } else if (parameter.FromForm != null) { if (!hasFromForm) { WriteLine($"var formCollection = await httpContext.Request.ReadFormAsync();"); hasFromForm = true; } GenerateConvert(parameterName, parameter.ParameterType, parameter.FromForm, "formCollection"); } else if (parameter.FromBody) { if (!hasFromBody) { WriteLine($"var reader = httpContext.RequestServices.GetService<{S(typeof(IHttpRequestReader))}>() ?? _requestReader;"); hasFromBody = true; } if (!parameter.ParameterType.Equals(typeof(JsonElement))) { FromBodyTypes.Add(parameter.ParameterType); } WriteLine($"var {parameterName} = ({S(parameter.ParameterType)})await reader.ReadAsync(httpContext, typeof({S(parameter.ParameterType)}));"); } } AwaitableInfo awaitableInfo = default; // Populate locals if (method.MethodInfo.ReturnType.Equals(typeof(void))) { Write(""); } else { if (AwaitableInfo.IsTypeAwaitable(method.MethodInfo.ReturnType, out awaitableInfo)) { if (awaitableInfo.ResultType.Equals(typeof(void))) { Write("await "); } else { Write("var result = await "); } } else { Write("var result = "); } } WriteNoIndent($"handler.{method.MethodInfo.Name}("); bool first = true; foreach (var parameter in method.Parameters) { var parameterName = "arg_" + parameter.Name.Replace("_", "__"); if (!first) { WriteNoIndent(", "); } WriteNoIndent(parameterName); first = false; } WriteLineNoIndent(");"); var unwrappedType = awaitableInfo.ResultType ?? method.MethodInfo.ReturnType; if (_metadataLoadContext.Resolve <Result>().IsAssignableFrom(unwrappedType)) { WriteLine("await result.ExecuteAsync(httpContext);"); } else if (!unwrappedType.Equals(typeof(void))) { WriteLine($"await new {S(typeof(ObjectResult))}(result).ExecuteAsync(httpContext);"); } Unindent(); WriteLine("}"); WriteLine(""); }
static void AddPartitionDefinition(OutputModel outputModel, DatabasePlan databasePlan, MethodModel methodModel, string name) { if (databasePlan.PartitionPlansByName.TryGetValue(name, out var partitionPlan)) { if (!SymbolEqualityComparer.Default.Equals(partitionPlan.GetPkModel.MethodSymbol, methodModel.MethodSymbol)) { outputModel.Report(Diagnostics.Errors.PartitionAlreadyDefined, methodModel.MethodSymbol); } } else { partitionPlan = new PartitionPlan { Name = name, PluralName = name.Pluralize(), ClassName = name.WithSuffix(Suffixes.Partition), BatchHandlersClassName = name.WithSuffix(Suffixes.BatchHandlers), CreateOrReplaceClassName = name.WithSuffix(Suffixes.CreateOrReplace), ReadClassName = name.WithSuffix(Suffixes.Read), ReadOrThrowClassName = name.WithSuffix(Suffixes.ReadOrThrow), ReadManyClassName = name.WithSuffix(Suffixes.ReadMany), ReadUnionsClassName = name.WithSuffix(Suffixes.ReadUnions), ReadOrThrowUnionsClassName = name.WithSuffix(Suffixes.ReadOrThrowUnions), ReadManyUnionsClassName = name.WithSuffix(Suffixes.ReadManyUnions), QueryBuilderClassName = name.WithSuffix(Suffixes.QueryBuilder), QueryBuilderUnionsClassName = name.WithSuffix(Suffixes.QueryBuilderUnions), QueryClassName = name.WithSuffix(Suffixes.Query), QueryUnionsClassName = name.WithSuffix(Suffixes.QueryUnions), ReadOrCreateClassName = name.WithSuffix(Suffixes.ReadOrCreate), CreateClassName = name.WithSuffix(Suffixes.Create), BatchClassName = name.WithSuffix(Suffixes.Batch), GetPkModel = methodModel }; partitionPlan.BatchHandlersClassNameArgument = partitionPlan.BatchHandlersClassName.ToArgumentName(); partitionPlan.ClassNameArgument = partitionPlan.ClassName.ToArgumentName(); databasePlan.PartitionPlansByName[name] = partitionPlan; partitionPlan.QueryBuilderClassNameArgument = partitionPlan.QueryBuilderClassName.ToArgumentName(); outputModel.ValidateNames( methodModel.MethodSymbol, partitionPlan.Name, partitionPlan.PluralName, partitionPlan.ClassName, partitionPlan.BatchHandlersClassName, partitionPlan.CreateOrReplaceClassName, partitionPlan.ReadClassName, partitionPlan.ReadOrThrowClassName, partitionPlan.ReadManyClassName, partitionPlan.QueryBuilderClassName, partitionPlan.QueryClassName, partitionPlan.ReadOrCreateClassName, partitionPlan.CreateClassName, partitionPlan.BatchClassName, partitionPlan.QueryBuilderUnionsClassName, partitionPlan.QueryUnionsClassName, partitionPlan.ReadManyUnionsClassName, partitionPlan.ReadOrThrowUnionsClassName, partitionPlan.ReadUnionsClassName); outputModel.ValidateIdentifiers( methodModel.MethodSymbol, partitionPlan.ClassNameArgument, partitionPlan.BatchHandlersClassNameArgument, partitionPlan.QueryBuilderClassNameArgument); } }
public void ReportMissingPlaceholderForPathParameter(MethodModel _, string placeholder, IEnumerable <ParameterModel> parameters) { this.AddDiagnostic(missingPlaceholderForPathParameter, parameters.SelectMany(x => SymbolLocations(x.ParameterSymbol)), placeholder); }
public void ReportMissingPathPropertyOrParameterForPlaceholder(MethodModel method, string placeholder) { // We'll put the squiggle on the attribute itself this.AddDiagnostic(missingPathPropertyOrParameterForPlaceholder, AttributeLocations(method.RequestAttribute, method.MethodSymbol), placeholder); }
public void ReportMultiplePathParametersForKey(MethodModel _, string key, IEnumerable <ParameterModel> parameters) { this.AddDiagnostic(multiplePathParametersForKey, parameters.SelectMany(x => SymbolLocations(x.ParameterSymbol)), key); }
public void ReportMethodMustHaveRequestAttribute(MethodModel method) { this.AddDiagnostic(methodMustHaveRequestAttribute, method.MethodSymbol.Locations); }
/// <summary> /// Obtiene el prototipo de un método Get o Set de una propiedad /// </summary> private string GetPropertyMethodPrototype(LanguageStructModel.ModifierType modifier, MethodModel method, string methodName) { string prototype = string.Empty; // Añade los datos al prototipo if (method != null) { // Añade el modificador (si es distinto al de la propiedad, es decir: public Property { private set } if (modifier != method.Modifier) { prototype += GetModifierText(method.Modifier) + " "; } // Añade el nombre prototype = methodName + ";"; } // Devuelve el prototipo return(prototype); }
/// <summary> /// Convierte un método /// </summary> private StructDocumentationModel ConvertMethod(StructDocumentationModel parent, MethodModel item) { StructDocumentationModel structDoc = Create(parent, item, "Method"); // Añade los argumentos structDoc.Parameters.Add(GetPrototype(item)); AddListArguments(structDoc, item, item.Arguments); AddListTypeParameter(structDoc, item.TypeParameters); // Añade el valor de retorno structDoc.Childs.Add(GetReturnValue(structDoc, item.ReturnType, ConvertRemarks(item.RemarksXml.Returns))); // Devuelve la estructura return(structDoc); }
public void AddMethod(MethodModel method) { Methods.Add(method); }
static void Validate(OutputModel outputModel, ClassModel classModel, MethodModel model) { }
public void ReportQueryMapParameterIsNotADictionary(MethodModel _, ParameterModel parameter) { this.AddDiagnostic(queryMapParameterIsNotADictionary, SymbolLocations(parameter.ParameterSymbol)); }
private void GenerateMethod(TypeEmitter typeEmitter, List <EmittedProperty> emittedProperties, MethodModel method) { var methodEmitter = typeEmitter.EmitMethod(method); var serializationMethods = new ResolvedSerializationMethods(this.typeModel.SerializationMethodsAttribute?.Attribute, method.SerializationMethodsAttribute?.Attribute); if (method.RequestAttribute == null) { this.diagnostics.ReportMethodMustHaveRequestAttribute(method); } else { string?path = method.RequestAttribute.Attribute.Path; this.ValidatePathParams(method, path); this.ValidateCancellationTokenParams(method); this.ValidateMultipleBodyParams(method); this.ValidateHttpRequestMessageParams(method); methodEmitter.EmitRequestInfoCreation(method.RequestAttribute.Attribute); var resolvedAllowAnyStatusCode = method.AllowAnyStatusCodeAttribute ?? this.typeModel.TypeAllowAnyStatusCodeAttribute; if (resolvedAllowAnyStatusCode?.Attribute.AllowAnyStatusCode == true) { methodEmitter.EmitSetAllowAnyStatusCode(); } if (this.typeModel.BasePathAttribute?.Attribute.BasePath != null) { methodEmitter.EmitSetBasePath(this.typeModel.BasePathAttribute.Attribute.BasePath); } this.GenerateMethodProperties(methodEmitter, emittedProperties, serializationMethods); foreach (var methodHeader in method.HeaderAttributes) { if (methodHeader.Attribute.Name.Contains(":")) { this.diagnostics.ReportHeaderOnMethodMustNotHaveColonInName(method, methodHeader); } methodEmitter.EmitAddMethodHeader(methodHeader); } this.GenerateMethodParameters(methodEmitter, method, serializationMethods); if (!methodEmitter.TryEmitRequestMethodInvocation()) { this.diagnostics.ReportMethodMustHaveValidReturnType(method); } } }
public void ReportMethodMustHaveValidReturnType(MethodModel method) { this.AddDiagnostic(methodMustHaveValidReturnType, method.MethodSymbol.Locations); }
public void ReportParameterMustNotBeByRef(MethodModel _, ParameterModel parameter) { this.AddDiagnostic(parameterMustNotBeByRef, SymbolLocations(parameter.ParameterSymbol), parameter.Name); }
private ICollection <MethodModel> GetMethods(Type type, TypeModel parent) { var list = new List <MethodModel>(); // Used for ID generation var methodNames = new List <string>(); // Get only methods for this object, none of the inherited methods. foreach (var methodInfo in type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance)) { try { if (!methodInfo.IsSpecialName) { var method = new MethodModel { Parent = parent, ParentClass = parent.Id, Name = methodInfo.Name, }; // Contains overloads - ID is the hashcode if (methodNames.Contains(methodInfo.Name)) { method.UseHashCodeForId = true; } methodNames.Add(methodInfo.Name); if (methodInfo.IsGenericMethod) { var arguments = methodInfo.GetGenericArguments().Select(genericType => genericType.Name).ToList(); method.Name = $"{methodInfo.Name}<{string.Join(",", arguments)}>"; method.UseHashCodeForId = true; } try { method.FullName = methodInfo.ToString(); method.ReturnType = GetTypeName(methodInfo.ReturnType); method.ReturnTypeFullName = GetFullTypeName(methodInfo.ReturnType); // Get common tags var element = xmlDocCommentReader.GetComments(methodInfo.IsGenericMethod ? methodInfo.GetGenericMethodDefinition() : methodInfo); var comments = GetCommonTags(element); method.Example = comments.Example; method.Remarks = comments.Remarks; method.Returns = comments.Returns; method.Summary = comments.Summary; method.Parameters = GetMethodParameters(methodInfo.GetParameters(), element); // Parameters } catch (Exception x) { method.LoadError = true; method.FullName = x.Message; } list.Add(method); } } catch (Exception x) { Trace.TraceError($"Type {type} : Parse methods Problem. {x.Message} => {x.Source}"); } } return(list.OrderBy(x => x.Name).ToList()); }
public MethodTreeItem(MethodModel methodModel) : base(GetModifiers(methodModel) + methodModel.Name) { MethodModel = methodModel; }
public void ReportMultipleBodyParameters(MethodModel _, IEnumerable <ParameterModel> parameters) { this.AddDiagnostic(multipleBodyParameters, parameters.SelectMany(x => SymbolLocations(x.ParameterSymbol))); }