{"id":955,"date":"2025-05-02T07:46:19","date_gmt":"2025-05-02T06:46:19","guid":{"rendered":"https:\/\/debuggersspace.com\/?p=955"},"modified":"2025-05-02T07:51:56","modified_gmt":"2025-05-02T06:51:56","slug":"understanding-startup-cs-appsettings-json-filters-and-using-keyword-in-net-core-with-real-world-examples","status":"publish","type":"post","link":"https:\/\/debuggersspace.com\/index.php\/2025\/05\/02\/understanding-startup-cs-appsettings-json-filters-and-using-keyword-in-net-core-with-real-world-examples\/","title":{"rendered":"Understanding Startup.cs, appsettings.json, Filters, and using Keyword in .NET Core \u2013 With Real-World Examples"},"content":{"rendered":"
\n
\n \t<\/i> Read Time:<\/span>4 Minute, 14 Second <\/div>\n\n <\/div>

\ud83d\udccc 1. Startup.cs<\/code> in ASP.NET Core<\/h2>\n

\u2705 Definition<\/strong><\/h3>\n

Startup.cs<\/code> is the central configuration file for your ASP.NET Core application, used to register services and define the middleware pipeline.<\/p>\n

\ud83d\udccd Where is it used?<\/strong><\/h3>\n
    \n
  • \n

    In every ASP.NET Core project (.NET 5<\/code> or earlier).<\/p>\n<\/li>\n

  • \n

    Configures DI (Dependency Injection), routing, authentication, etc.<\/p>\n<\/li>\n<\/ul>\n

    \u2699\ufe0f How is it used?<\/strong><\/h3>\n
      \n
    • \n

      By implementing two methods: ConfigureServices()<\/code> and Configure()<\/code>.<\/p>\n<\/li>\n<\/ul>\n

      \ud83c\udfaf Why is it used?<\/strong><\/h3>\n
        \n
      • \n

        To define the behavior of the app at startup: dependencies, middleware, etc.<\/p>\n<\/li>\n<\/ul>\n

        \ud83d\udcbc Code Example<\/strong><\/h3>\n
        \n
        public<\/span> class<\/span> Startup<\/span>
        \n{
        \npublic<\/span> IConfiguration Configuration { get<\/span>; }<\/code><\/code>public<\/span><\/span> Startup<\/span>(IConfiguration configuration<\/span>)
        \n{
        \nConfiguration = configuration;
        \n}<\/p>\n

        <\/code><\/code>public<\/span><\/span> void<\/span> ConfigureServices<\/span>(IServiceCollection services<\/span>)
        \n{
        \nservices.AddControllers();
        \nservices.AddScoped<IMyService, MyService>();
        \n}<\/p>\n

        <\/code><\/code>public<\/span><\/span> void<\/span> Configure<\/span>(IApplicationBuilder app, IWebHostEnvironment env<\/span>)
        \n{
        \nif<\/span> (env.IsDevelopment()) app.UseDeveloperExceptionPage();<\/p>\n

        <\/code><\/code>app.UseRouting();
        \napp.UseAuthorization();
        \napp.UseEndpoints(endpoints => endpoints.MapControllers());
        \n}
        \n}<\/p>\n<\/div>\n<\/div>\n

        \ud83c\udfa4 Interview Questions & Answers<\/strong><\/h3>\n

        Q1: What is the difference between ConfigureServices<\/code> and Configure<\/code>?<\/strong>
        A: ConfigureServices<\/code> registers services for DI, while Configure<\/code> builds the middleware pipeline for handling HTTP requests.<\/p>\n

        Q2: Can we have multiple Startup.cs<\/code> files?<\/strong>
        A: Yes, by using environment-specific Startup classes like StartupDevelopment.cs<\/code> and defining them in Program.cs<\/code>.<\/p>\n

        Q3: How is Startup.cs<\/code> linked to the app’s lifecycle?<\/strong>
        A: It\u2019s automatically invoked during app bootstrapping by the host builder.<\/p>\n

        \n

        \ud83d\udcc2 2. appsettings.json<\/code> \u2013 The Configuration File<\/h2>\n

        \u2705 Definition<\/strong><\/h3>\n

        appsettings.json<\/code> stores app-level configurations like DB connection strings, keys, and logging levels.<\/p>\n

        \ud83d\udccd Where is it used?<\/strong><\/h3>\n
          \n
        • \n

          Found at the root of every ASP.NET Core project.<\/p>\n<\/li>\n

        • \n

          Accessed via IConfiguration<\/code>.<\/p>\n<\/li>\n<\/ul>\n

          \u2699\ufe0f How is it used?<\/strong><\/h3>\n
            \n
          • \n

            Values are injected using Configuration[\"key\"]<\/code> or via strongly typed objects.<\/p>\n<\/li>\n<\/ul>\n

            \ud83c\udfaf Why is it used?<\/strong><\/h3>\n
              \n
            • \n

              To externalize and separate configuration from code.<\/p>\n<\/li>\n<\/ul>\n

              \ud83d\udcbc Code Example<\/strong><\/h3>\n
              \n
              {<\/span>
              \n\"ConnectionStrings\"<\/span>:<\/span> {<\/span>
              \n\"DefaultConnection\"<\/span>:<\/span> \"Server=.;Database=MyDb;Trusted_Connection=True;\"<\/span>
              \n}<\/span>,<\/span>
              \n\"Jwt\"<\/span>:<\/span> {<\/span>
              \n\"Key\"<\/span>:<\/span> \"SecretKey123\"<\/span>,<\/span>
              \n\"Issuer\"<\/span>:<\/span> \"MyApp\"<\/span>
              \n}<\/span>
              \n}<\/span>
              \n<\/code><\/div>\n<\/div>\n
              \n
              csharp<\/div>\n
              \/\/ Reading from appsettings.json<\/span>
              \nstring<\/span> connStr = Configuration.GetConnectionString(\"DefaultConnection\"<\/span>);
              \nstring<\/span> jwtKey = Configuration[\"Jwt:Key\"<\/span>];
              \n<\/code><\/div>\n<\/div>\n

              \ud83c\udfa4 Interview Questions & Answers<\/strong><\/h3>\n

              Q1: How do you access strongly typed configuration values?<\/strong>
              A: Use services.Configure<T>(Configuration.GetSection(\"SectionName\"))<\/code> and inject IOptions<T><\/code> in your class.<\/p>\n

              Q2: How do you manage multiple environments (dev\/staging\/prod)?<\/strong>
              A: By creating appsettings.Development.json<\/code>, appsettings.Production.json<\/code>, etc., and setting ASPNETCORE_ENVIRONMENT<\/code>.<\/p>\n

              Q3: What happens if a key is missing?<\/strong>
              A: Configuration[\"missingKey\"]<\/code> returns null<\/code>\u2014handle null-checks or use fallback values.<\/p>\n

              \n

              \ud83e\uddf0 3. Filters in ASP.NET Core<\/h2>\n

              \u2705 Definition<\/strong><\/h3>\n

              Filters allow you to execute logic at specific points during request processing, like before or after controller actions.<\/p>\n

              \ud83d\udccd Where are they used?<\/strong><\/h3>\n
                \n
              • \n

                Global level: applied to all controllers.<\/p>\n<\/li>\n

              • \n

                Controller level or action level.<\/p>\n<\/li>\n

              • \n

                Common in logging, authentication, and error handling.<\/p>\n<\/li>\n<\/ul>\n

                \u2699\ufe0f How are they used?<\/strong><\/h3>\n
                  \n
                • \n

                  By implementing IActionFilter<\/code>, IExceptionFilter<\/code>, or using built-in attributes.<\/p>\n<\/li>\n<\/ul>\n

                  \ud83c\udfaf Why are they used?<\/strong><\/h3>\n
                    \n
                  • \n

                    To separate concerns like logging and error handling from business logic.<\/p>\n<\/li>\n<\/ul>\n

                    \ud83d\udcbc Code Example<\/strong><\/h3>\n
                    \n
                    public<\/span> class<\/span> LogActionFilter<\/span> : IActionFilter<\/span>
                    \n{
                    \npublic<\/span><\/span> void<\/span> OnActionExecuting<\/span>(ActionExecutingContext context<\/span>)
                    \n{
                    \nConsole.WriteLine(\"Action started\"<\/span>);
                    \n}<\/code><\/code>public<\/span><\/span> void<\/span> OnActionExecuted<\/span>(ActionExecutedContext context<\/span>)
                    \n{
                    \nConsole.WriteLine(“Action ended”<\/span>);
                    \n}
                    \n}<\/p>\n<\/div>\n<\/div>\n
                    \n
                    \/\/ Registering the filter globally<\/span>
                    \nservices.AddControllers(options => {
                    \noptions.Filters.Add<LogActionFilter>();
                    \n});
                    \n<\/code><\/div>\n<\/div>\n

                    \ud83c\udfa4 Interview Questions & Answers<\/strong><\/h3>\n

                    Q1: What is the difference between middleware and filters?<\/strong>
                    A: Middleware applies globally and works outside MVC, while filters are scoped to MVC and can access action context.<\/p>\n

                    Q2: Can filters be async?<\/strong>
                    A: Yes, by implementing IAsyncActionFilter<\/code>.<\/p>\n

                    Q3: When to use a filter vs. middleware?<\/strong>
                    A: Use filters when you need access to ModelState<\/code>, action parameters, or result metadata.<\/p>\n

                    \n

                    \ud83e\uddfe 4. The using<\/code> Keyword in C#<\/h2>\n

                    \u2705 Definition<\/strong><\/h3>\n

                    using<\/code> is used for:<\/p>\n

                      \n
                    1. \n

                      Importing namespaces.<\/p>\n<\/li>\n

                    2. \n

                      Managing resources that implement IDisposable<\/code>.<\/p>\n<\/li>\n<\/ol>\n

                      \ud83d\udccd Where is it used?<\/strong><\/h3>\n
                        \n
                      • \n

                        Every C# file starts with using<\/code> directives.<\/p>\n<\/li>\n

                      • \n

                        using<\/code> statements are used for disposable resources like DB connections, file streams.<\/p>\n<\/li>\n<\/ul>\n

                        \u2699\ufe0f How is it used?<\/strong><\/h3>\n
                          \n
                        • \n

                          Namespace imports allow usage of classes like HttpClient<\/code>, DbContext<\/code>, etc.<\/p>\n<\/li>\n

                        • \n

                          Statement ensures resource cleanup.<\/p>\n<\/li>\n<\/ul>\n

                          \ud83c\udfaf Why is it used?<\/strong><\/h3>\n
                            \n
                          • \n

                            Prevents memory leaks by auto-disposing resources.<\/p>\n<\/li>\n

                          • \n

                            Organizes code with external dependencies.<\/p>\n<\/li>\n<\/ul>\n

                            \ud83d\udcbc Code Example<\/strong><\/h3>\n
                            \n
                            \/\/ 1. Namespace import<\/span>
                            \nusing<\/span> System.Net.Http;<\/code><\/code>\/\/ 2. Resource disposal<\/span>
                            \nusing<\/span> (var<\/span> client = new<\/span> HttpClient())
                            \n{
                            \nvar<\/span> response = await<\/span> client.GetStringAsync(“https:\/\/example.com”<\/span>);
                            \n}<\/p>\n<\/div>\n<\/div>\n
                            \n
                            \/\/ Modern using declaration (C# 8+)<\/span>
                            \nusing<\/span> var<\/span> file = new<\/span> FileStream(\"log.txt\"<\/span>, FileMode.OpenOrCreate);
                            \n<\/code><\/div>\n<\/div>\n

                            \ud83c\udfa4 Interview Questions & Answers<\/strong><\/h3>\n

                            Q1: What’s the difference between using<\/code> directive and statement?<\/strong>
                            A: Directive brings in namespaces; statement ensures object disposal.<\/p>\n

                            Q2: What happens if you don\u2019t use using<\/code> with IDisposable<\/code>?<\/strong>
                            A: The resource may stay in memory longer than needed, causing memory leaks or file locks.<\/p>\n

                            Q3: How is using<\/code> internally implemented?<\/strong>
                            A: It’s translated into a try-finally block where Dispose()<\/code> is called in the finally<\/code>.<\/p>\n

                            \n

                            \ud83e\udde0 Quick Recap Table<\/h2>\n
                            \n
                            \n\n\n\n\n\n\n\n\n
                            Concept<\/th>\nWhere Used<\/th>\nHow Used<\/th>\nWhy Used<\/th>\n<\/tr>\n<\/thead>\n
                            Startup.cs<\/code><\/td>\nEntry of ASP.NET Core project<\/td>\nRegister services, build middleware pipeline<\/td>\nApp bootstrapping and lifecycle config<\/td>\n<\/tr>\n
                            appsettings.json<\/code><\/td>\nRoot configuration file<\/td>\nRead via Configuration[\"key\"]<\/code><\/td>\nManage environments and external config<\/td>\n<\/tr>\n
                            Filters<\/td>\nGlobal, Controller, or Action level<\/td>\nImplement interfaces or use attributes<\/td>\nDecouple logging, validation, auth logic<\/td>\n<\/tr>\n
                            using<\/code><\/td>\nTop of file \/ disposable object scope<\/td>\nNamespace import and resource management<\/td>\nAvoid memory leaks, improve readability<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                            \n
                            <\/div>\n<\/div>\n<\/div>\n<\/div>\n
                            \n

                            \ud83d\udce3 Conclusion<\/h2>\n

                            Understanding how Startup.cs<\/code>, appsettings.json<\/code>, Filters, and using<\/code> work together gives you a strong foundation in ASP.NET Core development. These are the hidden pillars that bring performance, maintainability, and structure to your enterprise application.<\/p>\n","protected":false},"excerpt":{"rendered":"

                            \ud83d\udccc 1. Startup.cs in ASP.NET Core \u2705 Definition Startup.cs is the central configuration file for your ASP.NET Core application, used to register services and define the middleware pipeline. \ud83d\udccd Where is it used? In every ASP.NET Core project (.NET 5 or earlier). Configures DI (Dependency Injection), routing, authentication, etc. \u2699\ufe0f How is it used? By […]<\/p>\n","protected":false},"author":43,"featured_media":959,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","footnotes":""},"categories":[15,159,146,1,24],"tags":[],"class_list":["post-955","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-net-core-3-1","category-net-core-top-50-qa","category-net-interview-qa","category-blog","category-c-net"],"uagb_featured_image_src":{"full":["https:\/\/debuggersspace.com\/wp-content\/uploads\/2025\/05\/ChatGPT-Image-May-2-2025-12_20_58-PM.png",1536,1024,false],"thumbnail":["https:\/\/debuggersspace.com\/wp-content\/uploads\/2025\/05\/ChatGPT-Image-May-2-2025-12_20_58-PM-150x150.png",150,150,true],"medium":["https:\/\/debuggersspace.com\/wp-content\/uploads\/2025\/05\/ChatGPT-Image-May-2-2025-12_20_58-PM-300x200.png",300,200,true],"medium_large":["https:\/\/debuggersspace.com\/wp-content\/uploads\/2025\/05\/ChatGPT-Image-May-2-2025-12_20_58-PM-768x512.png",750,500,true],"large":["https:\/\/debuggersspace.com\/wp-content\/uploads\/2025\/05\/ChatGPT-Image-May-2-2025-12_20_58-PM-1024x683.png",750,500,true],"1536x1536":["https:\/\/debuggersspace.com\/wp-content\/uploads\/2025\/05\/ChatGPT-Image-May-2-2025-12_20_58-PM.png",1536,1024,false],"2048x2048":["https:\/\/debuggersspace.com\/wp-content\/uploads\/2025\/05\/ChatGPT-Image-May-2-2025-12_20_58-PM.png",1536,1024,false]},"uagb_author_info":{"display_name":"Himanshu Namdeo","author_link":"https:\/\/debuggersspace.com\/author\/admin\/"},"uagb_comment_info":0,"uagb_excerpt":"\ud83d\udccc 1. Startup.cs in ASP.NET Core \u2705 Definition Startup.cs is the central configuration file for your ASP.NET Core application, used to register services and define the middleware pipeline. \ud83d\udccd Where is it used? In every ASP.NET Core project (.NET 5 or earlier). Configures DI (Dependency Injection), routing, authentication, etc. \u2699\ufe0f How is it used? By…","_links":{"self":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/955"}],"collection":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/users\/43"}],"replies":[{"embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/comments?post=955"}],"version-history":[{"count":4,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/955\/revisions"}],"predecessor-version":[{"id":958,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/955\/revisions\/958"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/media\/959"}],"wp:attachment":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/media?parent=955"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/categories?post=955"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/tags?post=955"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}