Clean Architecture في C#: بناء تطبيقات قابلة للاستمرار والتطوير

  Clean Architecture في C#: بناء تطبيقات قابلة للاستمرار والتطوير في عالم تطوير البرمجيات، ليست المشكلة في كتابة كود يعمل، بل في كتابة كود ي...

 

Clean Architecture في C#: بناء تطبيقات قابلة للاستمرار والتطوير

في عالم تطوير البرمجيات، ليست المشكلة في كتابة كود يعمل، بل في كتابة كود يظل يعمل بفعالية وسهولة مع تطور المتطلبات وتعاقب المطورين على المشروع. هنا تأتي الهندسة المعمارية النظيفة (Clean Architecture) كمنهجية ثورية تحقق هذا الهدف. في هذا المقال، سنستكشف كيفية تطبيق Clean Architecture في مشاريع C# لبناء تطبيقات متينة وقابلة للاختبار والصيانة.

ما هي Clean Architecture؟

هي مبادئ ومعمارية برمجية قدمها Robert C. Martin (Uncle Bob) تهدف إلى فصل concerns المشروع إلى طبقات مستقلة، حيث تكون قواعد العمل (Business Logic) في مركز التطبيق، معزولة تمامًا عن أي تفاصيل خارجية مثل قواعد البيانات، وواجهات المستخدم، أو frameworks خارجية.

الهيكل الحلقي للطبقات

تتبع Clean Architecture هيكلًا حلقيًا يتكون من أربع طبقات رئيسية:

1. Domain Layer (Core) - النواة

2. Application Layer - طبقة التطبيق

3. Infrastructure Layer - البنية التحتية

4. Presentation Layer - واجهة المستخدم

الطبقات بالتفصيل مع أمثلة C#

1. Domain Layer (النواة) - القلب النابض للتطبيق

هي الطبقة الأكثر استقرارًا ولا تعتمد على أي طبقة أخرى. تحتوي على:

• الكيانات (Entities): تمثل كائنات العمل الأساسية.

• القيم (Value Objects): كائنات لا يتم تعريفها بمعرف فريد.

• الاستثناءات (Exceptions): استثناءات مجال العمل.

• الواجهات (Interfaces): تعريف العقود التي يجب على الطبقات الخارجية تنفيذها.

csharp

// الكيان الأساسي
public class Product
{
    public int Id { get; private set; }
    public string Name { get; private set; }
    public decimal Price { get; private set; }
    
    public Product(string name, decimal price)
    {
        if (string.IsNullOrWhiteSpace(name))
            throw new DomainException("اسم المنتج مطلوب");
            
        if (price <= 0)
            throw new DomainException("السعر يجب أن يكون أكبر من الصفر");
        
        Name = name;
        Price = price;
    }
}

// واجهة المستودع - تعريف بدون تنفيذ
public interface IProductRepository
{
    Task<Product> GetByIdAsync(int id);
    Task AddAsync(Product product);
}

2. Application Layer (طبقة التطبيق) - تنفيذ حالات الاستخدام

تحتوي على منطق حالات الاستخدام (Use Cases) وتنسق تدفق البيانات:

• نمط Mediator و CQRS: باستخدام مكتبة MediatR.

• نمط الـ DTOs: كائنات نقل البيانات.

• الواجهات (Interfaces): للخدمات الخارجية.

csharp

// أمر (Command) لإنشاء منتج جديد
public record CreateProductCommand : IRequest<int>
{
    public string Name { get; init; }
    public decimal Price { get; init; }
}

// معالج الأمر (Command Handler)
public class CreateProductCommandHandler : IRequestHandler<CreateProductCommand, int>
{
    private readonly IProductRepository _productRepository;
    
    public CreateProductCommandHandler(IProductRepository productRepository)
    {
        _productRepository = productRepository;
    }
    
    public async Task<int> Handle(CreateProductCommand request, CancellationToken cancellationToken)
    {
        var product = new Product(request.Name, request.Price);
        await _productRepository.AddAsync(product);
        return product.Id;
    }
}

// استعلام (Query) للحصول على المنتجات
public record GetProductsQuery : IRequest<List<ProductDto>>;

public class ProductDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

3. Infrastructure Layer (البنية التحتية) - التفاصيل الخارجية

تحتوي على تنفيذ التفاصيل الخارجية:

