locked
best pratice how to organize Startup file .net core 2.0 RRS feed

  • Question

  • Hello could you help me I would like know how to organise the file Startup.cs to dotnet core 2.0.3

    I used 

    IIS : v6.1
    Security : Microsoft.AspNetCore.Authentication.JwtBearer v2.0.1
    DataAccess : Microsoft.EntityFrameworkCore v2.0.1
    I18N : Razor MVC
    Logging : log4net v2.0.8
    Cache : IMemoryCache
    Documentation: Swashbuckle.AspNetCore v1.1.0
    GenerateHtml : RazorLight

    ConfigureIIS
    ConfigureSecurity
    ConfigureDatabase
    ConfigureFormatter
    ConfigureI18N
    ConfigureAllActionFilterAttribute
    ConfigureRepositories
    ConfigureBusiness
    ConfigureLogging
    ConfigureCache
    ConfigureDocumentation
    ConfigurationRazorLight 

    namespace XXXWebPortal.API
    {
        using System;
        using System.Text;
        using XXXPortal.FileManagers;
        using XXXPortal.FileManagers.Contracts;
        using XXXPortal.UserManagers;
        using XXXPortal.UserManagers.Contracts;
        using XXXWebPortal.API.Attributes;
        using XXXWebPortal.API.Extensions;
        using XXXWebPortal.API.Services;
        using XXXPortal.YYYYdocs.Contracts;
        using XXXPortal.YYYYdocs.Impl;
        using Microsoft.AspNetCore.Authentication.JwtBearer;
        using Microsoft.AspNetCore.Builder;
        using Microsoft.AspNetCore.Hosting;
        using Microsoft.EntityFrameworkCore;
        using Microsoft.Extensions.Configuration;
        using Microsoft.Extensions.DependencyInjection;
        using Microsoft.IdentityModel.Tokens;
        using XXXPortal.Database;
        using XXXPortal.MailManagers.Contracts;
        using XXXPortal.MailManagers;
        using XXXPortal.Mails.Contracts;
        using XXXPortal.Mails.Impl;
        using XXXPortal.Encryptions.Contracts;
        using XXXPortal.Encryptions.Impl;
        using XXXWebPortal.API.Authorization;
        using XXXPortal.SecurityManagers.Contracts;
        using XXXPortal.SecurityManagers;
        using XXXPortal.Securities.Contracts;
        using XXXPortal.Securities.Impl;
        using XXXPortal.DataAccess.Contracts;
        using XXXPortal.DataAccess.Impl;
        using XXXPortal.WebPortals.Contracts;
        using XXXPortal.WebPortals.Impl;
        using XXXPortal.QQQQQQPortals.Contracts;
        using XXXPortal.QQQQQQPortals.Impl;
        using Microsoft.AspNetCore.Mvc.Razor;
        using System.Collections.Generic;
        using System.Globalization;
        using Microsoft.AspNetCore.Localization;
        using Microsoft.AspNetCore.Http;
        using XXXPortal.GenerateDocumentsManagers.Contracts;
        using XXXPortal.GenerateDocumentsManagers;
        using Microsoft.Extensions.Logging;
        using XXXPortal.Core.Log;
        using XXXPortal.Core.Log.Contracts;
        using XXXPortal.DataManagers.Contracts;
        using XXXPortal.DataManagers;
        using XXXWebPortal.API.Formatters;
        using Microsoft.Net.Http.Headers;
        using Swashbuckle.AspNetCore.Swagger;
    
        public class Startup
        {
            private const string enUSCulture = "en-US";
    
            public IConfiguration Configuration { get; }
            public IHostingEnvironment Environment { get; }
            private IServiceCollection Services { get; set; }
    
            public Startup(IConfiguration configuration, IHostingEnvironment env)
            {
                Configuration = configuration;
                Environment = env;
    
                var builder = new ConfigurationBuilder()
                    .SetBasePath(env.ContentRootPath)
                    .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                    .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
                    .AddEnvironmentVariables();
                Configuration = builder.Build();
            }
    
            // This method gets called by the runtime. Use this method to add services to the container.
            public void ConfigureServices(IServiceCollection services)
            {
                this.ConfigureIIS(services);
                this.ConfigureSecurity(services);
                this.ConfigureDatabase(services);
    
                var csvFormatterOptions = new CsvFormatterOptions();
                services.AddLocalization(options => options.ResourcesPath = "Resources");
                services.AddMvc(
                    options =>
                    {
                        options.InputFormatters.Add(new CsvInputFormatter(csvFormatterOptions));
                        options.OutputFormatters.Add(new CsvOutputFormatter(csvFormatterOptions));
                        options.FormatterMappings.SetMediaTypeMappingForFormat("csv", MediaTypeHeaderValue.Parse("text/csv"));
                    })
                    .AddViewLocalization(LanguageViewLocationExpanderFormat.Suffix)
                    .AddDataAnnotationsLocalization();
    
                services.AddScoped<LogActionAttribute>();
    
                this.ConfigureRepositories(services);
                this.ConfigureBusiness(services);
    
                this.ConfigureLogging(services);
                this.ConfigureCache(services);
                this.ConfigureDocumentation(services);
    
               /*var engine = new RazorLightEngineBuilder()
                  .UseFilesystemProject(path)
                  .UseMemoryCachingProvider()
                  .Build();*/
    			
                Services = services;
            }
    
            // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
            public void Configure(IApplicationBuilder app, IHostingEnvironment env, IApplicationLifetime appLifetime, ILoggerFactory loggerFactory)
            {
                appLifetime.ApplicationStarted.Register(OnStarted);
                appLifetime.ApplicationStopping.Register(OnStopping);
                appLifetime.ApplicationStopped.Register(OnStopped);
    
                if (env.IsDevelopment())
                    app.UseDeveloperExceptionPage();
    
                app.UseCors(builder =>
               {
                   builder.AllowAnyHeader();
                   builder.AllowAnyMethod();
                   builder.AllowAnyOrigin();
                   builder.AllowCredentials();
               });
    
                app.UseHTTPLogging();
    
                app.UseAuthentication();
                app.UseApiKeySecurity();
                app.UseTest();
    
                app.UseErrorLogging();
    
                this.UseRequestLocalization(app);//app.UseRequestLocalization();
    
                if (!env.IsProduction())
                {
                    app.UseDocumentation();
                    UseViewAllRegisteredServices(app, env);
                }
    
                app.UseMvc();
            }
    
            private void OnStarted()
            {
                Log("XXX API has fully started");
            }
    
            private void OnStopping()
            {
                Log("XXX API is performing a graceful shutdown");
            }
    
            private void OnStopped()
            { 
                Log("Shutdown blocks until this event completes");
            }
    
            private void ConfigureIIS(IServiceCollection services)
            {
                services.Configure<IISOptions>(options =>
                {
                    options.AutomaticAuthentication = false;
                });
            }
    
            private void ConfigureSecurity(IServiceCollection services)
            {
                services
                    .AddAuthentication(options =>
                    {
                        options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
                        options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
                        options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
                    })
                    .AddJwtBearer(jwtOptions =>
                    {
                        jwtOptions.IncludeErrorDetails = true;
                        jwtOptions.RequireHttpsMetadata = Environment.IsProduction();
    
                        jwtOptions.TokenValidationParameters = new TokenValidationParameters
                        {
                            ValidateIssuerSigningKey = true,
                            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration.GetValue<string>("Settings:JwtSymmetricKey"))),
    
                            ValidateIssuer = true,
                            ValidIssuer = "XXXWebPortal",
    
                            ValidateAudience = true,
                            ValidAudience = "XXXWebPortal",
    
                            ValidateLifetime = true,
                            ClockSkew = TimeSpan.Zero
                        };
                    });
    
                services.AddAuthorization();
            }
    
            private void ConfigureDatabase(IServiceCollection services)
            {
                services.AddDbContext<XXXContext>(options =>
                {
                    //options.UseLoggerFactory(MyLoggerFactory); // Warning: Do not create a new ILoggerFactory instance each time
                    options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
                });
            }
    
            private void ConfigureRepositories(IServiceCollection services)
            {
                services.AddScoped<IEncryptionRepository, EncryptionRepository>();
                services.AddScoped<IImpersonationContextRepository, ImpersonationContextRepository>();
    
                services.AddSingleton<IWebPortalRepository, WebPortalRepository>();
    
                services.AddScoped<IRafRepository, RafRepository>();
                services.AddScoped<IClassificationRepository, ClassificationRepository>();
                services.AddScoped<IRequirementRepository, RequirementRepository>();
    
                services.AddScoped<IMailRepository, MailRepository>();
    
                services.AddScoped<IAAAAARepository, AAAAARepository>();
                services.AddScoped<XXXPortal.SharePoint.Contracts.IDocumentRepository, XXXPortal.SharePoint.Impl.DocumentRepository>();
                services.AddScoped<XXXPortal.DataAccess.Contracts.IDocumentRepository, XXXPortal.DataAccess.Impl.DocumentRepository>();
    
                services.AddScoped<IBBBBBBBPortalRepository, BBBBBBBPortalRepository>();
                services.AddScoped<IRafUserDetailsRepository, RafUserDetailsRepository>();
    
            }
    
            private void ConfigureBusiness(IServiceCollection services)
            {
                services.AddTransient<ITokenService, TokenService>();
    
                services.AddSingleton<ILogBusiness, LogBusiness>();
    
                services.AddScoped<ISharePointFileManager, SharePointFileManager>();
                services.AddScoped<IAAAAAFileManager, AAAAAFileManager>();
    
                services.AddScoped<IXXXUserManager, XXXUserManager>();
                services.AddScoped<IWAUserManager, WAUserManager>();
                services.AddScoped<IUserManager, UserManager>();
    
                services.AddScoped<IMailerManager, MailerManager>();
                services.AddScoped<IMailManager, MailManager>();
    
                services.AddScoped<IImpersonationManager, ImpersonationManager>();
    
                services.AddScoped<IGenerateDocumentManager, GenerateDocumentManager>();
    
                services.AddScoped<IClassificationManager, ClassificationManager>();
                services.AddScoped<IRequirementManager, RequirementManager>();
                
                services.AddScoped<IDocumentManager, DocumentManager>();
    
                services.AddScoped<IRafManager, RafManager>();
                services.AddScoped<IRafUserDetailsManager, RafUserDetailsManager>();
    
    
                // services.AddTransient<IMyClass, MyClass>(); // Lifetime service
                // services.AddScoped<IMyClass, MyClass>();    // Request scoped service
                // services.AddSingleton<IMyClass, MyClass>(); // Singleton service
            }
    
            private void ConfigureLogging(IServiceCollection services)
            {
                services.AddLogging(builder => builder
                     .AddLog4Net()
                     .AddConsole()
                     .AddDebug()
                     //.AddFilter((provider, category, logLevel) =>
                     //{
                     //    if (provider == "XXXWebPortal.API.Log4NetProvider" && category == "XXXPortal.Core.Log.LogApplication")
                     //        return true;
    
                     //    return false;
                     //}));
                //.AddFilter("System", LogLevel.Critical) // Rule for all providers
                //.AddFilter<DebugLoggerProvider>("Microsoft", LogLevel.Critical) // Rule only for debug provider
                .AddConfiguration(Configuration.GetSection("Logging"))); // Would add rules from IConfiguration, overriding default rules added above
            }
    
            private void ConfigureCache(IServiceCollection services)
            {
                services.AddMemoryCache();
            }
    
            private void ConfigureDocumentation(IServiceCollection services)
            {
                services.AddSwaggerGen(c =>
                {
                    c.SwaggerDoc("v1", new Info
                    {
                        Version = "v1",
                        Title = "Documentation XXX Web Portal",
                        Description = "Specification TTTTTTTT API",
                        Contact = new Contact { Name = "TEAM IT", Email = Configuration["XXXPortalMailboxes:XXX.BAL.IT.Team"] },
                        
                    });
                });
            }
    
            private void UseRequestLocalization(IApplicationBuilder app)
            {
                var supportedCultures = new List<CultureInfo>
                {
                    new CultureInfo("fr"),
                    new CultureInfo(enUSCulture)
                };
    
                var localizationOptions = new RequestLocalizationOptions()
                {
                    DefaultRequestCulture = new RequestCulture(culture: enUSCulture, uiCulture: enUSCulture),
                    SupportedCultures = supportedCultures,
                    SupportedUICultures = supportedCultures
                };
    
                app.UseRequestLocalization(localizationOptions);
            }
    
            private void UseViewAllRegisteredServices(IApplicationBuilder app, IHostingEnvironment env)
            {
                app.Map("/allservices", builder => builder.Run(async context =>
                {
                    var sb = new StringBuilder();
    
                    sb.AppendLine($"({Configuration.GetConnectionString("DefaultConnection")}) <h1>BDD</h1>");
    
                    sb.AppendLine($"({env.IsDevelopment()}) <h1>IsDevelopment</h1>");
                    sb.AppendLine($"({env.IsEnvironment("UAT_29-03")}) <h1>IsUAT_29-03</h1>");
                    sb.AppendLine($"({env.IsEnvironment("REC")}) <h1>IsREC</h1>");
                    sb.AppendLine($"({env.IsStaging()}) <h1>IsStaging</h1>");
                    sb.AppendLine($"({env.IsProduction()}) <h1>IsProduction</h1>");
    
                    sb.AppendLine(string.Empty);
                    sb.AppendLine($"({env.EnvironmentName}) <h1>All Services</h1>");
                    sb.Append("<table><thead>");
                    sb.Append("<tr><th>Type</th><th>Lifetime</th><th>Instance</th></tr>");
                    sb.Append("</thead><tbody>");
                    foreach (var svc in Services)
                    {
                        sb.Append("<tr>");
                        sb.Append($"<td>{svc.ServiceType.FullName}</td>");
                        sb.Append($"<td>{svc.Lifetime}</td>");
                        sb.Append($"<td>{svc.ImplementationType?.FullName}</td>");
                        sb.Append("</tr>");
                    }
                    sb.Append("</tbody></table>");
                    await context.Response.WriteAsync(sb.ToString());
                }));
            }
    
            private void Log(string message)
            {
                string userName = UsersKeys.XXX_API_PORTAL;
                string uniqueIdHttpRequest;
    
                userName = userName.PadRight(18, ' ');
                uniqueIdHttpRequest = new String(' ', 22);
    
                LogApplication.Log.Debug($"{userName} {uniqueIdHttpRequest} {message}");
            }
        }
    }
    



    Friday, February 16, 2018 12:35 PM

All replies

  • Hi Cypoli,

    Thank you for posting here.

    For your question is more related to ASP.NET Core, you could post a new thread in ASP.NET Core forum for suitable support.

    The CLR Forum discuss and ask questions about .NET Framework Base Classes (BCL) such as Collections, I/O, Regigistry, Globalization, Reflection. Also discuss all the other Microsoft libraries that are built on or extend the .NET Framework, including Managed Extensibility Framework (MEF), Charting Controls, CardSpace, Windows Identity Foundation (WIF), Point of Sale (POS), Transactions. 

    Best Regards,

    Wendy


    MSDN Community Support
    Please remember to click "Mark as Answer" the responses that resolved your issue, and to click "Unmark as Answer" if not. This can be beneficial to other community members reading this thread. If you have any compliments or complaints to MSDN Support, feel free to contact MSDNFSF@microsoft.com.

    Monday, February 19, 2018 2:46 AM
  • Ok thanks for your advise could you tell me how I can delete my post ?
    Monday, February 19, 2018 11:40 AM