Category Archives: Net Core

hello-world-startup-basic-request-headers-names


using Microsoft.AspNetCore.Hosting; //IWebHostBuilder
using Microsoft.AspNetCore.Builder; //IApplicationBuilder
using Microsoft.AspNetCore.Http; //WriteAsync
using Microsoft.AspNetCore; //webHost
using Microsoft.Extensions.Logging;//ILoggerFactory
using Microsoft.Extensions.DependencyInjection; // IServiceCollection
using Microsoft.Net.Http.Headers;
using System.Reflection; //List
using System;
using System.Collections.Generic; //Type
using System.Linq; //Where

namespace WebApplication1
{
    public class Startup
    {
        public Startup(IHostingEnvironment env, ILoggerFactory logger)
        {
            //These are two services available at constructor
        }

        public void ConfigureServices(IServiceCollection services)
        {
            //This is the only service available at ConfigureServices
        }

        private List<FieldInfo> GetConstants(Type type)
        {
            FieldInfo[] fieldInfos = type.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);

            return fieldInfos.Where(fi => fi.IsLiteral && !fi.IsInitOnly).ToList();
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)
        {
            app.Run(async context =>
            {
                context.Response.Headers.Add(HeaderNames.ContentType, "text/html");

                await context.Response.WriteAsync("<h1>Request Headers from Microsoft.Net.Http.Headers.HeaderNames</h1>");
                await context.Response.WriteAsync("<ul>");
                foreach (var h in GetConstants(typeof(HeaderNames)))
                {
                    await context.Response.WriteAsync($"<li>{h.Name} = {h.GetValue(h)}</li>");
                }
                await context.Response.WriteAsync("</ul>");
            });
        }
    }



    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>()
                .UseUrls("http://*:1000", "http://*:5000")
                .UseEnvironment("Development"); //You can change this to "Production" to use StartupProduction
    }
}

using Microsoft.AspNetCore.Hosting; //IWebHostBuilder

using Microsoft.AspNetCore.Builder; //IApplicationBuilder

using Microsoft.AspNetCore.Http; //WriteAsync

using Microsoft.AspNetCore; //webHost

using Microsoft.Extensions.Logging;//ILoggerFactory

using Microsoft.Extensions.DependencyInjection; // IServiceCollection

using Microsoft.Net.Http.Headers;

using System.Reflection; //List

using System;

using System.Collections.Generic; //Type

using System.Linq; //Where

namespace WebApplication1

{

public class Startup

{

public Startup(IHostingEnvironment env, ILoggerFactory logger)

{

//These are two services available at constructor

}

public void ConfigureServices(IServiceCollection services)

{

//This is the only service available at ConfigureServices

}

private List<FieldInfo> GetConstants(Type type)

{

FieldInfo[] fieldInfos = type.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);

return fieldInfos.Where(fi => fi.IsLiteral && !fi.IsInitOnly).ToList();

}

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)

{

app.Run(async context =>

{

context.Response.Headers.Add(HeaderNames.ContentType, "text/html");

await context.Response.WriteAsync("<h1>Request Headers from Microsoft.Net.Http.Headers.HeaderNames</h1>");

await context.Response.WriteAsync("<ul>");

foreach (var h in GetConstants(typeof(HeaderNames)))

{

await context.Response.WriteAsync($"<li>{h.Name} = {h.GetValue(h)}</li>");

}

await context.Response.WriteAsync("</ul>");

});

}

public class Program

{

public static void Main(string[] args)

{

CreateWebHostBuilder(args).Build().Run();

}

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>

WebHost.CreateDefaultBuilder(args)

.UseStartup<Startup>()

.UseUrls("http://*:1000", "http://*:5000")

.UseEnvironment("Development"); //You can change this to "Production" to use StartupProduction

}

