public static MethodDeclarationSyntax ConstructStartupConfigureMethod(IEnumerable <StatementSyntax> additonalStatements = null) { var devOnlyStatements = new List <StatementSyntax>() { SyntaxFactory.ParseStatement(AppUseDevExceptionPageCall) }; var devEnvCondition = SyntaxFactory.ParseExpression(DevEnvConditionText); var statements = new List <StatementSyntax>() { // Standard blazor configuration statements SyntaxFactory.ParseStatement(AppUseStaticFilesText), SyntaxFactory.ParseStatement(AppUseRoutingText), SyntaxFactory.ParseStatement(AppUseEndpointsCall), // Dev env dependent statements SyntaxFactory.IfStatement(devEnvCondition, CodeSyntaxHelper.GetStatementsAsBlock(devOnlyStatements)) }; if (additonalStatements != null) { statements.AddRange(additonalStatements); } return(SyntaxFactory.MethodDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)), StartupConfigureMethodName) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) // Accept runtime injected application builder .AddParameterListParameters(RuntimeInjectable.AppBuilderInjectable.AsParameter) .WithBody(CodeSyntaxHelper.GetStatementsAsBlock(statements))); }
public static MethodDeclarationSyntax ConstructDisposeMethod(IEnumerable <StatementSyntax> statements) { var method = SyntaxFactory.MethodDeclaration( SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)), BlazorComponentLifecycleEvent.Dispose.ToString()); method = method.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)); method = method.WithBody(CodeSyntaxHelper.GetStatementsAsBlock(statements)); // Should be public void Dispose() return(method); }
public static MethodDeclarationSyntax ConstructOnParametersSetMethod(IEnumerable <StatementSyntax> statements) { var method = SyntaxFactory.MethodDeclaration( SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)), BlazorComponentLifecycleEvent.OnParametersSet.ToString()); method = method.AddModifiers( SyntaxFactory.Token(SyntaxKind.ProtectedKeyword), SyntaxFactory.Token(SyntaxKind.OverrideKeyword)); method = method.WithBody(CodeSyntaxHelper.GetStatementsAsBlock(statements)); // Should be protected override void OnParametersSet() return(method); }
public static MethodDeclarationSyntax ConstructOnAfterRenderMethod(IEnumerable <StatementSyntax> statements) { var method = SyntaxFactory.MethodDeclaration( SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)), BlazorComponentLifecycleEvent.OnAfterRender.ToString()); method = method.AddModifiers( SyntaxFactory.Token(SyntaxKind.ProtectedKeyword), SyntaxFactory.Token(SyntaxKind.OverrideKeyword)); method = method.AddParameterListParameters(SyntaxFactory .Parameter(SyntaxFactory.Identifier(ComponentOnAfterRenderParamName)) .WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword)))); method = method.WithBody(CodeSyntaxHelper.GetStatementsAsBlock(statements)); // Should be protected override void OnAfterRender(bool firstRender) return(method); }
public static MethodDeclarationSyntax ConstructStartupConfigureServicesMethod(IEnumerable <StatementSyntax> additonalStatements = null) { var statements = new List <StatementSyntax>() { // Standard blazor configuration statements SyntaxFactory.ParseStatement(ServiceAddRazorPagesText), SyntaxFactory.ParseStatement(ServiceAddServerSideBlazorText) }; if (additonalStatements != null) { statements.AddRange(additonalStatements); } return(SyntaxFactory.MethodDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)), StartupConfigureServicesMethodName) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) // Accept runtime injected service collection .AddParameterListParameters(RuntimeInjectable.ServiceCollectionInjectable.AsParameter) .WithBody(CodeSyntaxHelper.GetStatementsAsBlock(statements))); }
public static ConstructorDeclarationSyntax ConstructStartupConstructor(IEnumerable <StatementSyntax> additonalStatements = null) { var statements = new List <StatementSyntax>() { // We guarantee that config and env will be assigned values from // constructor params RuntimeInjectable.ConfigInjectable.PropertyAssignment, RuntimeInjectable.EnvInjectable.PropertyAssignment }; if (additonalStatements != null) { statements.AddRange(additonalStatements); } return(SyntaxFactory.ConstructorDeclaration(StartupClassName) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) // Accept runtime injected config and env services .AddParameterListParameters(RuntimeInjectable.ConfigInjectable.AsParameter, RuntimeInjectable.EnvInjectable.AsParameter) .WithBody(CodeSyntaxHelper.GetStatementsAsBlock(statements))); }
public static ConstructorDeclarationSyntax ConstructMiddlewareConstructor( string middlewareClassName, IEnumerable <StatementSyntax> additionalStatements = null) { var statements = new List <StatementSyntax>() { // We guarantee that request delegate will be assigned to _next RuntimeInjectable.RequestDelegateInjectable.PrivateFieldAssignment }; if (additionalStatements != null) { statements.AddRange(additionalStatements); } return(SyntaxFactory.ConstructorDeclaration(middlewareClassName) .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)) // Accept runtime injected request delegate as next .AddParameterListParameters(RuntimeInjectable.RequestDelegateInjectable.AsParameter) .WithBody(CodeSyntaxHelper.GetStatementsAsBlock(statements))); }
public static MethodDeclarationSyntax ConstructSetParametersAsyncMethod(IEnumerable <StatementSyntax> statements) { var method = SyntaxFactory.MethodDeclaration( SyntaxFactory.ParseTypeName(typeof(Task).Name), BlazorComponentLifecycleEvent.SetParametersAsync.ToString()); method = method.AddModifiers( SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.OverrideKeyword), SyntaxFactory.Token(SyntaxKind.AsyncKeyword)); method = method.AddParameterListParameters(RuntimeInjectable.ParameterViewInjectable.AsParameter); // Adding the call to ComponentBase.SetParametersAsync function, technically not // required but doesn't hurt to add and covers more cases var baseCall = SyntaxFactory.ParseStatement(string.Format(SetParametersBaseCallTemplate, RuntimeInjectable.ParameterViewInjectable.ParamName)); // Adding an extra space so that the base call is separated from other method calls method = method.WithBody(CodeSyntaxHelper.GetStatementsAsBlock(statements.Append(CodeSyntaxHelper.GetBlankLine()).Append(baseCall))); // Should be public override async Task SetParametersAsync(ParameterView parameters) return(method); }
public static BlockSyntax ConstructMiddlewareMainContentBlock( string nextCallText, bool shouldContinue = true, IEnumerable <StatementSyntax> preHandleStatements = null, IEnumerable <StatementSyntax> postHandleStatements = null) { IEnumerable <StatementSyntax> statements = preHandleStatements ?? new List <StatementSyntax>(); // In most cases, shouldContinue will be true, but if the middleware was generated from // an http handler, then this will not be the case if (shouldContinue) { // Ensure that call to next occurs between pre-handle statements and post-handle // statements if any exist (usually exactly one will) statements = statements.Append(SyntaxFactory.ParseStatement(nextCallText)); } if (postHandleStatements != null) { statements = statements.Concat(postHandleStatements); } return(CodeSyntaxHelper.GetStatementsAsBlock(statements)); }