private static MethodDeclarationSyntax CreateTypeRequestWithMessageAllowNull( string className, HttpStatusCode httpStatusCode, string typeRequestName, string parameterName = "message") { return(SyntaxFactory.MethodDeclaration( SyntaxFactory.IdentifierName(className), SyntaxFactory.Identifier(httpStatusCode.ToNormalizedString())) .WithModifiers(SyntaxTokenListFactory.PublicStaticKeyword()) .WithParameterList( SyntaxFactory.ParameterList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Parameter(SyntaxFactory.Identifier(parameterName)) .WithType(SyntaxFactory.NullableType(SyntaxFactory.PredefinedType(SyntaxTokenFactory.StringKeyword()))) .WithDefault( SyntaxFactory.EqualsValueClause( SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)))))) .WithExpressionBody( SyntaxFactory.ArrowExpressionClause( SyntaxObjectCreationExpressionFactory.Create(className) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxObjectCreationExpressionFactory.Create(typeRequestName) .WithArgumentList( SyntaxArgumentListFactory.CreateWithOneItem(parameterName)))))))) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))); }
private MemberDeclarationSyntax CreateInvokeExecuteAsyncMethod( string parameterTypeName, string resultTypeName, bool hasParameters) { var arguments = hasParameters ? new SyntaxNodeOrToken[] { SyntaxParameterFactory.Create(parameterTypeName, "parameters"), SyntaxTokenFactory.Comma(), SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()), } : new SyntaxNodeOrToken[] { SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()), }; var bodyBlockSyntaxStatements = CreateBodyBlockSyntaxStatements(resultTypeName); return(SyntaxFactory.MethodDeclaration( SyntaxFactory.GenericName(SyntaxFactory.Identifier(nameof(Task))) .WithTypeArgumentList( SyntaxFactory.TypeArgumentList( SyntaxFactory.SingletonSeparatedList <TypeSyntax>( SyntaxFactory.IdentifierName(EndpointResultTypeName)))), SyntaxFactory.Identifier("InvokeExecuteAsync")) .WithModifiers(SyntaxTokenListFactory.PrivateAsyncKeyword()) .WithParameterList( SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(arguments))) .WithBody( SyntaxFactory.Block(bodyBlockSyntaxStatements))); }
private MemberDeclarationSyntax CreateExecuteAsyncMethod( string parameterTypeName, bool hasParameters) { var arguments = hasParameters ? new SyntaxNodeOrToken[] { SyntaxParameterFactory.Create(parameterTypeName, "parameters"), SyntaxTokenFactory.Comma(), SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()) .WithDefault(SyntaxFactory.EqualsValueClause( SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, SyntaxTokenFactory.DefaultKeyword()))), } : new SyntaxNodeOrToken[] { SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()) .WithDefault(SyntaxFactory.EqualsValueClause( SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, SyntaxTokenFactory.DefaultKeyword()))), }; return(SyntaxFactory.MethodDeclaration( SyntaxFactory.GenericName(SyntaxFactory.Identifier(nameof(Task))) .WithTypeArgumentList( SyntaxFactory.TypeArgumentList( SyntaxFactory.SingletonSeparatedList <TypeSyntax>( SyntaxFactory.IdentifierName(EndpointResultTypeName)))), SyntaxFactory.Identifier("ExecuteAsync")) .WithModifiers(SyntaxTokenListFactory.PublicKeyword()) .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(arguments))) .WithSemicolonToken(SyntaxTokenFactory.Semicolon())); }
private MemberDeclarationSyntax CreatePropertyForStatusCodeContent( HttpStatusCode statusCode, string resultTypeName) => SyntaxFactory.PropertyDeclaration( SyntaxFactory.IdentifierName(resultTypeName), SyntaxFactory.Identifier(statusCode.ToNormalizedString() + "Content")) .WithModifiers(SyntaxTokenListFactory.PublicKeyword()) .WithExpressionBody( SyntaxFactory.ArrowExpressionClause( SyntaxFactory.ConditionalExpression( SyntaxFactory.BinaryExpression( SyntaxKind.LogicalAndExpression, SyntaxFactory.IdentifierName("Is" + statusCode.ToNormalizedString()), SyntaxFactory.IsPatternExpression( SyntaxFactory.IdentifierName("ContentObject"), SyntaxFactory.DeclarationPattern( SyntaxFactory.IdentifierName(resultTypeName), SyntaxFactory.SingleVariableDesignation( SyntaxFactory.Identifier("result"))))), SyntaxFactory.IdentifierName("result"), SyntaxFactory.ThrowExpression( SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName(nameof(InvalidOperationException))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal($"Content is not the expected type - please use the Is{statusCode.ToNormalizedString()} property first.")))))))))) .WithSemicolonToken(SyntaxTokenFactory.Semicolon());
private MemberDeclarationSyntax CreateFieldIHttpMessageFactory() => SyntaxFactory.FieldDeclaration( SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(nameof(IHttpMessageFactory))) .WithVariables( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.VariableDeclarator( SyntaxFactory.Identifier("httpMessageFactory"))))) .WithModifiers( SyntaxTokenListFactory.PrivateReadonlyKeyword());
public static MemberDeclarationSyntax?CreateToStringMethod(IDictionary <string, OpenApiSchema> apiSchemaProperties) { if (apiSchemaProperties == null) { throw new ArgumentNullException(nameof(apiSchemaProperties)); } var content = new List <InterpolatedStringContentSyntax>(); if (apiSchemaProperties.Count > 0) { var lastKey = apiSchemaProperties.Keys.Last(); foreach (var schema in apiSchemaProperties) { var name = schema.Key.EnsureFirstCharacterToUpper(); var hasAnyProperties = schema.Value.HasAnyProperties(); if (!hasAnyProperties) { content.Add(SyntaxInterpolatedFactory.CreateNameOf(name)); content.Add(SyntaxInterpolatedFactory.StringTextColon()); content.Add(SyntaxFactory.Interpolation(SyntaxFactory.IdentifierName(name))); } else { content.Add(SyntaxInterpolatedFactory.CreateNameOf(name)); content.Add(SyntaxInterpolatedFactory.StringTextColonAndParenthesesStart()); content.Add(SyntaxFactory.Interpolation(SyntaxFactory.IdentifierName(name))); content.Add(SyntaxInterpolatedFactory.StringTextParenthesesEnd()); } if (schema.Key != lastKey) { content.Add(SyntaxInterpolatedFactory.StringTextComma()); } } } if (content.Count == 0) { return(null); } var codeBody = SyntaxFactory.Block( SyntaxFactory.SingletonList <StatementSyntax>( SyntaxFactory.ReturnStatement( SyntaxFactory.InterpolatedStringExpression( SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken)) .WithContents(SyntaxFactory.List(content))))); return(SyntaxFactory.MethodDeclaration( SyntaxFactory.PredefinedType(SyntaxTokenFactory.StringKeyword()), SyntaxFactory.Identifier("ToString")) .WithModifiers(SyntaxTokenListFactory.PublicOverrideKeyword()) .WithBody(codeBody)); }
private MemberDeclarationSyntax CreateExecuteAsyncMethod( string parameterTypeName, string resultTypeName, bool hasParameters) { var arguments = hasParameters ? new SyntaxNodeOrToken[] { SyntaxParameterFactory.Create(parameterTypeName, "parameters"), SyntaxTokenFactory.Comma(), SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()) .WithDefault(SyntaxFactory.EqualsValueClause( SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, SyntaxTokenFactory.DefaultKeyword()))), } : new SyntaxNodeOrToken[] { SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()) .WithDefault(SyntaxFactory.EqualsValueClause( SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, SyntaxTokenFactory.DefaultKeyword()))), }; SyntaxTokenList methodModifiers; BlockSyntax codeBlockSyntax; if (hasParameters) { methodModifiers = SyntaxTokenListFactory.PublicKeyword(); codeBlockSyntax = SyntaxFactory.Block( SyntaxIfStatementFactory.CreateParameterArgumentNullCheck("parameters", false), SyntaxFactory.ReturnStatement( SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName("InvokeExecuteAsync")) .WithArgumentList( SyntaxArgumentListFactory.CreateWithTwoItems("parameters", nameof(CancellationToken).EnsureFirstCharacterToLower())))); } else { methodModifiers = SyntaxTokenListFactory.PublicAsyncKeyword(); var bodyBlockSyntaxStatements = CreateBodyBlockSyntaxStatements(resultTypeName); codeBlockSyntax = SyntaxFactory.Block(bodyBlockSyntaxStatements); } return(SyntaxFactory.MethodDeclaration( SyntaxFactory.GenericName(SyntaxFactory.Identifier(nameof(Task))) .WithTypeArgumentList( SyntaxFactory.TypeArgumentList( SyntaxFactory.SingletonSeparatedList <TypeSyntax>( SyntaxFactory.IdentifierName(EndpointResultTypeName)))), SyntaxFactory.Identifier("ExecuteAsync")) .WithModifiers(methodModifiers) .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(arguments))) .WithBody(codeBlockSyntax)); }
private MemberDeclarationSyntax CreateExecuteAsyncMethod(string parameterTypeName, string resultTypeName, bool hasParameters) { var arguments = hasParameters ? new SyntaxNodeOrToken[] { SyntaxParameterFactory.Create(parameterTypeName, "parameters"), SyntaxTokenFactory.Comma(), SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()) .WithDefault(SyntaxFactory.EqualsValueClause( SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, SyntaxTokenFactory.DefaultKeyword()))), } : new SyntaxNodeOrToken[] { SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()) .WithDefault(SyntaxFactory.EqualsValueClause( SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, SyntaxTokenFactory.DefaultKeyword()))), }; var codeBody = hasParameters ? SyntaxFactory.Block( SyntaxIfStatementFactory.CreateParameterArgumentNullCheck("parameters"), SyntaxFactory.ReturnStatement( SyntaxFactory.InvocationExpression( SyntaxFactory.IdentifierName("InvokeExecuteAsync")) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.Argument(SyntaxFactory.IdentifierName("parameters")), SyntaxTokenFactory.Comma(), SyntaxFactory.Argument(SyntaxFactory.IdentifierName(nameof(CancellationToken).EnsureFirstCharacterToLower())), }))))) : SyntaxFactory.Block( SyntaxThrowStatementFactory.CreateNotImplementedException()); return(SyntaxFactory.MethodDeclaration( SyntaxFactory.GenericName(SyntaxFactory.Identifier(nameof(Task))) .WithTypeArgumentList( SyntaxFactory.TypeArgumentList( SyntaxFactory.SingletonSeparatedList <TypeSyntax>( SyntaxFactory.GenericName( SyntaxFactory.Identifier("EndpointResult")) .WithTypeArgumentList( SyntaxFactory.TypeArgumentList( SyntaxFactory.SingletonSeparatedList <TypeSyntax>( SyntaxFactory.IdentifierName(resultTypeName))))))), SyntaxFactory.Identifier("ExecuteAsync")) .WithModifiers(SyntaxTokenListFactory.PublicKeyword()) .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(arguments))) .WithBody(codeBody)); }
private static MethodDeclarationSyntax CreateTypeRequestWithObject( string className, HttpStatusCode httpStatusCode, string typeRequestName, string parameterName = "message") { return(SyntaxFactory.MethodDeclaration( SyntaxFactory.IdentifierName(className), SyntaxFactory.Identifier(httpStatusCode.ToNormalizedString())) .WithModifiers(SyntaxTokenListFactory.PublicStaticKeyword()) .WithParameterList( SyntaxFactory.ParameterList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Parameter(SyntaxFactory.Identifier(parameterName)) .WithType(SyntaxFactory.NullableType(SyntaxFactory.PredefinedType(SyntaxTokenFactory.StringKeyword()))) .WithDefault( SyntaxFactory.EqualsValueClause( SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)))))) .WithExpressionBody( SyntaxFactory.ArrowExpressionClause( SyntaxObjectCreationExpressionFactory.Create(className) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxObjectCreationExpressionFactory.Create(typeRequestName) .WithInitializer( SyntaxFactory.InitializerExpression( SyntaxKind.ObjectInitializerExpression, SyntaxFactory.SeparatedList <ExpressionSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.IdentifierName("StatusCode"), SyntaxFactory.CastExpression( SyntaxFactory.PredefinedType( SyntaxFactory.Token(SyntaxKind.IntKeyword)), SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(nameof(HttpStatusCode)), SyntaxFactory.IdentifierName(httpStatusCode.ToNormalizedString())))), SyntaxTokenFactory.Comma(), SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.IdentifierName("Content"), SyntaxFactory.IdentifierName(parameterName)), }))))))))) .WithSemicolonToken(SyntaxTokenFactory.Semicolon())); }
private MemberDeclarationSyntax CreateFieldIHttpClientFactory() { return (SyntaxFactory.FieldDeclaration( SyntaxFactory .VariableDeclaration( SyntaxFactory.IdentifierName("IHttpClientFactory")) .WithVariables( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.VariableDeclarator( SyntaxFactory.Identifier("factory"))))) .WithModifiers( SyntaxTokenListFactory.PrivateReadonlyKeyword())); }
private static ConversionOperatorDeclarationSyntax CreateImplicitOperatorForActionResult(string className) { return(SyntaxFactory.ConversionOperatorDeclaration( SyntaxTokenFactory.ImplicitKeyword(), SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(nameof(ActionResult)))) .WithModifiers(SyntaxTokenListFactory.PublicStaticKeyword(true)) .WithOperatorKeyword(SyntaxTokenFactory.OperatorKeyword()) .AddParameterListParameters(SyntaxParameterFactory.Create(className, "x")) .WithExpressionBody(SyntaxFactory.ArrowExpressionClause( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("x"), SyntaxFactory.IdentifierName("result"))) .WithArrowToken(SyntaxTokenFactory.EqualsGreaterThan())) .WithSemicolonToken(SyntaxTokenFactory.Semicolon())); }
private static MethodDeclarationSyntax CreateTypeRequestWithSpecifiedResultFactoryMethodWithMessageAllowNull( string resultFactoryMethodName, string className, HttpStatusCode httpStatusCode, string parameterName = "message") { return(SyntaxFactory.MethodDeclaration( SyntaxFactory.IdentifierName(className), SyntaxFactory.Identifier(httpStatusCode.ToNormalizedString())) .WithModifiers(SyntaxTokenListFactory.PublicStaticKeyword()) .WithParameterList( SyntaxFactory.ParameterList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Parameter(SyntaxFactory.Identifier(parameterName)) .WithType(SyntaxFactory.NullableType(SyntaxFactory.PredefinedType(SyntaxTokenFactory.StringKeyword()))) .WithDefault( SyntaxFactory.EqualsValueClause( SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)))))) .WithExpressionBody( SyntaxFactory.ArrowExpressionClause( SyntaxFactory.ObjectCreationExpression( SyntaxFactory.IdentifierName(className)) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("ResultFactory"), SyntaxFactory.IdentifierName(resultFactoryMethodName))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(nameof(HttpStatusCode)), SyntaxFactory.IdentifierName(httpStatusCode.ToString()))), SyntaxTokenFactory.Comma(), SyntaxFactory.Argument(SyntaxFactory.IdentifierName(parameterName)), }))))))))) .WithSemicolonToken(SyntaxTokenFactory.Semicolon())); }
private static MethodDeclarationSyntax CreateTypeRequestWithProblemDetailsWithMessage( string className, HttpStatusCode httpStatusCode, string parameterName = "message") { return(SyntaxFactory.MethodDeclaration( SyntaxFactory.IdentifierName(className), SyntaxFactory.Identifier(httpStatusCode.ToNormalizedString())) .WithModifiers(SyntaxTokenListFactory.PublicStaticKeyword()) .WithParameterList( SyntaxFactory.ParameterList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Parameter(SyntaxFactory.Identifier(parameterName)) .WithType(SyntaxFactory.PredefinedType(SyntaxTokenFactory.StringKeyword()))))) .WithExpressionBody( SyntaxFactory.ArrowExpressionClause( SyntaxFactory.ObjectCreationExpression( SyntaxFactory.IdentifierName(className)) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("ResultFactory"), SyntaxFactory.IdentifierName("CreateContentResultWithProblemDetails"))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(nameof(HttpStatusCode)), SyntaxFactory.IdentifierName(httpStatusCode.ToString()))), SyntaxTokenFactory.Comma(), SyntaxFactory.Argument(SyntaxFactory.IdentifierName(parameterName)) }))))))))) .WithSemicolonToken(SyntaxTokenFactory.Semicolon())); }
private MemberDeclarationSyntax CreateConstructor() => SyntaxFactory.ConstructorDeclaration( SyntaxFactory.Identifier(EndpointTypeName)) .WithModifiers( SyntaxTokenListFactory.PublicKeyword()) .WithParameterList( SyntaxFactory.ParameterList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Parameter( SyntaxFactory.Identifier("response")) .WithType( SyntaxFactory.IdentifierName("EndpointResponse"))))) .WithInitializer( SyntaxFactory.ConstructorInitializer( SyntaxKind.BaseConstructorInitializer, SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxFactory.IdentifierName("response")))))) .WithBody(SyntaxFactory.Block());
private static MethodDeclarationSyntax CreateTypeRequest( string className, HttpStatusCode httpStatusCode, string typeRequestName) { return(SyntaxFactory.MethodDeclaration( SyntaxFactory.IdentifierName(className), SyntaxFactory.Identifier(httpStatusCode.ToNormalizedString())) .WithModifiers(SyntaxTokenListFactory.PublicStaticKeyword()) .WithExpressionBody( SyntaxFactory.ArrowExpressionClause( SyntaxObjectCreationExpressionFactory.Create(className) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxFactory.ObjectCreationExpression( SyntaxFactory.IdentifierName(typeRequestName)) .WithArgumentList(SyntaxFactory.ArgumentList()))))))) .WithSemicolonToken(SyntaxTokenFactory.Semicolon())); }
private static MethodDeclarationSyntax CreateTypeRequestObjectResult( string className, string methodName, string parameterTypeName, string parameterName = "response", bool asGenericList = false, bool asGenericPagination = false) { string?genericListTypeName = null; if (asGenericList) { genericListTypeName = Microsoft.OpenApi.Models.NameConstants.List; } else if (asGenericPagination) { genericListTypeName = Microsoft.OpenApi.Models.NameConstants.Pagination; } if (string.IsNullOrEmpty(parameterTypeName)) { parameterTypeName = "string"; } return(SyntaxFactory.MethodDeclaration( SyntaxFactory.IdentifierName(className), SyntaxFactory.Identifier(methodName)) .WithModifiers(SyntaxTokenListFactory.PublicStaticKeyword()) .WithParameterList(SyntaxParameterListFactory.CreateWithOneItem(parameterTypeName, parameterName, genericListTypeName)) .WithExpressionBody( SyntaxFactory.ArrowExpressionClause( SyntaxObjectCreationExpressionFactory.Create(className) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxObjectCreationExpressionFactory.Create(methodName + nameof(ObjectResult)) .WithArgumentList(SyntaxArgumentListFactory.CreateWithOneItem(parameterName)))))))) .WithSemicolonToken(SyntaxTokenFactory.Semicolon())); }
private MemberDeclarationSyntax CreateInvokeExecuteAsyncMethod(string parameterTypeName, string resultTypeName, bool hasParameters) { var arguments = hasParameters ? new SyntaxNodeOrToken[] { SyntaxParameterFactory.Create(parameterTypeName, "parameters"), SyntaxTokenFactory.Comma(), SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()) } : new SyntaxNodeOrToken[] { SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()) }; return(SyntaxFactory.MethodDeclaration( SyntaxFactory.GenericName(SyntaxFactory.Identifier(nameof(Task))) .WithTypeArgumentList(SyntaxTypeArgumentListFactory.CreateWithOneItem(resultTypeName)), SyntaxFactory.Identifier("InvokeExecuteAsync")) .WithModifiers(SyntaxTokenListFactory.PrivateAsyncKeyword()) .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(arguments))) .WithBody(SyntaxFactory.Block(SyntaxThrowStatementFactory.CreateNotImplementedException()))); }
private static ConversionOperatorDeclarationSyntax CreateImplicitOperator( string className, string typeName, HttpStatusCode httpStatusCode, bool asGenericList = false, bool asGenericPagination = false) { string?genericListTypeName = null; if (asGenericList) { genericListTypeName = Microsoft.OpenApi.Models.NameConstants.List; } else if (asGenericPagination) { genericListTypeName = Microsoft.OpenApi.Models.NameConstants.Pagination; } var httpStatus = httpStatusCode.ToNormalizedString(); if (string.IsNullOrEmpty(typeName)) { typeName = "string"; } return(SyntaxFactory.ConversionOperatorDeclaration( SyntaxTokenFactory.ImplicitKeyword(), SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(className))) .WithModifiers(SyntaxTokenListFactory.PublicStaticKeyword(true)) .WithOperatorKeyword(SyntaxTokenFactory.OperatorKeyword()) .AddParameterListParameters(SyntaxParameterFactory.Create(typeName, "x", genericListTypeName)) .WithExpressionBody(SyntaxFactory.ArrowExpressionClause( SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(httpStatus))) .AddArgumentListArguments(SyntaxArgumentFactory.Create("x"))) .WithArrowToken(SyntaxTokenFactory.EqualsGreaterThan())) .WithSemicolonToken(SyntaxTokenFactory.Semicolon())); }
private static MethodDeclarationSyntax CreateStatusCodeResult( string className, HttpStatusCode httpStatusCode) { return(SyntaxFactory.MethodDeclaration(SyntaxFactory.IdentifierName(className), SyntaxFactory.Identifier(httpStatusCode.ToNormalizedString())) .WithModifiers(SyntaxTokenListFactory.PublicStaticKeyword()) .WithExpressionBody( SyntaxFactory.ArrowExpressionClause( SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName(className)) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName(nameof(StatusCodeResult))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(nameof(StatusCodes)), SyntaxFactory.IdentifierName($"Status{(int)httpStatusCode}{httpStatusCode}")))))))))))) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))); }
private static MemberDeclarationSyntax CreateActionResultField() { return(SyntaxFactory.FieldDeclaration( SyntaxVariableDeclarationFactory.Create(nameof(ActionResult), "result")) .WithModifiers(SyntaxTokenListFactory.PrivateReadonlyKeyword())); }