결과 : Request Headers from Microsoft.Net.Http.Headers.HeaderNames •Accept = Accept •AcceptCharset = Accept-Charset •AcceptEncoding = Accept-Encoding •AcceptLanguage = Accept-Language •AcceptRanges = Accept-Ranges •AccessControlAllowCredentials = Access-Control-Allow-Credentials •AccessControlAllowHeaders = Access-Control-Allow-Headers •AccessControlAllowMethods = Access-Control-Allow-Methods •AccessControlAllowOrigin = Access-Control-Allow-Origin •AccessControlExposeHeaders = Access-Control-Expose-Headers •AccessControlMaxAge = Access-Control-Max-Age •AccessControlRequestHeaders = Access-Control-Request-Headers •AccessControlRequestMethod = Access-Control-Request-Method •Age = Age •Allow = Allow •Authority = :authority… Read More »

hello-world-startup-basic-request-headers


using Microsoft.AspNetCore.Hosting; //IWebHostBuilder
using Microsoft.AspNetCore.Builder; //IApplicationBuilder
using Microsoft.AspNetCore.Http; //WriteAsync
using Microsoft.AspNetCore; //webHost
using Microsoft.Extensions.Logging;//ILoggerFactory
using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1
{
    public class Startup
    {
        public Startup(IHostingEnvironment env, ILoggerFactory logger)
        {
            //These are two services available at constructor
        }

        public void ConfigureServices(IServiceCollection services)
        {
            //This is the only service available at ConfigureServices
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)
        {
            app.Run(async context =>
            {
                context.Response.Headers.Add("content-type", "text/html");
                await context.Response.WriteAsync("<h1>Request Headers</h1>");
                await context.Response.WriteAsync("<ul>");
                foreach (var h in context.Request.Headers)
                {
                    await context.Response.WriteAsync($"<li>{h.Key} : {h.Value}</li>");
                }
                await context.Response.WriteAsync("</ul>");
            });
        }
    }



    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>()
                .UseUrls("http://*:1000", "http://*:5000")
                .UseEnvironment("Development"); //You can change this to "Production" to use StartupProduction
    }
}

using Microsoft.AspNetCore.Hosting; //IWebHostBuilder

using Microsoft.AspNetCore.Builder; //IApplicationBuilder

using Microsoft.AspNetCore.Http; //WriteAsync

using Microsoft.AspNetCore; //webHost

using Microsoft.Extensions.Logging;//ILoggerFactory

using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1

