Domain Events

using System;

namespace Basics.Events
{
    public class OrderPlacedEvent : EventArgs
    {
        public long OrderId { get; set; }
        public DateTime OrderDate { get; set; }
        public string CustomerName { get; set; }

        public OrderPlacedEvent(long orderId, DateTime orderDate, string customerName)
        {
            OrderId = orderId;
            OrderDate = orderDate;
            CustomerName = customerName;
        }
    }

    public class EventBus
    {
        private static EventBus _instance;

        // Event definition
        public event EventHandler<OrderPlacedEvent> OrderPlaced;

        private EventBus() { }

        public static EventBus Instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new EventBus();
                }
                return _instance;
            }
        }

        // Method to publish the event
        public void PublishOrderPlacedEvent(long orderId, DateTime orderDate, string customerName)
        {
            OrderPlaced?.Invoke(this, new OrderPlacedEvent(orderId, orderDate, customerName));
        }
    }
}

using System;
using Basics.Events;

public class Program
{
    public static void Main(string[] args)
    {
        // Subscription to the "Order placed" event
        EventBus.Instance.OrderPlaced += HandleOrderPlacedEvent;

        // Place order and trigger event
        PlaceOrder(34059020106036052, DateTime.Now, "Walter Hartwell White");
    }

    public static void PlaceOrder(long orderId, DateTime orderDate, string customerName)
    {
        // The logic for order processing would take place here

        // Triggering the "Order placed" event
        EventBus.Instance.PublishOrderPlacedEvent(orderId, orderDate, customerName);
    }

    public static void HandleOrderPlacedEvent(object sender, OrderPlacedEvent e)
    {
        Console.WriteLine($"New order received: ID={e.OrderId}, Date={e.OrderDate}, Customer={e.CustomerName}");

        // Further actions could be carried out here, e.g., send a confirmation email
    }
}

using MediatR;
using System;

namespace With_MediatR.Events
{
    public class OrderPlacedEvent : INotification
    {
        public long OrderId { get; set; }
        public DateTime OrderDate { get; set; }
        public string CustomerName { get; set; }

        public OrderPlacedEvent(long orderId, DateTime orderDate, string customerName)
        {
            OrderId = orderId;
            OrderDate = orderDate;
            CustomerName = customerName;
        }
    }
}

using MediatR;
using System.Threading;
using System.Threading.Tasks;
using With_MediatR.Events;

namespace With_MediatR.Handlers
{
    public class OrderPlacedEventHandler : INotificationHandler<OrderPlacedEvent>
    {
        public Task Handle(OrderPlacedEvent notification, CancellationToken cancellationToken)
        {
            // Beispielhafte Verarbeitung des Ereignisses
            Console.WriteLine($"Order placed: ID = {notification.OrderId}, Date = {notification.OrderDate}, Customer = {notification.CustomerName}");
            return Task.CompletedTask;
        }
    }
}

using MediatR;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Reflection;
using System.Threading.Tasks;
using With_MediatR.Events;
using With_MediatR.Handlers;

public class Program
{
    public static async Task Main(string[] args)
    {
        try
        {
            // Configuration and initialisation of MediatR
            var serviceProvider = ConfigureServices();
            var mediator = serviceProvider.GetRequiredService<IMediator>();

            // Place order and trigger event
            var orderId = GenerateOrderId();
            var orderDate = DateTime.Now;
            var customerName = "Walter Hartwell White";

            await mediator.Publish(new OrderPlacedEvent(orderId, orderDate, customerName));

            Console.ReadLine();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }

    private static IServiceProvider ConfigureServices()
    {
        var services = new ServiceCollection();

        // Add MediatR
        services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()));

        // Structure of the service provider
        return services.BuildServiceProvider();
    }

    private static long GenerateOrderId()
    {
        // Dynamische Generierung einer Order-ID
        return DateTime.Now.Ticks;
    }
}

using MediatR;
using Microsoft.Extensions.DependencyInjection;
using System.Reflection;
using With_MediatR_CQRS.Commands;
using With_MediatR_CQRS.EventHandlers;
using With_MediatR_CQRS.Handlers;
using With_MediatR_CQRS.Queries;
using With_MediatR_CQRS.Repositories;

