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 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 void CreateWithOneItem()
{
// Arrange
var expected = SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("hallo"));
// Act
var actual = SyntaxArgumentFactory.Create("hallo");
// Assert
Assert.Equal(expected.ToFullString(), actual.ToFullString());
}
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 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()));
}
