Category Archives: Net Core

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 :

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.