Wzorzec CQRS w języku C# (jak działa dla programistów)

Krok 1: Skonfiguruj aplikację ASP.NET

1. Uruchom Visual Studio i wybierz opcję utworzenia nowego projektu.

2. Wyszukaj i wybierz typ projektu "Aplikacja internetowa .NET Core". Kliknij Dalej.

   

3. Nadaj projektowi nazwę i ustaw jego lokalizację. Kliknij Utwórz.
4. Wybierz szablon "Aplikacja internetowa (Model-View-Controller)" dla ASP.NET Core. Upewnij się, że wybierasz wersję .NET Core, która odpowiada Twoim wymaganiom. Kliknij Utwórz.

Krok 2

Następnie warto zorganizować projekt pod kątem CQRS. Można to zrobić, dodając foldery w celu oddzielenia poleceń, zapytań i wspólnych interfejsów, z których będą korzystać. W oknie Solution Explorer kliknij prawym przyciskiem myszy na swój projekt, wybierz "Dodaj", a następnie "Nowy folder". Utwórz trzy foldery: "Commands", "Queries" i "Interfaces".

W folderze "Interfaces" dodaj interfejsy dla swoich poleceń i zapytań. W przypadku polecenia może istnieć interfejs ICommandHandler z metodą Handle, która przyjmuje polecenie i wykonuje działanie. W przypadku zapytania można użyć interfejsu IQueryHandler z metodą Handle, która pobiera zapytanie i zwraca dane.

Krok 3

Teraz dodajmy polecenie i zapytanie, aby to zademonstrować. Załóżmy, że Twoja aplikacja zarządza zadaniami i chcesz dodać zadanie (polecenie) oraz pobrać zadania (zapytanie).

W folderze "Interfaces" dodaj dwa interfejsy:

// Define interfaces for your handlers:
public interface ICommandHandler<TCommand>
{
    void Handle(TCommand command);
}

public interface IQueryHandler<TQuery, TResult>
{
    TResult Handle(TQuery query);
}

// Define interfaces for your handlers:
public interface ICommandHandler<TCommand>
{
    void Handle(TCommand command);
}

public interface IQueryHandler<TQuery, TResult>
{
    TResult Handle(TQuery query);
}

' Define interfaces for your handlers:
Public Interface ICommandHandler(Of TCommand)
	Sub Handle(ByVal command As TCommand)
End Interface

Public Interface IQueryHandler(Of TQuery, TResult)
	Function Handle(ByVal query As TQuery) As TResult
End Interface

W folderze "Commands" dodaj klasę AddItemCommand z właściwościami dotyczącymi szczegółów zadania. Dodaj również klasę AddItemCommandHandler, która implementuje interfejs ICommandHandler i zawiera logikę dodawania zadania do bazy danych.

W folderze "Queries" dodaj klasę GetTasksQuery, która reprezentuje żądanie zadań. Dodaj kolejną klasę GetTasksQueryHandler, która implementuje interfejs IQueryHandler i zawiera logikę pobierania zadań z bazy danych.

Prosty przykład: Twój AddItemCommand może wyglądać następująco:

public class AddItemCommand
{
    public string Name { get; set; }
    public int Quantity { get; set; }

    // Constructor
    public AddItemCommand(string name, int quantity)
    {
        Name = name;
        Quantity = quantity;
    }
}

public class AddItemCommand
{
    public string Name { get; set; }
    public int Quantity { get; set; }

    // Constructor
    public AddItemCommand(string name, int quantity)
    {
        Name = name;
        Quantity = quantity;
    }
}

Public Class AddItemCommand
	Public Property Name() As String
	Public Property Quantity() As Integer

	' Constructor
	Public Sub New(ByVal name As String, ByVal quantity As Integer)
		Me.Name = name
		Me.Quantity = quantity
	End Sub
End Class

A także AddItemCommandHandler:

public class AddItemCommandHandler : ICommandHandler<AddItemCommand>
{
    public void Handle(AddItemCommand command)
    {
        // Here, you'd add the item to your database, for example, to have employee data stored
        Console.WriteLine($"Adding item: {command.Name} with quantity {command.Quantity}");
        // Add database logic here
    }
}

public class AddItemCommandHandler : ICommandHandler<AddItemCommand>
{
    public void Handle(AddItemCommand command)
    {
        // Here, you'd add the item to your database, for example, to have employee data stored
        Console.WriteLine($"Adding item: {command.Name} with quantity {command.Quantity}");
        // Add database logic here
    }
}

Public Class AddItemCommandHandler
	Implements ICommandHandler(Of AddItemCommand)

	Public Sub Handle(ByVal command As AddItemCommand)
		' Here, you'd add the item to your database, for example, to have employee data stored
		Console.WriteLine($"Adding item: {command.Name} with quantity {command.Quantity}")
		' Add database logic here
	End Sub
End Class

