{{announcement.body}}
{{announcement.title}}

How to Organize Your ASP Core's Startup File

DZone 's Guide to

How to Organize Your ASP Core's Startup File

Use extension methods to clean up your ASP.NET Core application's startup file.

· Web Dev Zone ·
Free Resource

If you're a developer used to working with ASP.NET Core, you should be familiar with the nightmare that is startup file organization. Every ASP Core application startup file can include configurations, middleware declaration, dependency injection definition, authentication configs, and policies amongst. Long story short, heavy applications can have large, messy, unreadable startup files with hundreds of lines of hard-to-scroll-through code.

Gordon on ASP.NET's startup file organization

Gordon on ASP.NET's startup file organization

So, as you might have guessed, here is where extension methods come to the rescue. Learning to organize your Startup.cs is part of being a good C# programmer; having extension methods in your arsenal is a must. By the end of this article, you will learn a neat and simple trick to improve the organization of your startup files and spare yourself the pain of endless startup file scrolling in your future projects. 

Extension Methods — Your New Bestfriends

Extension methods were introduced with C# 3.0, and since then, the sun has been shining a little brighter.
Extension methods can be used to extend an existing type without creating a derived type, recompiling, or modifying the original one.

As a brief example, let's say we want to add a special method,  CountChar to the String class. CountChar will simply count the number of occurrences of a specific character in a given string.

namespace ExtensionMethods {
public static class MyExtensions
{
   public static int CountChar(this String str,Char character)
   {
      return str.Count(x=> x == character);
}
}
}


Now, to use it, we just need to import the namespace ExtensionMethods in our project, and voilà! Thanks to the magic of IntelliSense, our new method, CountChar , is now usable for any object of type String.

Using CountChar with myString variable

Using CountChar with myString variable

Check out the Microsoft docs page for more examples here.

Full Potential of Extension Methods

Now, let's do something more complex; we will extend the IServiceCollection  and the IApplicationBuilder. To do that we need to:

  • Create a static class — this class will include all our extension methods.

  • Create our extension method by passing our type as a parameter with the keyword this. In our example, we will take Swagger configuration as an example:

namespace ExtensionMethods
{

    public static class SwaggerConfigurationExtension
    {
        public static void AddSwaggerConfig(this IServiceCollection services)
        {

          services.AddSwaggerGen(c =>
            {
            c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });

            });
        }


        public static void UseCustomSwaggerConfig(this IApplicationBuilder app)
        {
            // Enable middleware to serve generated Swagger as a JSON endpoint.
            app.UseSwagger();

            // Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.),
            // specifying the Swagger JSON endpoint.

            app.UseSwaggerUI(c =>
            {
                c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
            });
        }
    }
}


In the code above, we created two extension methods:

  • AddSwaggerConfig extends the IServiceCollection  to add the Swagger generator configuration.

  • UseCustomSwaggerConfig extends the IApplicationBuilder  to enable middleware for Swagger server generation and swagger UI.

In terms of startup extension organization, two possibilities present themselves :

  • Regoup all your extensions in a single class (called StartupExtension for example).

  • Personnaly, I prefer the second solution. Usually, I create a folder named Extensions and I put all my classes there. With this structure, I can reuse an extension in another project with coping just the file that I need, rather than coping the code.

So, with those methods, we will have a startup file that looks like this :

    public class Startup
    {
         public void ConfigureServices(IServiceCollection services)
        {
                services.AddSwaggerConfig()
                services.AddCustomAuthentification()
                services.AddCustomSettingsFile()
                services.AddHttpClients()
               ...
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
        {
                app.UseCustomSwaggerConfig()
                ...
        }
    }


Congratulations, now you've harnessed the power of extension methods.
Gordon excited that you know how to use extension methods

Gordon excited that you know how to use extension methods

I hope you enjoyed this article.

Topics:
asp.net core ,clean code ,csharp ,best practice ,tutorial

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}