public class Program
{
  public static async Task Main(string[] args)
  {
    // Configuration and initialisation of MediatR
    var serviceProvider = ConfigureServices();
    var mediator = serviceProvider.GetRequiredService<IMediator>();

    // Creation of the command to create a new order
    var createOrderCommand = new CreateOrderCommand
    {
      OrderId = 034059020106036052,
      CustomerName = "Walter Hartwell White",
      OrderDate = DateTime.Now,
      Products = new List<string> { "BlueProduct #1", "BlueProduct #2" }
    };

    // Call the handler for the command to create a new order
    await mediator.Send(createOrderCommand);// [call CreateOrderCommandHandler]

    // Creation of the query for orders from a specific customer
    var getOrdersQuery = new GetOrdersQuery
    {
      CustomerName = "Walter Hartwell White"
    };

    // Call up handler for querying orders from a specific customer
    var orders = await mediator.Send(getOrdersQuery); // [call GetOrdersQueryHandler]

    Console.WriteLine($"Number of orders for {getOrdersQuery.CustomerName}: {orders.Count}");
  }

  private static IServiceProvider ConfigureServices()
  {
    var services = new ServiceCollection();

    //Register repositories and handlers
    services.AddTransient<OrderRepository>();
    services.AddTransient<CreateOrderCommandHandler>();
    services.AddTransient<OrderCreatedEventHandler>();
    services.AddTransient<GetOrdersQueryHandler>();

    // Add MediatR
    services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()));

    return services.BuildServiceProvider();
  }
}

using MediatR;
using With_MediatR_CQRS.Classes;

namespace With_MediatR_CQRS.Queries;

public class GetOrdersQuery : IRequest<List<Order>>
{
  public string CustomerName { get; set; }
}

using MediatR;
using With_MediatR_CQRS.Commands;
using With_MediatR_CQRS.Events;

namespace With_MediatR_CQRS.Handlers;

public class CreateOrderCommandHandler : IRequestHandler<CreateOrderCommand>
{
  private readonly IMediator _mediator;

  public CreateOrderCommandHandler(IMediator mediator)
  {
    _mediator = mediator;
  }

  public async Task Handle(CreateOrderCommand request, CancellationToken cancellationToken)
  {
    // This is where the logic for creating a new order would take place
    Console.WriteLine($"New order created at {request.OrderDate}: ID={request.OrderId}, Customer={request.CustomerName}");

    // Triggering the domain event "Order created"
    await _mediator.Publish(new OrderCreatedEvent(request.OrderId, request.CustomerName, request.OrderDate, request.Products));

  }
}

using MediatR;

namespace With_MediatR_CQRS.Events;

public class OrderCreatedEvent : INotification
{
  public long OrderId { get; }
  public string CustomerName { get; }
  public DateTime OrderDate { get; set; }
  public List<string> Products { get; }

  public OrderCreatedEvent(long orderId, string customerName,DateTime orderDate, List<string> products)
  {
    OrderId = orderId;
    CustomerName = customerName;
    OrderDate = orderDate;
    Products = products;
  }
} 

using MediatR;
using With_MediatR_CQRS.Classes;
using With_MediatR_CQRS.Events;
using With_MediatR_CQRS.Repositories;

namespace With_MediatR_CQRS.EventHandlers;

public class OrderCreatedEventHandler : INotificationHandler<OrderCreatedEvent>
{
    private readonly OrderRepository _orderRepository;

    public OrderCreatedEventHandler(OrderRepository orderRepository)
    {
        _orderRepository = orderRepository;
    }

    public Task Handle(OrderCreatedEvent notification, CancellationToken cancellationToken)
    {
        // For this example, we simulate the receipt of the order 15 minutes after the order was placed
        Console.WriteLine($"New order received at {DateTime.Now.AddMinutes(+15)}: ID={notification.OrderId}, Customer={notification.CustomerName}");

        foreach (var product in notification.Products)
        {
            Console.WriteLine($"Product added: {product}");
        }

        // Save the order in the repository
        _orderRepository.Add(new Order(notification.OrderId, notification.CustomerName, notification.OrderDate, notification.Products));

        return Task.CompletedTask;
    }
} 

using MediatR;

namespace With_MediatR_CQRS.Commands;

public class CreateOrderCommand : IRequest
{
  public long OrderId { get; set; }
  public string CustomerName { get; set; }
  public DateTime OrderDate { get; set; }
  public List<string> Products { get; set; }
}
namespace With_MediatR_CQRS.Classes;

public class Order
{
  public long OrderId { get; }
  public string CustomerName { get; }
  public DateTime OrderDate { get; set; }
  public List<string> Products { get; }

  public Order(long orderId, string customerName, DateTime orderDate, List<string> products)
  {
    OrderId = orderId;
    CustomerName = customerName;
    OrderDate = orderDate;
    Products = products;
  }
}