Twoja funkcja GetItemsQuery może być pusta, jeśli nie potrzebuje żadnych parametrów do pobrania zadań, a funkcja GetItemsQueryHandler może wyglądać następująco:

public class GetItemsQuery
{
    // This class might not need any properties, depending on your query
}

namespace CQRS_testing.Queries
{
    using CQRS_testing.Interfaces;

    public class GetItemsQueryHandler : IQueryHandler<GetItemsQuery, IEnumerable<string>>
    {
        public IEnumerable<string> Handle(GetItemsQuery query)
        {
            // Here, you'd fetch items from your database
            return new List<string> { "Item1", "Item2" };
        }
    }
}

public class GetItemsQuery
{
    // This class might not need any properties, depending on your query
}

namespace CQRS_testing.Queries
{
    using CQRS_testing.Interfaces;

    public class GetItemsQueryHandler : IQueryHandler<GetItemsQuery, IEnumerable<string>>
    {
        public IEnumerable<string> Handle(GetItemsQuery query)
        {
            // Here, you'd fetch items from your database
            return new List<string> { "Item1", "Item2" };
        }
    }
}

Imports CQRS_testing.Interfaces

Public Class GetItemsQuery
	' This class might not need any properties, depending on your query
End Class

Namespace CQRS_testing.Queries

	Public Class GetItemsQueryHandler
		Implements IQueryHandler(Of GetItemsQuery, IEnumerable(Of String))

		Public Function Handle(ByVal query As GetItemsQuery) As IEnumerable(Of String)
			' Here, you'd fetch items from your database
			Return New List(Of String) From {"Item1", "Item2"}
		End Function
	End Class
End Namespace

W kontrolerach ASP.NET będziesz używać tych procedur obsługi do przetwarzania poleceń i zapytań. Aby dodać zadanie, akcja kontrolera utworzyłaby AddTaskCommand, ustawiła jego właściwości na podstawie danych z formularza, a następnie przekazała go do instancji AddTaskCommandHandler w celu przetworzenia. W celu pobrania zadań wywoływałby on GetTasksQueryHandler, aby uzyskać dane i przekazać je do widoku.

Podłączanie w kontrolerze

Po skonfigurowaniu poleceń i zapytań można teraz używać ich w kontrolerach. Oto jak można to zrobić w klasie ItemsController:

public class ItemsController : Controller
{
    private readonly ICommandHandler<AddItemCommand> _addItemHandler;
    private readonly IQueryHandler<GetItemsQuery, IEnumerable<string>> _getItemsHandler;

    // Constructor injection is correctly utilized here
    public ItemsController(ICommandHandler<AddItemCommand> addItemHandler, IQueryHandler<GetItemsQuery, IEnumerable<string>> getItemsHandler)
    {
        _addItemHandler = addItemHandler;
        _getItemsHandler = getItemsHandler;
    }

    public IActionResult Index()
    {
        // Use the injected _getItemsHandler instead of creating a new instance
        var query = new GetItemsQuery();
        var items = _getItemsHandler.Handle(query);
        return View(items);
    }

    [HttpPost]
    public IActionResult Add(string name, int quantity)
    {
        // Use the injected _addItemHandler instead of creating a new instance
        var command = new AddItemCommand(name, quantity);
        _addItemHandler.Handle(command);
        return RedirectToAction("Index");
    }
}

public class ItemsController : Controller
{
    private readonly ICommandHandler<AddItemCommand> _addItemHandler;
    private readonly IQueryHandler<GetItemsQuery, IEnumerable<string>> _getItemsHandler;

    // Constructor injection is correctly utilized here
    public ItemsController(ICommandHandler<AddItemCommand> addItemHandler, IQueryHandler<GetItemsQuery, IEnumerable<string>> getItemsHandler)
    {
        _addItemHandler = addItemHandler;
        _getItemsHandler = getItemsHandler;
    }

    public IActionResult Index()
    {
        // Use the injected _getItemsHandler instead of creating a new instance
        var query = new GetItemsQuery();
        var items = _getItemsHandler.Handle(query);
        return View(items);
    }

    [HttpPost]
    public IActionResult Add(string name, int quantity)
    {
        // Use the injected _addItemHandler instead of creating a new instance
        var command = new AddItemCommand(name, quantity);
        _addItemHandler.Handle(command);
        return RedirectToAction("Index");
    }
}

Public Class ItemsController
	Inherits Controller

	Private ReadOnly _addItemHandler As ICommandHandler(Of AddItemCommand)
	Private ReadOnly _getItemsHandler As IQueryHandler(Of GetItemsQuery, IEnumerable(Of String))

	' Constructor injection is correctly utilized here
	Public Sub New(ByVal addItemHandler As ICommandHandler(Of AddItemCommand), ByVal getItemsHandler As IQueryHandler(Of GetItemsQuery, IEnumerable(Of String)))
		_addItemHandler = addItemHandler
		_getItemsHandler = getItemsHandler
	End Sub

	Public Function Index() As IActionResult
		' Use the injected _getItemsHandler instead of creating a new instance
		Dim query = New GetItemsQuery()
		Dim items = _getItemsHandler.Handle(query)
		Return View(items)
	End Function

	<HttpPost>
	Public Function Add(ByVal name As String, ByVal quantity As Integer) As IActionResult
		' Use the injected _addItemHandler instead of creating a new instance
		Dim command = New AddItemCommand(name, quantity)
		_addItemHandler.Handle(command)
		Return RedirectToAction("Index")
	End Function
