C# (Csharp) 프로그래밍

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 :

hello-world-with-cookies 2


using Microsoft.AspNetCore.Hosting; //IWebHostBuilder
using Microsoft.AspNetCore.Builder; //IApplicationBuilder
using Microsoft.AspNetCore.Http; //WriteAsync
using Microsoft.AspNetCore; //webHost

namespace WebApplication1
{
    public class Startup
    {
        public void Configure(IApplicationBuilder app)
        {
            app.Run(async context =>
            {
                context.Response.Headers.Add("content-tyep", "text/html");
                var deleteCookie = context.Request.Query["delete"];

                if(!string.IsNullOrWhiteSpace(deleteCookie))
                {
                    context.Response.Cookies.Delete("MyCookie");
                    await context.Response.WriteAsync($@"Delete cookie. Click <a href=""\"">here</a> to go back to home page.");
                    return;
                }

                var cookie = context.Request.Cookies["MyCookie"];

                if (string.IsNullOrWhiteSpace(cookie) && context.Request.Path == "/")
                {
                    context.Response.Cookies.Append
                    (
                        "MyCookie",
                        "Hello World",
                        new CookieOptions
                        {
                            Path = "/",
                            HttpOnly = false,
                            Secure = false
                        }
                    );
                    await context.Response.WriteAsync($"Writing a new cookie <br/>Refresh page to see cookie value.<br/>");
                }
                else
                {
                    await context.Response.WriteAsync($@"Click <a href=""\?delete=1"">here</a> to delete cookie.<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

namespace WebApplication1

{

public class Startup

{

public void Configure(IApplicationBuilder app)

{

app.Run(async context =>

{

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

var deleteCookie = context.Request.Query["delete"];

if(!string.IsNullOrWhiteSpace(deleteCookie))

{

context.Response.Cookies.Delete("MyCookie");

await context.Response.WriteAsync($@"Delete cookie. Click <a href=""\"">here</a> to go back to home page.");

return;

}

var cookie = context.Request.Cookies["MyCookie"];

if (string.IsNullOrWhiteSpace(cookie) && context.Request.Path == "/")

{

context.Response.Cookies.Append

(

"MyCookie",

"Hello World",

new CookieOptions

{

Path = "/",

HttpOnly = false,

Secure = false

}

);

await context.Response.WriteAsync($"Writing a new cookie <br/>Refresh page to see cookie value.<br/>");

}

else

{

await context.Response.WriteAsync($@"Click <a href=""\?delete=1"">here</a> to delete cookie.<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");

}

결과 ? :Writing a new cookie Refresh page to see cookie value. Click here to delete cookie. Delete cookie. Click here to go back to home page.

hello-world-with-IApplicationLifetime


using Microsoft.AspNetCore.Hosting; //IWebHostBuilder
using Microsoft.AspNetCore.Builder; //IApplicationBuilder
using Microsoft.AspNetCore.Http; //WriteAsync
using Microsoft.AspNetCore; //webHost

namespace WebApplication1
{
    public class Startup
    {  
        public void Configure(IApplicationBuilder app, IApplicationLifetime lifetime)
        {
            lifetime.ApplicationStarted.Register(() => System.Console.WriteLine("===== Server is starting"));
            lifetime.ApplicationStopping.Register(() => System.Console.WriteLine("===== Server is stopping"));
            lifetime.ApplicationStopped.Register(() => System.Console.WriteLine("===== Server has stopped"));

            app.Run(async context =>
            { 
                await context.Response.WriteAsync("Hello 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

namespace WebApplication1

{

public class Startup

{

public void Configure(IApplicationBuilder app, IApplicationLifetime lifetime)

{

lifetime.ApplicationStarted.Register(() => System.Console.WriteLine("===== Server is starting"));

lifetime.ApplicationStopping.Register(() => System.Console.WriteLine("===== Server is stopping"));

lifetime.ApplicationStopped.Register(() => System.Console.WriteLine("===== Server has stopped"));

app.Run(async context =>

{

await context.Response.WriteAsync("Hello 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");

}

결과 : Hello world

hello-world-with-IHostingEnvironment-Configure-Services


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;
using Microsoft.Extensions.Options;

namespace WebApplication1
{
    public class SimpleOption
    {
        public string ContentPath { get; set; }
    }

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

        public void ConfigureServices(IServiceCollection services)
        {
            //This is the only service available at ConfigureServices
            services.Configure<SimpleOption>(option =>
            {
                option.ContentPath = _env.ContentRootPath;
            });
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env,  ILoggerFactory logger)
        {
            app.Run(async context =>
            {
                context.Response.ContentType = "text/html";
                var simpleOption = context.RequestServices.GetService<IOptions<SimpleOption>>();

                await context.Response.WriteAsync($"{simpleOption.Value.ContentPath}");
            });            
        }
    }

    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;

using Microsoft.Extensions.Options;

namespace WebApplication1

{

public class SimpleOption

{

public string ContentPath { get; set; }

}

public class Startup

{

IHostingEnvironment _env;

public Startup(IHostingEnvironment env, ILoggerFactory logger)

{

//These are two services available at constructor

_env = env;

}

public void ConfigureServices(IServiceCollection services)

{

//This is the only service available at ConfigureServices

services.Configure<SimpleOption>(option =>

{

option.ContentPath = _env.ContentRootPath;

});

}

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

{

app.Run(async context =>

{

context.Response.ContentType = "text/html";

var simpleOption = context.RequestServices.GetService<IOptions<SimpleOption>>();

await context.Response.WriteAsync($"{simpleOption.Value.ContentPath}");

});

}

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");

}

결과 : D:\Sample\MVC\WebApplication2\WebApplication1

hello-world-with-IHostingEnvironment


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;

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
        }

        //StartUP  
        public void Configure(IApplicationBuilder app, IHostingEnvironment env,  ILoggerFactory logger)
        {
            var applicationName = $"<tr><td>ApplicationName</td><td>{env.ApplicationName}</td></tr>";
            var contentRootPath = $"<tr><td>ContentRootPath</td><td>{env.ContentRootPath}</td></tr>";
            var contentRootFileProvider = $"<tr><td>ContentRootFileProvider</td><td>{env.ContentRootFileProvider}</td></tr>";
            var environmentName = $"<tr><td>EnvironmentName</td><td>{env.EnvironmentName}</td></tr>";
            var webRootPath = $"<tr><td>WebRootPath</td><td>{env.WebRootPath}</td></tr>";
            var webRootFileProvider = $"<tr><td>WebRootFileProvider</td><td>{env.WebRootFileProvider}</td></tr>";

            var content = $"<html><body><table><tbody><h1>Complete list of IHostingEnvironment properties</h1>{applicationName}{contentRootPath}{contentRootFileProvider}{environmentName}{webRootPath}{webRootFileProvider}</tbody></table></body></html>";


            app.Run(context =>
            {
                context.Response.ContentType = "text/html";
                return context.Response.WriteAsync(content);

            });            
        }
    }

    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;

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

}

//StartUP

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

{

var applicationName = $"<tr><td>ApplicationName</td><td>{env.ApplicationName}</td></tr>";

var contentRootPath = $"<tr><td>ContentRootPath</td><td>{env.ContentRootPath}</td></tr>";

var contentRootFileProvider = $"<tr><td>ContentRootFileProvider</td><td>{env.ContentRootFileProvider}</td></tr>";

var environmentName = $"<tr><td>EnvironmentName</td><td>{env.EnvironmentName}</td></tr>";

var webRootPath = $"<tr><td>WebRootPath</td><td>{env.WebRootPath}</td></tr>";

var webRootFileProvider = $"<tr><td>WebRootFileProvider</td><td>{env.WebRootFileProvider}</td></tr>";

var content = $"<html><body><table><tbody><h1>Complete list of IHostingEnvironment properties</h1>{applicationName}{contentRootPath}{contentRootFileProvider}{environmentName}{webRootPath}{webRootFileProvider}</tbody></table></body></html>";

app.Run(context =>

{

context.Response.ContentType = "text/html";

return context.Response.WriteAsync(content);

});

}

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");

}

결과 : Complete list of IHostingEnvironment properties ApplicationName WebApplication1 ContentRootPath D:\Sample\MVC\WebApplication2\WebApplication1 ContentRootFileProvider Microsoft.Extensions.FileProviders.PhysicalFileProvider EnvironmentName Development WebRootPath WebRootFileProvider Microsoft.Extensions.FileProviders.NullFileProvider

hello-world-with-logging


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

namespace WebApplication1
{
    public class Startup
    { 
        //StartUP  
        public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
        {
            var log = loggerFactory.CreateLogger<Startup>();

            app.Run(context =>
            {
                log.LogTrace($"equest {context.Request.Path}");
                log.LogDebug($"Debug info {context.Request.Path}");
                return context.Response.WriteAsync($"Hello world at {context.Request.Path}");

            });            
        }
    }

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

        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
               .ConfigureLogging(builder =>
               {
                   builder.SetMinimumLevel(LogLevel.Trace);
                   builder.AddConsole();
               })
                .UseStartup<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

namespace WebApplication1

{

public class Startup

{

//StartUP

public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)

{

var log = loggerFactory.CreateLogger<Startup>();

app.Run(context =>

{

log.LogTrace($"equest {context.Request.Path}");

log.LogDebug($"Debug info {context.Request.Path}");

return context.Response.WriteAsync($"Hello world at {context.Request.Path}");

});

}

public class Program

{

public static void Main(string[] args)

{

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

}

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

WebHost.CreateDefaultBuilder(args)

.ConfigureLogging(builder =>

{

builder.SetMinimumLevel(LogLevel.Trace);

builder.AddConsole();

})

.UseStartup<Startup>();

}

결과 : Hello world at /

hello-world-with-middleware


using Microsoft.AspNetCore.Hosting; //IWebHostBuilder
using Microsoft.AspNetCore.Builder; //IApplicationBuilder
using Microsoft.AspNetCore.Http; //WriteAsync
using Microsoft.AspNetCore; //webHost
using System.Threading.Tasks;

namespace WebApplication1
{
    public class Startup
    { 
        //StartUP  
        public void Configure(IApplicationBuilder app)
        {
            app.Use(async (context, next) =>
            {
                context.Items["content"] += "[1] -------- \n";
                await next.Invoke();
                context.Items["content"] += "[5] -------- \n";

                await context.Response.WriteAsync(context.Items["Content"] as string);
            });

            app.Use(async (context, next) =>
            {
                context.Items["Content"] += "[2] Hello world \n";//2
                await next.Invoke();
                context.Items["Content"] += "[4]  \n";//4
            });

            app.Run(context =>
            {
                context.Items["Content"] += "[3] ----- \n";//3
                return Task.CompletedTask;
            });

            //app.Run(async (context) =>
            //{
            //    await context.Response.WriteAsync("Hello 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 System.Threading.Tasks;

namespace WebApplication1

{

public class Startup

{

//StartUP

public void Configure(IApplicationBuilder app)

{

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

{

context.Items["content"] += "[1] -------- \n";

await next.Invoke();

context.Items["content"] += "[5] -------- \n";

await context.Response.WriteAsync(context.Items["Content"] as string);

});

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

{

context.Items["Content"] += "[2] Hello world \n";//2

await next.Invoke();

context.Items["Content"] += "[4] \n";//4

});

app.Run(context =>

{

context.Items["Content"] += "[3] ----- \n";//3

return Task.CompletedTask;

});

//app.Run(async (context) =>

//{

// await context.Response.WriteAsync("Hello 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");

}

결과 : [2] Hello world [3] —– [4]

Hello World!


using Microsoft.AspNetCore.Hosting; //IWebHostBuilder
using Microsoft.AspNetCore.Builder; //IApplicationBuilder
using Microsoft.AspNetCore.Http; //WriteAsync
using Microsoft.AspNetCore; //webHost

namespace WebApplication1
{
    public class Startup
    { 
        //StartUP  
        public void Configure(IApplicationBuilder app)
        {
            app.Run(async (context) =>
            {
                await context.Response.WriteAsync("Hello 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>();
    }
}

using Microsoft.AspNetCore.Hosting; //IWebHostBuilder

using Microsoft.AspNetCore.Builder; //IApplicationBuilder

using Microsoft.AspNetCore.Http; //WriteAsync

using Microsoft.AspNetCore; //webHost

namespace WebApplication1

{

public class Startup

{

//StartUP

public void Configure(IApplicationBuilder app)

{

app.Run(async (context) =>

{

await context.Response.WriteAsync("Hello 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>();

}