C# (Csharp) 프로그래밍

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.

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 /