End Class

Aby wszystko podłączyć, zwłaszcza jeśli używasz wstrzykiwania zależności (DI) w ASP.NET Core, musisz zarejestrować swoje procedury obsługi poleceń i zapytań w kontenerze DI w pliku Startup.cs. W ten sposób ASP.NET może udostępniać instancje twoich procedur obsługi, gdy są one potrzebne.

Oto bardzo prosty przykład rejestracji procedury obsługi:

builder.Services.AddTransient<ICommandHandler<AddItemCommand>, AddItemCommandHandler>();
builder.Services.AddTransient<IQueryHandler<GetItemsQuery, IEnumerable<string>>, GetItemsQueryHandler>();

builder.Services.AddTransient<ICommandHandler<AddItemCommand>, AddItemCommandHandler>();
builder.Services.AddTransient<IQueryHandler<GetItemsQuery, IEnumerable<string>>, GetItemsQueryHandler>();

builder.Services.AddTransient(Of ICommandHandler(Of AddItemCommand), AddItemCommandHandler)()
builder.Services.AddTransient(Of IQueryHandler(Of GetItemsQuery, IEnumerable(Of String)), GetItemsQueryHandler)()

W praktycznym zastosowaniu CQRS fundamentalne znaczenie ma rozróżnienie między modelem danych dla operacji zapisu a modelem dla operacji odczytu, co gwarantuje, że architektura obsługuje zróżnicowane i zoptymalizowane podejścia do przetwarzania danych.

Przykład kodu

Zobaczmy teraz, jak można wykorzystać IronPDF w aplikacji napisanej w języku C# zgodnie z wzorcem Command Query Responsibility Segregation (CQRS). Poniżej znajduje się uproszczony przykład pokazujący, jak można wykorzystać IronPDF w konfiguracji CQRS do wygenerowania raportu w formacie PDF. Ten przykład ma charakter koncepcyjny i skupia się na generowaniu dokumentu PDF jako polecenia.

using IronPdf;
using System.Threading.Tasks;

namespace PdfGenerationApp.Commands
{
    public class GeneratePdfReportCommand
    {
        // Command handler that generates a PDF report
        public async Task GenerateReportAsync(string reportContent, string outputPath)
        {
            // Initialize the IronPDF HTML to PDF renderer
            var renderer = new ChromePdfRenderer();
            // Use IronPDF to generate a PDF from HTML content
            var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(reportContent));
            // Save the generated PDF to a specified path
            pdf.SaveAs(outputPath);
        }
    }
}

using IronPdf;
using System.Threading.Tasks;

namespace PdfGenerationApp.Commands
{
    public class GeneratePdfReportCommand
    {
        // Command handler that generates a PDF report
        public async Task GenerateReportAsync(string reportContent, string outputPath)
        {
            // Initialize the IronPDF HTML to PDF renderer
            var renderer = new ChromePdfRenderer();
            // Use IronPDF to generate a PDF from HTML content
            var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(reportContent));
            // Save the generated PDF to a specified path
            pdf.SaveAs(outputPath);
        }
    }
}

Imports IronPdf
Imports System.Threading.Tasks

Namespace PdfGenerationApp.Commands
	Public Class GeneratePdfReportCommand
		' Command handler that generates a PDF report
		Public Async Function GenerateReportAsync(ByVal reportContent As String, ByVal outputPath As String) As Task
			' Initialize the IronPDF HTML to PDF renderer
			Dim renderer = New ChromePdfRenderer()
			' Use IronPDF to generate a PDF from HTML content
			Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf(reportContent))
			' Save the generated PDF to a specified path
			pdf.SaveAs(outputPath)
		End Function
	End Class
End Namespace

W tym przykładzie GeneratePdfReportCommand reprezentuje polecenie w wzorcu CQRS. Zawiera metodę GenerateReportAsync, która przyjmuje reportContent jako ciąg znaków HTML oraz outputPath, gdzie zostanie zapisany raport PDF. Klasa HtmlToPdf biblioteki IronPDF służy do konwersji treści HTML do formatu PDF, który jest następnie zapisywany w określonej ścieżce. Ta konfiguracja ilustruje, w jaki sposób można zintegrować funkcję generowania plików PDF z architekturą aplikacji, zwłaszcza w scenariuszach wymagających wyraźnego rozdzielenia obszarów odpowiedzialności, zgodnie z zaleceniami CQRS.