در این مقاله به مطالب زیر می پردازیم:

• ایجاد پروژه asp.net core 2

• Middleware چیست؟

• ایجاد ASP.NET CORE 2.0 Middleware

آموزش برنامه نویسی | اموزش asp.net core 2 | آموزش دات نت کور 2

آموزش Asp.Net Core 2.0 (ایجاد پروژه)

در این مقاله به مطالب زیر می پردازیم:

• ایجاد پروژه asp.net core 2

• Middleware چیست؟

• ایجاد ASP.NET CORE 2.0 Middleware

برای ایجاد یک پروژه خالی در ویژوال استودیو 2017 مراحل زیر را انجام دهید:

• File > New > Project
• ASP.NET Core Web Application را انتخاب و نام و لوکیشن آن را وارد کنید و ok بزنید
• Empty را انتخاب کنید، ok بزنید

تمام کدهای Program.cs و Startup.cs را پاک کنید و فقط کدهای ضروری را نگه دارید. (براساس کدهای زیر)

 public class Program
    {
        public static void Main(string[] args)
        {
            BuildWebHost(args).Run();
        }
 
        public static IWebHost BuildWebHost(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup()
                .Build();
    }
 
    public class Startup
    {
        public Startup(
            IHostingEnvironment env,
            ILoggerFactory loggerFactory,
            IConfiguration config)
        {
 
        }
 
        public void ConfigureServices(
            IServiceCollection services)
        {
            // setup dependency injection in service container
        }
 
        public void Configure(
            IApplicationBuilder app,
            IHostingEnvironment env)
        {
            // setup request pipeline using middleware
        }
    }

قالب پروژه خالی در ویژوال استودیو 2017 یک پروژه با کلاس های Program.cs و Startup.cs ایجاد می کند:

Program.cs:

درست مانند یک برنامه کنسول است که با public static void Main() یک برنامه asp.net core را شروع می کند.

در اینجا یک وب هاست برای درخواست مدیریت سرور تنظیم کرده ایم که این روش با استفاده از متد CreateDefaultBuilder() پیکربندی شده است:

• Kestrel: یک وب سرور cross-platform
• Root: پوشه های مربوط به روت برنامه
• IIS: یک سرور پروکسی
• Startup: یک کلاس است که خدمات و سرویس ها و پیکربندی پروژه را انجام می دهد.
• Configuration: اضافه کردن appsettings.json و متغیرها به Iconfiguration از طریق تزریقات وابستگی (Dependency Injection)
• Logging: اضافه کردن یک کنسول و تایید ورود به سیستم

بعد از پیکربندی یکی از هاست های Build() و یا Run() را برای درخواست به سرور می فرستیم.

پس از تنظیم WebHostBuilder با استفاده از متد UseSetting() می توانید تنظیمات مختلفی از جمله:

applicationName (string), contentRoot (string), detailedErrors (bool), environment (string), urls (semicolon separated list) and webroot (string) را انجام دهید. برخی از این خواص همچنین می توانند از طریق متد های افزودنی در WebHostBuilder تنظیم شوند.

Startup.cs:

این کلاس سرویس های تزریق وابستگی و pipeline را با استفاده از متدهای ConfigureServices() و Configure() برای برنامه درخواست می کند.

این متدها را می توانید در کد بالا مشاهده کنید.

نکته قابل توجه اینکه ConfigureServices در متد Configure() وجود دارد و لازم نیست از قبل به آن دسترسی داشته باشید.

ایجاد ASP.NET CORE 2.0 MIDDLEWARE

در اینجا یک پروژه Hello Word را با ASP.NET Core Middleware ایجاد می کنیم.

Middleware چیست؟

عملکرد Middleware قرار گرفتن در مسیر اجرای درخواست‌های رسیده به فریم‌ورک است. Middlewareها می‌توانند درخواست‌های دریافت شده را بررسی کنند و در صورت نیاز اطلاعاتی به آن‌ها بیفزایند، آن‌ها را تغییر دهند یا به طور کلی مسیر اجرا را متوقف و مسیر دیگری هدایت کنند.

در کلاس Startup.cs و با استفاده از متد Configure() ایجاد پروژه را شروع می کنیم:

 public void Configure(
            IApplicationBuilder app,
            IHostingEnvironment env)
        {
            // setup request pipeline using middleware
            app.Run(async (context) =>
            {
                await context.Response.WriteAsync("Hello World! (Run)");
            });
        }

این یک روش خوب است که از IapplicationBuilder برای ساختن یک pipeline استفاده کنیم.

// RunMiddlewareExtensions.cs
        public static void RunHelloWorld(this IApplicationBuilder app)
        {
            app.Run(async (context) =>
            {
                await context.Response.WriteAsync("Hello World! (Run)");
            });
        }
        // Startup.cs
        public void Configure(
            IApplicationBuilder app,
            IHostingEnvironment env)
        {
            // setup request pipeline using middleware
            app.RunHelloWorld();
        }

برای پیکربندی Middleware ما از IApplicationBuilder.Run() استفاده کردیم اما می توانید از IApplicationBuilder.Use() نیز استفاده کنید.

 // UseMiddlewareExtensions.cs
        public static IApplicationBuilder UseHelloWorld(
            this IApplicationBuilder app)
        {
            return app.Use(async (context, next) =>
            {
                await context.Response.WriteAsync("Hello World! (Use)\n");
                await next();
            });
        }
        // Startup.cs
        public void Configure(
            IApplicationBuilder app,
            IHostingEnvironment env)
        {
            // setup request pipeline using middleware
            app.UseHelloWorld();
            app.RunHelloWorld();
        }

بهتر است اجزاء middleware را در یک کلاس جداگانه تعریف کنیم:

 public class HelloWorldMiddleware
    {
        private readonly RequestDelegate next;
 
        public HelloWorldMiddleware(RequestDelegate next)
        {
            this.next = next;
        }
 
        public async Task Invoke(HttpContext context)
        {
            await context.Response.WriteAsync("Hello World! (Use in Class)\n");
            await this.next(context);
        }
    }
    // UseMiddlewareExtensions.cs
    public static IApplicationBuilder UseHelloWorldInClass(
       this IApplicationBuilder app)
    {
    	  return app.UseMiddleware();
    }
    // Startup.cs
    public void Configure(
            IApplicationBuilder app,
            IHostingEnvironment env)
    {
        // setup request pipeline using middleware
        app.UseHelloWorld();
        app.UseHelloWorldInClass();
        app.RunHelloWorld();
    }

همانطور که در بالا اشاره کردیم، Middleware یک کامپوننت است که درخواست های HTTP را دریافت می کند و پاسخ میدهد. (HTTP request and response messages)

وقتی pipeline را در متد Configure() از طریق IapplicationBuilder تنظیم کردیم، می توانیم از متدهای دیگر برای پیکربندی Middleware استفاده کنیم.

• Run();
• Use();
• Map();

ASP.NET CORE 2.0 DEPENDENCY INJECTION

ایجاد یک سرویس:

public interface IGreetingService
    {
        string Greet(string to);
    }
 
    public class GreetingService : IGreetingService
    {
        public string Greet(string to)
        {
            return $"Hello {to}";
        }
    }

درخواست injection

 public static class UseMiddlewareExtensions
    {
        public static IApplicationBuilder UseHelloWorld(this IApplicationBuilder app)
        {
            return app.UseMiddleware();
        }
    }
 
    public class HelloWorldMiddleware
    {
        private readonly RequestDelegate next;
 
        public HelloWorldMiddleware(
            RequestDelegate next)
        {
            this.next = next;
        }
 
        public async Task Invoke(
            HttpContext context,
            IGreetingService greetingService)
        {
            var message = greetingService.Greet("World (via DI)");
            await context.Response.WriteAsync(message);
        }
    }

اضافه کردن AddScoped() به متد ConfigureServices() در کلاس Startup.cs:

اجرای سرویس شما نیاز به تنظیم پیچیده تر دارد:

  public void ConfigureServices(
            IServiceCollection services)
        {
            // setup dependency injection in service container
            services.AddScoped();
        }
 
        public void Configure(
            IApplicationBuilder app,
            IHostingEnvironment env)
        {
            // setup request pipeline using middleware
            app.UseHelloWorld();
        }

بنابراین یک متد factory برای ایجاد این سرویس ها ایجاد می کنیم:

 public class FlexibleGreetingService : IGreetingService
    {
        private readonly string sayWhat;
 
        public FlexibleGreetingService(string sayWhat)
        {
            this.sayWhat = sayWhat;
        }
 
        public string Greet(string to)
        {
            return $"{this.sayWhat} {to}";
        }
    }

متدهای قابل استفاده در این قسمت:

• AddScoped(): این سرویس ها در هر بار درخواست، یکبار ایجاد می شوند.
• AddTransient(): این سرویس ها در هر بار درخواست ایجاد می شوند.
• AddSingleton(): این سرویس برای درخواست اول ایجاد می شود و برای درخواست های دیگر نیز منتظر میماند.

ASP.NET CORE 2.0 CONFIGURATION

از طریق مراحل زیر به راحتی می تواند برنامه خود را پیکربندی کنید.

فایلهای appsettings.json و appsettings.Development.json را اضافه کنید:

// appsettings.json
{
  "Section1": {
    "SettingA": "ValueA",
    "SettingB": "ValueB"
  },
  "Section2": {
    "SettingC": "ValueC"
  }
}
// appsettings.Development.json
{
  "Section1": {
    "SettingA": "Dev_ValueA"
  },
  "Section2": {
    "SettingC": "Dev_ValueC"
  }
}

حال مشخصات پیکربندی را در کلاس Startup فراخوانی کنید:

 public static IConfiguration Config { get; private set; }
 
        public Startup(
            IConfiguration config)
        {
            Config = config;
        }

سپس سرویس ها را در متد ConfigureServicees() در کلاس Startup اضافه کنید:

  public void ConfigureServices(
            IServiceCollection services)
        {
            // setup dependency injection in service container
            services.AddOptions();
            services.Configure(Config);
        }

رابط Ioptions را به پروژه اضافه کنید:

 public class HelloWorldMiddleware
    {
        private readonly RequestDelegate next;
        private readonly AppSettings settings;
 
        public HelloWorldMiddleware(
            RequestDelegate next,
            IOptions options)
        {
            this.next = next;
            this.settings = options.Value;
        }
 
        public async Task Invoke(HttpContext context)
        {
            var jsonSettings = JsonConvert.SerializeObject(this.settings);
            await context.Response.WriteAsync(jsonSettings);
        }
    }

وقتی کدهای بالا را اجرا کردید خروجی زیر را به شما نشان می دهد:

Configuration-Output

ASP.NET Core یک مکانیزم ساده برای خواندن تنظیمات برنامه از منابع مختلف مانند فایل JSON، متغیرهای محیطی یا حتی منابع داده های سفارشی دارد. همچنین به لطف تزریق وابستگی می تواند به سادگی از تنظیمات استفاده کند.

  public static IWebHost BuildWebHost(string[] args)
        {
            return WebHost.CreateDefaultBuilder(args)
                           .ConfigureAppConfiguration((context, builder) =>
                           {
                               var env = context.HostingEnvironment;
 
                               builder.AddJsonFile("appsettings.json", 
                                            optional: true, reloadOnChange: true)
                                      .AddJsonFile($"appsettings.{env.EnvironmentName}.json", 
                                            optional: true, reloadOnChange: true);
 
                               if (env.IsDevelopment())
                               {
                                   var appAssembly = Assembly.Load(
                                       new AssemblyName(env.ApplicationName));
                                   if (appAssembly != null)
                                   {
                                       builder.AddUserSecrets(appAssembly, optional: true);
                                   }
                               }
 
                               builder.AddEnvironmentVariables();
 
                               if (args != null)
                               {
                                   builder.AddCommandLine(args);
                               }
                           })
                           .UseStartup()
                           .Build();
        }

ASP.NET CORE 2.0 ENVIRONMENTS

حال چگونه می توان رفتار برنامه را در محیط های مختلف تغییر داد؟

در متد Configure() از IhostingEnvironment استفاده می کنیم:

  public void Configure(
            IApplicationBuilder app,
            IHostingEnvironment env)
        {
            if (env.IsEnvironment("Development"))
                Run(app, "Development");
            else if (env.IsEnvironment("Staging"))
                Run(app, "Staging");
            else if (env.IsEnvironment("Production"))
                Run(app, "Production");
            else
                Run(app, env.EnvironmentName);
        }

متد IsEnvironment() را بعنوان یک متد extension فراخوانی می کنیم:

 public void Configure(
            IApplicationBuilder app,
            IHostingEnvironment env)
        {
            if (env.IsDevelopment())
                Run(app, "Development");
            else if (env.IsStaging())
                Run(app, "Staging");
            else if (env.IsProduction())
                Run(app, "Production");
            else
                Run(app, env.EnvironmentName);
        }

Asp.net core از یک رابط IhostingEnvironment برای کار در محیط های مختلف استفاده می کند که متد IsEnvironment() نیز مورد استفاده قرار می گیرد.

ASP.NET CORE 2.0 STATIC FILES

چگونه می توان محتوای (HTML، CSS، جاوا اسکریپت، تصاویر) را از برنامه Core ASP.NET ارائه داد؟

به این شکل با استفاده از متد Configure() در کلاس Startup می توان از middleware برای فایل های استاتیک استفاده کرد:

 public void Configure(
            IApplicationBuilder app,
            IHostingEnvironment env)
        {
            app.UseStaticFiles(); // for files in wwwroot folder
 
            app.UseStaticFiles(new StaticFileOptions() // for files in content folder
            {
                FileProvider = new PhysicalFileProvider(
                    Path.Combine(Directory.GetCurrentDirectory(), "content")),
                RequestPath = new PathString("/outside-content")
            });
 
            app.Run(async (context) =>
            {
                await context.Response.WriteAsync("Hello Static Files");
            });
        }

محتوای این فایل را به wwwroot اضافه کنید و یک فولدر content بسازید.

از طریق لینک زیر می توانید به این فایل دسترسی پیدا کنید:

• http://[site-address]/hello.html
• http://[site-address]/outside-content/info.html

فایل های استاتیک به طور پیش فرض از پوشه wwwroot خدمت می کنند و می توانید به مطالب از پوشه ریشه دسترسی پیدا کنید. پوشه پیش فرض را می توان از طریق WebHostBuilder در Program.cs تغییر داد:

UseWebRoot("public") // changed wwwroot to public

فایل های استاتیک نیز می توانند از پوشه های خارج از wwwroot با استفاده از StaticFileOptions و تنظیم FileProvider و RequestPath استفاده شوند.

منبع: tahirnaushad

"منتشر شده در سایت ABLY"