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))); }
public static MethodDeclarationSyntax CreateInterfaceMethod( string parameterTypeName, string resultTypeName, bool hasParameters) { ArgumentNullException.ThrowIfNull(parameterTypeName); ArgumentNullException.ThrowIfNull(resultTypeName); 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(SyntaxTypeArgumentListFactory.CreateWithOneItem(resultTypeName)), SyntaxFactory.Identifier("ExecuteAsync")) .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(arguments))) .WithSemicolonToken(SyntaxTokenFactory.Semicolon())); }
private StatementSyntax CreateExpressionStatementForWithMethodParameterMap( OpenApiParameter parameter) { var methodName = parameter.In switch { ParameterLocation.Query => nameof(IMessageRequestBuilder.WithQueryParameter), ParameterLocation.Header => nameof(IMessageRequestBuilder.WithHeaderParameter), ParameterLocation.Path => nameof(IMessageRequestBuilder.WithPathParameter), _ => throw new NotSupportedException(nameof(parameter.In)) }; var parameterMapName = parameter.Name; var parameterName = parameter.Name.EnsureFirstCharacterToUpper(); return(SyntaxFactory.ExpressionStatement( SyntaxFactory.InvocationExpression( SyntaxMemberAccessExpressionFactory.Create(methodName, "requestBuilder")) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.Argument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(parameterMapName))), SyntaxTokenFactory.Comma(), SyntaxFactory.Argument( SyntaxMemberAccessExpressionFactory.Create(parameterName, "parameters")), }))))); }
private static ReturnStatementSyntax CreateCodeBlockReturnStatement( string helperMethodName, bool hasParameters) { var arguments = hasParameters ? new SyntaxNodeOrToken[] { SyntaxArgumentFactory.Create("parameters"), SyntaxTokenFactory.Comma(), SyntaxArgumentFactory.Create("handler"), SyntaxTokenFactory.Comma(), SyntaxArgumentFactory.Create(nameof(CancellationToken).EnsureFirstCharacterToLower()), } : new SyntaxNodeOrToken[] { SyntaxArgumentFactory.Create("handler"), SyntaxTokenFactory.Comma(), SyntaxArgumentFactory.Create(nameof(CancellationToken).EnsureFirstCharacterToLower()), }; return(SyntaxFactory.ReturnStatement( SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(helperMethodName)) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>(arguments))))); }
public static ClassDeclarationSyntax AddSuppressMessageAttribute(this ClassDeclarationSyntax classDeclaration, SuppressMessageAttribute suppressMessage) { if (classDeclaration == null) { throw new ArgumentNullException(nameof(classDeclaration)); } if (suppressMessage == null) { throw new ArgumentNullException(nameof(suppressMessage)); } if (string.IsNullOrEmpty(suppressMessage.Justification)) { throw new ArgumentException(nameof(suppressMessage.Justification)); } var attributeArgumentList = SyntaxFactory.AttributeArgumentList( SyntaxFactory.SeparatedList <AttributeArgumentSyntax>(SyntaxFactory.NodeOrTokenList( SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.Category)), SyntaxTokenFactory.Comma(), SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.CheckId)), SyntaxTokenFactory.Comma(), SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.Justification !)) .WithNameEquals( SyntaxNameEqualsFactory.Create(nameof(SuppressMessageAttribute.Justification)) .WithEqualsToken(SyntaxTokenFactory.Equals()))))); return(classDeclaration .AddAttributeLists(SyntaxAttributeListFactory.Create(nameof(SuppressMessageAttribute), attributeArgumentList))); }
public static InterfaceDeclarationSyntax AddGeneratedCodeAttribute(this InterfaceDeclarationSyntax interfaceDeclaration, string toolName, string version) { if (interfaceDeclaration == null) { throw new ArgumentNullException(nameof(interfaceDeclaration)); } if (toolName == null) { throw new ArgumentNullException(nameof(toolName)); } if (version == null) { throw new ArgumentNullException(nameof(version)); } var attributeArgumentList = SyntaxFactory.AttributeArgumentList( SyntaxFactory.SeparatedList <AttributeArgumentSyntax>(SyntaxFactory.NodeOrTokenList( SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(toolName)), SyntaxTokenFactory.Comma(), SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(version))))); return(interfaceDeclaration .AddAttributeLists(SyntaxAttributeListFactory.Create(nameof(GeneratedCodeAttribute), attributeArgumentList))); }
private MemberDeclarationSyntax CreateConstructor() => SyntaxFactory.ConstructorDeclaration( SyntaxFactory.Identifier(EndpointTypeName)) .WithModifiers( SyntaxFactory.TokenList( SyntaxTokenFactory.PublicKeyword())) .WithParameterList( SyntaxFactory.ParameterList( SyntaxFactory.SeparatedList <ParameterSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.Parameter(SyntaxFactory.Identifier("factory")) .WithType(SyntaxFactory.IdentifierName(nameof(IHttpClientFactory))), SyntaxTokenFactory.Comma(), SyntaxFactory .Parameter(SyntaxFactory.Identifier("httpMessageFactory")) .WithType(SyntaxFactory.IdentifierName(nameof(IHttpMessageFactory))), }))) .WithBody( SyntaxFactory.Block( SyntaxFactory.ExpressionStatement( SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName("factory")), SyntaxFactory.IdentifierName("factory"))), SyntaxFactory.ExpressionStatement( SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName("httpMessageFactory")), SyntaxFactory.IdentifierName("httpMessageFactory")))));
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( SyntaxFactory.TokenList( SyntaxFactory.Token( CreatePragmaWarningCodeStyle1998(true), SyntaxKind.PrivateKeyword, SyntaxFactory.TriviaList()), SyntaxFactory.Token(SyntaxKind.AsyncKeyword))) .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(arguments))) .WithBody( SyntaxFactory.Block(SyntaxThrowStatementFactory.CreateNotImplementedException()) .WithOpenBraceToken( SyntaxFactory.Token( CreatePragmaWarningCodeStyle1998(false), SyntaxKind.OpenBraceToken, SyntaxFactory.TriviaList())))); }
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 static ReturnStatementSyntax CreateCodeBlockReturnStatementForHelper(bool hasParameters) { var arguments = hasParameters ? new SyntaxNodeOrToken[] { SyntaxArgumentFactory.Create("parameters"), SyntaxTokenFactory.Comma(), SyntaxArgumentFactory.Create("cancellationToken") } : new SyntaxNodeOrToken[] { SyntaxArgumentFactory.Create("cancellationToken") }; return(SyntaxFactory.ReturnStatement( SyntaxFactory.AwaitExpression( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("handler"), SyntaxFactory.IdentifierName("ExecuteAsync"))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>(arguments)))))); }
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 ParameterListSyntax CreateParameterList( bool hasParametersOrRequestBody, string parameterTypeName, string interfaceName, bool useFromServicesAttributeOnInterface) { ParameterListSyntax parameterList; if (hasParametersOrRequestBody) { if (useFromServicesAttributeOnInterface) { parameterList = SyntaxFactory.ParameterList( SyntaxFactory.SeparatedList <ParameterSyntax>( new SyntaxNodeOrToken[] { SyntaxParameterFactory.Create(parameterTypeName, "parameters"), SyntaxTokenFactory.Comma(), SyntaxParameterFactory.CreateWithAttribute(nameof(FromServicesAttribute), interfaceName, "handler"), SyntaxTokenFactory.Comma(), SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()) })); } else { parameterList = SyntaxFactory.ParameterList( SyntaxFactory.SeparatedList <ParameterSyntax>( new SyntaxNodeOrToken[] { SyntaxParameterFactory.Create(parameterTypeName, "parameters"), SyntaxTokenFactory.Comma(), SyntaxParameterFactory.Create(interfaceName, "handler"), SyntaxTokenFactory.Comma(), SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()) })); } } else { parameterList = SyntaxFactory.ParameterList( SyntaxFactory.SeparatedList <ParameterSyntax>( new SyntaxNodeOrToken[] { SyntaxParameterFactory.CreateWithAttribute(nameof(FromServicesAttribute), interfaceName, "handler"), SyntaxTokenFactory.Comma(), SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()) })); } return(parameterList); }
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 static ArgumentListSyntax CreateOneParameterArg(string parameterNameTo, string parameterNameFrom) => SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.Argument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(parameterNameTo))), SyntaxTokenFactory.Comma(), SyntaxFactory.Argument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("parameters"), SyntaxFactory.IdentifierName(parameterNameFrom))), }));
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 static ReturnStatementSyntax CreateCodeBlockReturnStatementForHelper( bool hasParameters) { var arguments = hasParameters ? new SyntaxNodeOrToken[] { SyntaxArgumentFactory.Create("parameters"), SyntaxTokenFactory.Comma(), SyntaxArgumentFactory.Create(nameof(CancellationToken).EnsureFirstCharacterToLower()), } : new SyntaxNodeOrToken[] { SyntaxArgumentFactory.Create(nameof(CancellationToken).EnsureFirstCharacterToLower()), }; return(SyntaxFactory.ReturnStatement( SyntaxFactory.AwaitExpression( SyntaxFactory.InvocationExpression( SyntaxMemberAccessExpressionFactory.Create("ExecuteAsync", "handler")) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>(arguments)))))); }
private ReturnStatementSyntax CreateInvokeExecuteAsyncMethodBlockReturn(string resultTypeName) { return(SyntaxFactory.ReturnStatement( SyntaxFactory.AwaitExpression( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("httpExchangeFactory"), SyntaxFactory.IdentifierName("FromResponse"))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxFactory.IdentifierName("response"))))), SyntaxFactory.GenericName( SyntaxFactory.Identifier("AddSuccessResponse")) // TODO: nameof .WithTypeArgumentList( SyntaxFactory.TypeArgumentList( SyntaxFactory.SingletonSeparatedList <TypeSyntax>( SyntaxFactory.IdentifierName(resultTypeName)))))) .WithArgumentList(CreateResponseArgHttpStatusCode(HttpStatusCode.OK)), SyntaxFactory.GenericName( SyntaxFactory.Identifier("AddErrorResponse")) // TODO: nameof .WithTypeArgumentList( SyntaxFactory.TypeArgumentList( SyntaxFactory.SingletonSeparatedList <TypeSyntax>( SyntaxFactory.IdentifierName("ProblemDetails")))))) // TODO: nameof .WithArgumentList(CreateResponseArgHttpStatusCode(HttpStatusCode.BadRequest)), SyntaxFactory.IdentifierName("AddErrorResponse"))) // TODO: nameof .WithArgumentList(CreateResponseArgHttpStatusCode(HttpStatusCode.NotFound)), SyntaxFactory.IdentifierName("BuildResponseAsync"))) // TODO: nameof .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.Argument( SyntaxFactory.SimpleLambdaExpression( SyntaxFactory.Parameter( SyntaxFactory.Identifier("x"))) .WithExpressionBody( SyntaxFactory.ObjectCreationExpression( SyntaxFactory.GenericName( SyntaxFactory.Identifier("EndpointResult")) // TODO: nameof .WithTypeArgumentList( SyntaxFactory.TypeArgumentList( SyntaxFactory.SingletonSeparatedList <TypeSyntax>( SyntaxFactory.IdentifierName(resultTypeName))))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxFactory.IdentifierName("x"))))))), SyntaxTokenFactory.Comma(), SyntaxFactory.Argument(SyntaxFactory.IdentifierName("cancellationToken")), })))))); }