• قواعد البيانات (Entity Framework Core)

• الخدمات الخارجية (APIs، البريد الإلكتروني)

• خدمات الملفات، التخزين

csharp

// تنفيذ مستودع Product باستخدام Entity Framework
public class ProductRepository : IProductRepository
{
    private readonly ApplicationDbContext _context;
    
    public ProductRepository(ApplicationDbContext context)
    {
        _context = context;
    }
    
    public async Task<Product> GetByIdAsync(int id)
    {
        return await _context.Products.FindAsync(id);
    }
    
    public async Task AddAsync(Product product)
    {
        await _context.Products.AddAsync(product);
        await _context.SaveChangesAsync();
    }
}

// تنفيذ خدمة البريد الإلكتروني
public class EmailService : IEmailService
{
    public async Task SendAsync(string to, string subject, string body)
    {
        // تنفيذ إرسال البريد
    }
}

4. Presentation Layer (واجهة المستخدم) - نقطة الدخول

يمكن أن تكون:

• Web API (ASP.NET Core)

• MVC

• Blazor

• Console Application

csharp

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly IMediator _mediator;
    
    public ProductsController(IMediator mediator)
    {
        _mediator = mediator;
    }
    
    [HttpPost]
    public async Task<ActionResult<int>> Create(CreateProductCommand command)
    {
        var productId = await _mediator.Send(command);
        return Ok(productId);
    }
    
    [HttpGet]
    public async Task<ActionResult<List<ProductDto>>> Get()
    {
        var products = await _mediator.Send(new GetProductsQuery());
        return Ok(products);
    }
}

مبدأ التبعية (Dependency Inversion)

المبدأ الأساسي: الطبقات الخارجية تعتمد على الطبقات الداخلية، وليس العكس.

csharp

// في Program.cs أو Startup.cs
// تسجيل الخدمات
services.AddScoped<IProductRepository, ProductRepository>();
services.AddScoped<IEmailService, EmailService>();
services.AddMediatR(typeof(CreateProductCommandHandler));

// في Infrastructure Layer
public static class DependencyInjection
{
    public static IServiceCollection AddInfrastructure(this IServiceCollection services, string connectionString)
    {
        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(connectionString));
            
        services.AddScoped<IProductRepository, ProductRepository>();
        
        return services;
    }
}

هيكل المشروع المقترح

text

src/
├── ProjectName.Domain/          // النواة
├── ProjectName.Application/     // طبقة التطبيق  
├── ProjectName.Infrastructure/  // البنية التحتية
└── ProjectName.Web/            // واجهة المستخدم

tests/
├── ProjectName.Domain.UnitTests/
├── ProjectName.Application.UnitTests/
└── ProjectName.Web.IntegrationTests/

الفوائد الرئيسية

1. الاستقلالية: يمكن تغيير قواعد البيانات أو واجهات المستخدم دون التأثير على قواعد العمل.

2. القابلية للاختبار: يمكن اختبار كل طبقة بمعزل عن الأخرى.

3. المرونة: سهولة إضافة features جديدة أو تغيير implementations.

4. الصيانة: كود نظيف ومنظم يسهل فهمه وتطويره.

5. التعاون: يمكن لفريق العمل التخصص في طبقات مختلفة.

التحديات والحلول

التحدي: تعقيد البداية
الحل: ابدأ بمشاريع صغيرة وتدرج في التعقيد.

التحدي: زيادة عدد الملفات
الحل: استخدام القوالب (Templates) وأدوات المساعدة.

التحدي: منحنى التعلم
الحل: التدريب المستمر ودراسة المشاريع الناجحة.

خاتمة

Clean Architecture في C# ليست مجرد هيكل تقني، بل هي فلسفة تطوير تركز على بناء تطبيقات تستطيع الصمود أمام اختبار الزمن. بالرغم من تعقيدها الظاهري في البداية، إلا أن الفوائد طويلة المدى تجعلها استثمارًا يستحق العناء. ابدأ بتطبيق مبادئها في مشاريعك التدريبية، وستجد نفسك قادرًا على بناء أنظمة أكثر احترافية وقابلية للاستمرار.

تذكر: "الهندسة المعمارية الجيدة تتيح لك تأجيل اتخاذ القرارات الصعبة إلى حين تكون مستعدًا لها" - Robert C. Martin.