
آموزش معماری تمیز (Clean Architecture) در ASP.NET Core
آموزش معماری تمیز (Clean Architecture) در ASP.NET Core یکی دیگر از آموزش های گروه آموزشی پرووید می باشد که در این قسمت آن را به شما معرفی می کنیم. این بسته آموزشی نیز یکی از دوره های آموزشی دیگر که در حوزه فارسی سازی آموزش های انگلیسی تنظیم شده است می باشد. عنوان این بسته آموزشی، پیاده سازی معماری تمیز (Clean Architecture) در ASP.NET Core است که با نام اصلی ASP.NET Core 6 Clean Architecture از شرکت Pluralsight منتشر شده است.
معماری تمیز و یا Clean Architecture چیست؟
اپلیکیشن های تجاری و اصل dependency inversion و یا معکوس سازی وابستگی به همراه اصول طراحی دامنه محور و یا Domain-Driven Design (DDD) استفاده می کنند، اغلب به سمت یک معماری مشابه میروند. این معماری تحت نامهای متعدد و متفاوتی شناخته میشود. یکی از نامهای ابتدایی که برای این معماری در نظر گرفته شد، معماری شش ضلعی و یا hexagonal architecture بود. پس از آن از نام Ports-and-Adapters نیز برای این نامگذاری استفاده شده است. امروزه برای این معماری، نام هایی از قبیل معماری پیازی و یا onion architecture و معماری تمیز ویا clean architecture استفاده می شود. با این وجود بسیاری از منابع و کتاب ها و آموزش ها از معماری تمیز و یا clean architecture یاد می گردد.
معماری تمیز کمک میکند تا business logic و application model در مرکز معماری قرار بگیرند. به عبارت دیگر به جای اینکه business logic وابسته به data access یا کد های دیگرinfrastructure باشد، این وابستگی و یا dependency معکوس می گردد. به عبارت دیگر infrastructure و جزئیات پیاده سازی و یا implementation detail ها به Application Core وابسته هستند. این موضوع با تعریف کردن abstraction ها و یا interface ها در Application Core که نهایتاً در لایههای مختلف برنامه، به طور ویژه در پروژه Infrastructure پیاده سازی می شوند، امکان پذیر می گردند.
در تصویری که در قسمت زیر مشاهده می کنید، شکل کلی این معماری نمایش داده شده است دقت کنید که این شکل شبیه به پیاز از دایره های متحد المرکزی که لایههای مختلف برنامه را نشان میدهند، تشکیل شده است.