{

public class Startup

{

public Startup(IHostingEnvironment env, ILoggerFactory logger)

{

//These are two services available at constructor

}

public void ConfigureServices(IServiceCollection services)

{

//This is the only service available at ConfigureServices

}

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)

{

app.Run(async context =>

{

context.Response.Headers.Add("content-type", "text/html");

await context.Response.WriteAsync("<h1>Request Headers</h1>");

await context.Response.WriteAsync("<ul>");

foreach (var h in context.Request.Headers)

{

await context.Response.WriteAsync($"<li>{h.Key} : {h.Value}</li>");

}

await context.Response.WriteAsync("</ul>");

});

}

public class Program

{

public static void Main(string[] args)

{

CreateWebHostBuilder(args).Build().Run();

}

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>

WebHost.CreateDefaultBuilder(args)

.UseStartup<Startup>()

.UseUrls("http://*:1000", "http://*:5000")

.UseEnvironment("Development"); //You can change this to "Production" to use StartupProduction

}

결과 : Request Headers •Accept : text/html, application/xhtml+xml, image/jxr, */* •Accept-Encoding : gzip, deflate •Accept-Language : ko-KR •Connection : close •Host : localhost:44323 •User-Agent : Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko

hello-world-startup-basic-multiple-urls


using Microsoft.AspNetCore.Hosting; //IWebHostBuilder
using Microsoft.AspNetCore.Builder; //IApplicationBuilder
using Microsoft.AspNetCore.Http; //WriteAsync
using Microsoft.AspNetCore; //webHost
using Microsoft.Extensions.Logging;//ILoggerFactory
using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1
{
    public class Startup
    {
        public Startup(IHostingEnvironment env, ILoggerFactory logger)
        {
            //These are two services available at constructor
        }

        public void ConfigureServices(IServiceCollection services)
        {
            //This is the only service available at ConfigureServices
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)
        {  
            app.Run(context =>
            {   
                return context.Response.WriteAsync("Hello world responding on http://localhost:1000 and http://localhost:5000");

            });
        }
    }



    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>()
                .UseUrls("http://*:1000", "http://*:5000")
                .UseEnvironment("Development"); //You can change this to "Production" to use StartupProduction
    }
}

using Microsoft.AspNetCore.Hosting; //IWebHostBuilder

using Microsoft.AspNetCore.Builder; //IApplicationBuilder

using Microsoft.AspNetCore.Http; //WriteAsync

using Microsoft.AspNetCore; //webHost

using Microsoft.Extensions.Logging;//ILoggerFactory

using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1

{

public class Startup

{

public Startup(IHostingEnvironment env, ILoggerFactory logger)

{

//These are two services available at constructor

}

public void ConfigureServices(IServiceCollection services)

{

//This is the only service available at ConfigureServices

}

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)

{

app.Run(context =>

{

return context.Response.WriteAsync("Hello world responding on http://localhost:1000 and http://localhost:5000");

});

}

public class Program

{

public static void Main(string[] args)

{

CreateWebHostBuilder(args).Build().Run();

}

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>

WebHost.CreateDefaultBuilder(args)

.UseStartup<Startup>()

.UseUrls("http://*:1000", "http://*:5000")

.UseEnvironment("Development"); //You can change this to "Production" to use StartupProduction

}

결과 : Hello world responding on http://localhost:1000 and http://localhost:5000

hello-world-startup-basic-multiple-environment


using Microsoft.AspNetCore.Hosting; //IWebHostBuilder
using Microsoft.AspNetCore.Builder; //IApplicationBuilder
using Microsoft.AspNetCore.Http; //WriteAsync
using Microsoft.AspNetCore; //webHost
using Microsoft.Extensions.Logging;//ILoggerFactory
using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1
{
    public class StartupProduction
    {
        public StartupProduction(IHostingEnvironment env, ILoggerFactory logger)
        {
            //These are two services available at constructor
        }

        public void ConfigureServices(IServiceCollection services)
        {
            //This is the only service available at ConfigureServices
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)
        {  
            app.Run(context =>
            {   
                return context.Response.WriteAsync("Hello world from Startup Production");

            });
        }
    }

    public class StartupDevelopment
    {
        public StartupDevelopment(IHostingEnvironment env, ILoggerFactory logger)
        {
            //These are two services available at constructor
        }

        public void ConfigureServices(IServiceCollection services)
        {
            //This is the only service available at ConfigureServices
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)
        {
            //These are the three default services available at Configure

            app.Run(context =>
            {
                return context.Response.WriteAsync("Hello world Startup Development");
            });
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup(typeof(Program).Assembly.FullName)
                .UseEnvironment("Development"); //You can change this to "Production" to use StartupProduction
    }
}

using Microsoft.AspNetCore.Hosting; //IWebHostBuilder

using Microsoft.AspNetCore.Builder; //IApplicationBuilder

using Microsoft.AspNetCore.Http; //WriteAsync

using Microsoft.AspNetCore; //webHost

using Microsoft.Extensions.Logging;//ILoggerFactory

using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1

{

public class StartupProduction

{

public StartupProduction(IHostingEnvironment env, ILoggerFactory logger)

{

//These are two services available at constructor

}

public void ConfigureServices(IServiceCollection services)

{

//This is the only service available at ConfigureServices

}

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)

{

app.Run(context =>

{

return context.Response.WriteAsync("Hello world from Startup Production");

});

}

public class StartupDevelopment

{

public StartupDevelopment(IHostingEnvironment env, ILoggerFactory logger)

{

//These are two services available at constructor

}

public void ConfigureServices(IServiceCollection services)

{

//This is the only service available at ConfigureServices

}

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)

{

//These are the three default services available at Configure

app.Run(context =>

{

return context.Response.WriteAsync("Hello world Startup Development");

});

}

public class Program

{

public static void Main(string[] args)

{

CreateWebHostBuilder(args).Build().Run();

}

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>

WebHost.CreateDefaultBuilder(args)

.UseStartup(typeof(Program).Assembly.FullName)

.UseEnvironment("Development"); //You can change this to "Production" to use StartupProduction

}

결과 : Hello world Startup Development

hello-world-startup-basic-multiple


using Microsoft.AspNetCore.Hosting; //IWebHostBuilder
using Microsoft.AspNetCore.Builder; //IApplicationBuilder
using Microsoft.AspNetCore.Http; //WriteAsync
using Microsoft.AspNetCore; //webHost
using Microsoft.Extensions.Logging;//ILoggerFactory
using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1
{
    public class Startup1
    {
        public Startup1(IHostingEnvironment env, ILoggerFactory logger)
        {
            //These are two services available at constructor
        }

        public void ConfigureServices(IServiceCollection services)
        {
            //This is the only service available at ConfigureServices
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)
        {  
            app.Run(context =>
            {   
                return context.Response.WriteAsync("Hello from multi start1");
                
            });
        }
    }

    public class Startup2
    {
        public Startup2(IHostingEnvironment env, ILoggerFactory logger)
        {
            //These are two services available at constructor
        }

        public void ConfigureServices(IServiceCollection services)
        {
            //This is the only service available at ConfigureServices
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)
        {
            //These are the three default services available at Configure

            app.Run(context =>
            {
                return context.Response.WriteAsync("Hello world Startup2");
            });
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args)
        {
            var hostBuilder = WebHost.CreateDefaultBuilder(args).UseEnvironment("Development");
            //This is a dumb way of doing it. You can use command line argument, etc to switch your startup 
            const int startupNumber = 2; //CHANGE THIS to 2 if you want to use Startup2

            if (startupNumber == 1)
                hostBuilder.UseStartup<Startup1>();
            else if (startupNumber == 2)
                hostBuilder.UseStartup<Startup2>();

            return hostBuilder;

        }
            
    }
}

using Microsoft.AspNetCore.Hosting; //IWebHostBuilder

using Microsoft.AspNetCore.Builder; //IApplicationBuilder

using Microsoft.AspNetCore.Http; //WriteAsync

using Microsoft.AspNetCore; //webHost

using Microsoft.Extensions.Logging;//ILoggerFactory

using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1

{

public class Startup1

{

public Startup1(IHostingEnvironment env, ILoggerFactory logger)

{

//These are two services available at constructor

}

public void ConfigureServices(IServiceCollection services)

{

//This is the only service available at ConfigureServices

}

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)

{

app.Run(context =>

{

return context.Response.WriteAsync("Hello from multi start1");

});

}

public class Startup2

{

public Startup2(IHostingEnvironment env, ILoggerFactory logger)

{

//These are two services available at constructor

}

public void ConfigureServices(IServiceCollection services)

{

//This is the only service available at ConfigureServices

}

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)

{

//These are the three default services available at Configure

app.Run(context =>

{

return context.Response.WriteAsync("Hello world Startup2");

});

}

public class Program

{

public static void Main(string[] args)

{

CreateWebHostBuilder(args).Build().Run();

}

public static IWebHostBuilder CreateWebHostBuilder(string[] args)

{

var hostBuilder = WebHost.CreateDefaultBuilder(args).UseEnvironment("Development");

//This is a dumb way of doing it. You can use command line argument, etc to switch your startup

const int startupNumber = 2; //CHANGE THIS to 2 if you want to use Startup2

if (startupNumber == 1)

hostBuilder.UseStartup<Startup1>();

else if (startupNumber == 2)

hostBuilder.UseStartup<Startup2>();

return hostBuilder;

}

결과 : Hello from multi start1

hello-world-startup-all-package-trimming


using Microsoft.AspNetCore.Hosting; //IWebHostBuilder
using Microsoft.AspNetCore.Builder; //IApplicationBuilder
using Microsoft.AspNetCore.Http; //WriteAsync
using Microsoft.AspNetCore; //webHost
using Microsoft.Extensions.Logging;//ILoggerFactory
using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1
{
    public class Startup
    {
        public Startup(IHostingEnvironment env, ILoggerFactory logger)
        {
            //These are two services available at constructor
        }

        public void ConfigureServices(IServiceCollection services)
        {
            //This is the only service available at ConfigureServices
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)
        {  

            app.Run(context =>
            {
                context.Response.Headers.Add("Content-Type", "text/html");
                return context.Response.WriteAsync($@"
                <html>
                <body>
                For the build command, use <blockquote>dotnet build /p:TrimUnusedDependencies=true</blockquote> For further options,
                open <a href=""https://github.com/dotnet/standard/blob/master/Microsoft.Packaging.Tools.Trimming/docs/trimming.md"">this</a>
                for the command line for trimming. 
                </body>
                </html>
                ");
                
            });
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>()
                .UseEnvironment("Development");
    }
}

using Microsoft.AspNetCore.Hosting; //IWebHostBuilder

using Microsoft.AspNetCore.Builder; //IApplicationBuilder

using Microsoft.AspNetCore.Http; //WriteAsync

using Microsoft.AspNetCore; //webHost

using Microsoft.Extensions.Logging;//ILoggerFactory

using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1

{

public class Startup

{

public Startup(IHostingEnvironment env, ILoggerFactory logger)

{

//These are two services available at constructor

}

public void ConfigureServices(IServiceCollection services)

{

//This is the only service available at ConfigureServices

}

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)

{

app.Run(context =>

{

context.Response.Headers.Add("Content-Type", "text/html");

return context.Response.WriteAsync($@"

<html>

<body>

For the build command, use <blockquote>dotnet build /p:TrimUnusedDependencies=true</blockquote> For further options,

open <a href=""https://github.com/dotnet/standard/blob/master/Microsoft.Packaging.Tools.Trimming/docs/trimming.md"">this</a>

for the command line for trimming.

</body>

</html>

");

});

}

public class Program

{

public static void Main(string[] args)

{

CreateWebHostBuilder(args).Build().Run();

}

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>

WebHost.CreateDefaultBuilder(args)

.UseStartup<Startup>()

.UseEnvironment("Development");

}

결과 : For the build command, use dotnet build /p:TrimUnusedDependencies=true For further options,open thisfor the command line for trimming.

hello-world-no-startup


using Microsoft.AspNetCore.Hosting; //IWebHostBuilder
using Microsoft.AspNetCore.Builder; //IApplicationBuilder
using Microsoft.AspNetCore.Http; //WriteAsync
using Microsoft.AspNetCore; //webHost
using Microsoft.Extensions.Logging;//ILoggerFactory
using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1
{
    public class Greeter
    {
        public string Say() => "Look Ma, no Startup class";
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
               .ConfigureServices(services => services.AddSingleton(new Greeter()))
                .Configure(app =>
                {
                    app.Run(context =>
                    {
                        var greet = context.RequestServices.GetService<Greeter>();
                        return context.Response.WriteAsync($"{greet.Say()}");
                    });
                })
                .UseEnvironment("Development");
    }
}

using Microsoft.AspNetCore.Hosting; //IWebHostBuilder

using Microsoft.AspNetCore.Builder; //IApplicationBuilder

using Microsoft.AspNetCore.Http; //WriteAsync

using Microsoft.AspNetCore; //webHost

using Microsoft.Extensions.Logging;//ILoggerFactory

using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1

{

public class Greeter

{

public string Say() => "Look Ma, no Startup class";

}

public class Program

{

public static void Main(string[] args)

{

CreateWebHostBuilder(args).Build().Run();

}

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>

WebHost.CreateDefaultBuilder(args)

.ConfigureServices(services => services.AddSingleton(new Greeter()))

.Configure(app =>

{

app.Run(context =>

{

var greet = context.RequestServices.GetService<Greeter>();

return context.Response.WriteAsync($"{greet.Say()}");

});

})

.UseEnvironment("Development");

}

결과 : Look Ma, no Startup class

hello-world-env-development


using Microsoft.AspNetCore.Hosting; //IWebHostBuilder
using Microsoft.AspNetCore.Builder; //IApplicationBuilder
using Microsoft.AspNetCore.Http; //WriteAsync
using Microsoft.AspNetCore; //webHost
using Microsoft.Extensions.Logging;//ILoggerFactory
using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1
{
    public class Startup
    {
        public Startup(IHostingEnvironment env, ILoggerFactory logger)
        {
            //These are two services available at constructor
        }

        public void ConfigureServices(IServiceCollection services)
        {
            //This is the only service available at ConfigureServices
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)
        {
            if (env.IsDevelopment())
            {
                app.Use(async (context, next) => {

                    await context.Response.WriteAsync("Development Mode \n");
                    await next.Invoke();
                });
            }

            if (env.IsProduction())
            {
                app.Use(async (context, next) => {

                    await context.Response.WriteAsync("Production Mode \n");
                    await next.Invoke();
                });
            }

            app.Run(async context =>
            {
               await context.Response.WriteAsync($"Hellow world");
            });
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>()
                .UseEnvironment("Development");
    }
}

using Microsoft.AspNetCore.Hosting; //IWebHostBuilder

using Microsoft.AspNetCore.Builder; //IApplicationBuilder

using Microsoft.AspNetCore.Http; //WriteAsync

using Microsoft.AspNetCore; //webHost

using Microsoft.Extensions.Logging;//ILoggerFactory

using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1

{

public class Startup

{

public Startup(IHostingEnvironment env, ILoggerFactory logger)

{

//These are two services available at constructor

}

public void ConfigureServices(IServiceCollection services)

{

//This is the only service available at ConfigureServices

}

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)

{

if (env.IsDevelopment())

{

app.Use(async (context, next) => {

await context.Response.WriteAsync("Development Mode \n");

await next.Invoke();

});

}

if (env.IsProduction())

{

app.Use(async (context, next) => {

await context.Response.WriteAsync("Production Mode \n");

await next.Invoke();

});

}

app.Run(async context =>

{

await context.Response.WriteAsync($"Hellow world");

});

}

public class Program

{

public static void Main(string[] args)

{

CreateWebHostBuilder(args).Build().Run();

}

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>

WebHost.CreateDefaultBuilder(args)

.UseStartup<Startup>()

.UseEnvironment("Development");

}

결과 : Development Mode Hellow world

hello-world-application-environment


using Microsoft.AspNetCore.Hosting; //IWebHostBuilder
using Microsoft.AspNetCore.Builder; //IApplicationBuilder
using Microsoft.AspNetCore.Http; //WriteAsync
using Microsoft.AspNetCore; //webHost
using Microsoft.Extensions.Logging;//ILoggerFactory
using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1
{
    public class Startup
    {
        public Startup(IHostingEnvironment env, ILoggerFactory logger)
        {
            //These are two services available at constructor
        }

        public void ConfigureServices(IServiceCollection services)
        {
            //This is the only service available at ConfigureServices
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)
        {
            //These are the three default services available at Configure

            app.Run(async context =>
            {
                context.Response.Headers.Add("content-type", "text/html");
                await context.Response.WriteAsync($"Application Name: {System.Reflection.Assembly.GetEntryAssembly().GetName().Name}<br/>");
                await context.Response.WriteAsync($"Application Base Path: {System.AppContext.BaseDirectory}<br/>");

                System.Reflection.Assembly entryAssembly = System.Reflection.Assembly.GetEntryAssembly();
                var targetFramework = entryAssembly.GetCustomAttributes(typeof(System.Runtime.Versioning.TargetFrameworkAttribute), true)[0] as System.Runtime.Versioning.TargetFrameworkAttribute;
                await context.Response.WriteAsync($"Target Framework: {targetFramework.FrameworkName}<br/>");

                await context.Response.WriteAsync($"Version: {System.Reflection.Assembly.GetEntryAssembly().GetName().Version}<br/>");
            });
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>()
                .UseEnvironment("Development");
    }
}

using Microsoft.AspNetCore.Hosting; //IWebHostBuilder

using Microsoft.AspNetCore.Builder; //IApplicationBuilder

using Microsoft.AspNetCore.Http; //WriteAsync

using Microsoft.AspNetCore; //webHost

using Microsoft.Extensions.Logging;//ILoggerFactory

using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1

{

public class Startup

{

public Startup(IHostingEnvironment env, ILoggerFactory logger)

{

//These are two services available at constructor

}

public void ConfigureServices(IServiceCollection services)

{

//This is the only service available at ConfigureServices

}

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)

{

//These are the three default services available at Configure

app.Run(async context =>

{

context.Response.Headers.Add("content-type", "text/html");

await context.Response.WriteAsync($"Application Name: {System.Reflection.Assembly.GetEntryAssembly().GetName().Name}<br/>");

await context.Response.WriteAsync($"Application Base Path: {System.AppContext.BaseDirectory}<br/>");

System.Reflection.Assembly entryAssembly = System.Reflection.Assembly.GetEntryAssembly();

var targetFramework = entryAssembly.GetCustomAttributes(typeof(System.Runtime.Versioning.TargetFrameworkAttribute), true)[0] as System.Runtime.Versioning.TargetFrameworkAttribute;

await context.Response.WriteAsync($"Target Framework: {targetFramework.FrameworkName}<br/>");

await context.Response.WriteAsync($"Version: {System.Reflection.Assembly.GetEntryAssembly().GetName().Version}<br/>");

});

}

public class Program

{

public static void Main(string[] args)

{

CreateWebHostBuilder(args).Build().Run();

}

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>

WebHost.CreateDefaultBuilder(args)

.UseStartup<Startup>()

.UseEnvironment("Development");

}

결과 : Application Name: WebApplication1 Application Base Path: D:\Sample\MVC\WebApplication2\WebApplication1\bin\Debug\netcoreapp2.2\ Target Framework: .NETCoreApp,Version=v2.2 Version: 1.0.0.0

hello-world-with-connection-info


using Microsoft.AspNetCore.Hosting; //IWebHostBuilder
using Microsoft.AspNetCore.Builder; //IApplicationBuilder
using Microsoft.AspNetCore.Http; //WriteAsync
using Microsoft.AspNetCore; //webHost
using Microsoft.Extensions.Logging;//ILoggerFactory
using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1
{
    public class Startup
    {
        public Startup(IHostingEnvironment env, ILoggerFactory logger)
        {
            //These are two services available at constructor
        }

        public void ConfigureServices(IServiceCollection services)
        {
            //This is the only service available at ConfigureServices
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)
        {
            //These are the three default services available at Configure

            app.Run(context =>
            {
                var connection = context.Connection;
                var str = string.Empty;
                str += $"Local IP:Port => {connection.LocalIpAddress}:{connection.LocalPort}\n";
                str += $"Remote IP:Port => {connection.RemoteIpAddress}:{connection.RemotePort}\n";
                str += $"ClientCertificate : {connection.ClientCertificate?.FriendlyName}\n";

                return context.Response.WriteAsync($"{str}");
            });
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>()
                .UseEnvironment("Development");
    }
}

using Microsoft.AspNetCore.Hosting; //IWebHostBuilder

using Microsoft.AspNetCore.Builder; //IApplicationBuilder

using Microsoft.AspNetCore.Http; //WriteAsync

using Microsoft.AspNetCore; //webHost

using Microsoft.Extensions.Logging;//ILoggerFactory

using Microsoft.Extensions.DependencyInjection; // IServiceCollection

namespace WebApplication1

{

public class Startup

{

public Startup(IHostingEnvironment env, ILoggerFactory logger)

{

//These are two services available at constructor

}

public void ConfigureServices(IServiceCollection services)

{

//This is the only service available at ConfigureServices

}

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory logger)

{

//These are the three default services available at Configure

app.Run(context =>

{

var connection = context.Connection;

var str = string.Empty;

str += $"Local IP:Port => {connection.LocalIpAddress}:{connection.LocalPort}\n";

str += $"Remote IP:Port => {connection.RemoteIpAddress}:{connection.RemotePort}\n";

str += $"ClientCertificate : {connection.ClientCertificate?.FriendlyName}\n";

return context.Response.WriteAsync($"{str}");

});

}

public class Program

{

public static void Main(string[] args)

{

CreateWebHostBuilder(args).Build().Run();

}

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>

WebHost.CreateDefaultBuilder(args)

.UseStartup<Startup>()

.UseEnvironment("Development");

}

결과 : Local IP:Port => ::1:44323 Remote IP:Port => ::1:14403 ClientCertificate :