هماهطور که در تصویر بالا مشهده می کنید؛ وابستگی ها ازلایه های بیرونی تر به سمت لایه های درونی تر شکل گفته اند. لایه Application Core که در وسط و یا در هسته (Core) قرار گرفته است، مهمترین بخش معماری به حساب می آید. همانطور که در تصویر نیز مشخص است Application Core هیچ وابستگی به لایه هی دیگر ندارد. entity ها و اینترفیس های اپلیکیشن در مرکز قرار می گیرند. علاوه بر این در بیرون از این دایره، ولی همچنان در Application Core لایه domain service ها نیز قرار می گیرند که اغلب اینترفیس هایی که درون دایره وسط هستند را پیاده سازی می کنند. در بیرون از Application Core لایه های UI و infrastructure قرار گرفته که به Application Core وابسته هستند. تصویر زیر نیز لایه های مختلف معماری تمیز را اینبار به صورت افقی نشان می دهد، تا به وابستگی های موجود را به شکل بهتری درک کنیم.
در تصویر بالا پیکان هایی که بصورت خط تو پر نشان داده شده اند، نمایانگر dependency های compile-time هستند و پیکان هایی که به صورت خط چین هستند، نمایانگر dependency های run-time هستند. در معماری تمیز لایه UI با اینترفیس شده در Application Core در زمان کامپایل کار می کند. روال ایده آل این است که هیچ اطلاعی در رابطه با تایپ های پیاده سازی شده و یا implementation type های موجود در لایه infrastructure در دسترس نباشد. در زمان run-time این implementation type ها که مورد نیاز اپلیکیشن هستند، بایستی در اختیار اپلیکیشن قرار بگیرند. این موضوع با استفاده از dependency injection و اینترفیس های تعریف شده اتفاق می افتد.
اصول طراحی نرم افزار در Clean Architecture
در پروژه های نرم افزاری بزرگ، اگر منطق اصلی برنامه به فناوری های جانبی وابستگی زیادی داشته باشد، تغییر یا آزمایش بخش های مختلف سیستم دشوارتر می شود. Clean Architecture با تأکید بر جداسازی مسئولیت ها تلاش می کند منطق اصلی برنامه را از جزئیاتی مانند پایگاه داده، رابط کاربری و چارچوب های اجرایی مستقل تر نگه دارد. این جداسازی به توسعه دهندگان کمک می کند ساختار نرم افزار را بهتر سازماندهی کنند و تغییر یک بخش را با وابستگی کمتری به سایر بخش ها انجام دهند.
یکی از مفاهیم مهم در این رویکرد، Dependency Inversion است؛ اصلی که بر جهت وابستگی ها میان اجزای نرم افزار تأکید دارد. با طراحی مناسب مرزهای میان لایه ها، می توان منطق اصلی برنامه را به گونه ای پیاده سازی کرد که جزئیات زیرساختی به آن وابسته باشند، نه برعکس. در این آموزش با اصول مهم معماری نرم افزار و راه اندازی بخش های اصلی Application آشنا می شوید و یاد می گیرید چگونه این مفاهیم را در یک برنامه مبتنی بر ASP.NET Core به کار بگیرید.
پیاده سازی لایه های Application Core و Infrastructure در ASP.NET Core
در طراحی مبتنی بر Clean Architecture، بخش Application Core محل نگهداری منطق اصلی و مفاهیمی است که باید تا حد امکان مستقل از فناوری های بیرونی باقی بمانند. این بخش می تواند شامل مدل های دامنه، قواعد کسب و کار و قراردادهایی باشد که بخش های دیگر برنامه برای تعامل با منطق اصلی از آن ها استفاده می کنند. سازماندهی صحیح این مسئولیت ها باعث می شود ساختار برنامه روشن تر شود و تغییر نیازهای فنی تأثیر کمتری بر هسته سیستم داشته باشد.
لایه Infrastructure معمولاً مسئول پیاده سازی جزئیات فنی مانند ارتباط با پایگاه داده یا سرویس های خارجی است. جدا نگه داشتن این جزئیات از منطق اصلی به برنامه اجازه می دهد وابستگی ها را از طریق قراردادهای مشخص مدیریت کند. در این آموزش با ایجاد Application Core و پروژه Infrastructure آشنا می شوید و می توانید درک کنید که چگونه تفکیک مسئولیت ها به نگهداری و توسعه برنامه های ASP.NET Core کمک می کند. این ساختار همچنین زمینه مناسبی برای آزمایش بخش های مختلف نرم افزار فراهم می سازد.
تست پذیری و توسعه رابط کاربری در معماری تمیز
یکی از مزیت های مهم جداسازی منطق اصلی برنامه از جزئیات اجرایی، فراهم شدن شرایط بهتر برای آزمایش نرم افزار است. زمانی که بخش های مختلف سیستم از طریق قراردادهای مشخص با یکدیگر ارتباط دارند، می توان رفتار آن ها را با وابستگی کمتر به زیرساخت واقعی بررسی کرد. تست کردن کدهای اپلیکیشن به توسعه دهندگان کمک می کند مشکلات را زودتر شناسایی کنند و هنگام تغییر یا افزودن قابلیت های جدید، اطمینان بیشتری از حفظ رفتار مورد انتظار داشته باشند.
Clean Architecture همچنین اجازه می دهد رابط های کاربری و روش های دسترسی به برنامه در کنار هسته اصلی توسعه پیدا کنند، بدون اینکه تمام منطق کسب و کار در آن ها قرار گیرد. در این دوره، افزودن API با ASP.NET Core و پیاده سازی Blazor UI در کنار تست کدها بررسی می شود. این موضوع نشان می دهد که چگونه می توان بخش های مختلف یک اپلیکیشن را با حفظ مرزهای معماری سازماندهی کرد و توسعه رابط کاربری را از منطق اصلی سیستم جدا نگه داشت.
این آموزش Clean Architecture برای چه کسانی مناسب است؟
این دوره با سطح پیشرفته برای توسعه دهندگانی مناسب است که با ASP.NET Core آشنایی دارند و می خواهند ساختار برنامه های خود را بر اساس اصول معماری نرم افزار طراحی کنند. اگر در پروژه های تجاری با چالش هایی مانند وابستگی زیاد میان بخش ها، دشواری تست کردن منطق برنامه یا پیچیدگی تغییر فناوری های زیرساختی روبه رو هستید، یادگیری Clean Architecture می تواند به شما در درک بهتر راهکارهای جداسازی مسئولیت ها کمک کند.
این آموزش برای افرادی نیز مفید است که قصد دارند از پیاده سازی ساده Endpoint ها فراتر بروند و ساختار کلی یک اپلیکیشن را با توجه به نگهداری و توسعه بلندمدت طراحی کنند. آشنایی با Application Core، Infrastructure، API و Blazor در کنار تست نرم افزار به شما کمک می کند ارتباط میان لایه های مختلف را بهتر بشناسید. با درک این اصول می توانید هنگام طراحی سیستم های جدید یا بازنگری در پروژه های موجود، تصمیم های معماری آگاهانه تری بگیرید.
سرفصل مطالب آموزش ویدئویی معماری تمیز (Clean Architecture) در ASP.NET Core
فصل اول: مقدمه دوره آموزشی- مقدمه دوره آموزشی
- مقدمه
- بررسی یک معماری قوی برای اپلیکیشن های NET Core.
- آنچه باید قبل از شروع این دوره آموزشی بدانید
- آموزش عملی: بررسی اپلیکیشن این دوره آموزشی
- مقدمه
- بررسی اصول مهم در معماری نرم افزار
- برسی سبک های مختلف معماری نرم افزار
- بررسی معماری تمیز و یا Clean Architecture
- جمع بندی
- مقدمه
- بررسی نیازمندی های تجاری و یا Business Requirement ها
- راه اندازی کردن معماری اپلیکیشن
- آموزش عملی: ایجاد کردن یک Solution در ویژوال استودیو
- ساختن پروژه Domain
- آموزش عملی: ساختن پروژه Domain
- طراحی کردن پروژه اپلیکیشن
- آموزش عملی: ایجاد کردن پروژه اپلیکیشن
- استفاده کردن از MediatR و AutoMapper
- آموزش عملی: کار با Application Logic در Request Handler
- معرفی کردن CQRS در معماری
- آموزش عملی: اضافه کردن CQRS به درون معماری
- بررسی Feature ها
- آموزش عملی: سازماندهی کردن کد با استفاده از Feature ها
- آموزش عملی: استفاده از Command ها برای ایجاد یک Entity جدید
- افزودن Validation با استفاده از Fluent Validation
- آموزش عملی: افزودنValidation و Exception های سفارشی
- جمع بندی
- مقدمه
- بررسی اهداف پروژه های Infrastructure
- افزودن Data Persistence با استفاده از Entity Framework Core
- آموزش عملی: افزودن Entity Framework Core
- آموزش عملی: پیاده سازی کردن Persistence Layer
- اضافه کردن پروژه Infrastructure
- آموزش عملی: افزودن پشتیبانی کردن از ارسال ایمیل از درون پروژه Infrastructure
- جمع بندی
- مقدمه
- ایجاد کردن پروژه API
- آموزش عملی: ایجاد کردن پروژه API
- استفاده از از View Services به MediatR
- آموزش عملی: افزودن کد کنترلر با استفاده از MediatR
- تصمیم گیری درباره اینکه چه آبجکتی باید برگردانده شود
- آموزش عملی: برگرداندن View Model ها و Response ها
- آموزش عملی: افزودن پشتیبانی از بازگرداندن یک فایل CSV
- انتشار قابلیت های API با استفاده از Swagger
- آموزش عملی: اضافه کردن پشتیبانی از Swagger
- جمع بندی
- مقدمه
- بررسی انواع مختلف تست ها ایجاد Unit Test ها
- اضافه کردن Unit Test ها
- آموزش عملی: ایجاد کردن Unit Test ها برای کدهای اپلیکیشن
- آموزش عملی: نوشتن Integration Test برای پروژه Infrastructure
- آموزش عملی: نوشتن Integration Test برای کنترلرهای API
- جمع بندی
- مقدمه
- مقدمه ای بر Blazor Client-side
- استفاده از NSwag و NSwagStudio
- آموزش عملی: تولید کردن کد های Client با استفاده از Nswag
- بررسی Client App
- آموزش عملی: اضافه کردن اپلیکیشن Blazor
- آموزش عملی: اضافه کردن قابلیت Paging بصورت End-to-end
- جمع بندی
- مقدمه
- هندل کردن خطاها در API
- آموزش عملی: هندل کردن خطاها
- اضافه کردن Logging به معماری
- آموزش عملی: اضافه کردن Logging به معماری
- هویت سنجی و یا Authenticate کردن کاربران
- آموزش عملی: افزودن Authentication با استفاده از توکن ها
- آموزش عملی: افزودن Authentication به اپلیکیشن Blazor
- جمع بندی



