Using The CQRS Pattern In C#

Next, we look at the two middle-tier components (These are in the Queries and Commands folders),

Queries (To read data)

using ConsoleAppCQRSPattern.DTOs;  
namespace ConsoleAppCQRSPattern.Queries {  
    public interface IEmployeeQueries {  
        EmployeeDTO FindByID(int employeeID);  
    }  
}  
using System;  
using ConsoleAppCQRSPattern.Repositories;  
using ConsoleAppCQRSPattern.DTOs;  
namespace ConsoleAppCQRSPattern.Queries {  
    public class EmployeeQueries {  
        private readonly IEmployeeQueriesRepository _repository;  
        public EmployeeQueries(IEmployeeQueriesRepository repository) {  
            _repository = repository;  
        }  
        public EmployeeDTO FindByID(int employeeID) {  
            var emp = _repository.GetByID(employeeID);  
            return new EmployeeDTO {  
                Id = emp.Id,  
                    FullName = emp.FirstName + " " + emp.LastName,  
                    Address = emp.Street + " " + emp.City + " " + emp.PostalCode,  
                    Age = Convert.ToInt32(Math.Abs(((DateTime.Now - emp.DateOfBirth).TotalDays) / 365)) - 1  
            };  
        }  
    }  
}  

Commands (To write data)

using ConsoleAppCQRSPattern.Models;  
namespace ConsoleAppCQRSPattern.Commands {  
    public interface IEmployeeCommands {  
        void SaveEmployeeData(Employee employee);  
    }  
}  
using ConsoleAppCQRSPattern.Models;  
using ConsoleAppCQRSPattern.Repositories;  
namespace ConsoleAppCQRSPattern.Commands {  
    public class EmployeeCommands: IEmployeeCommands {  
        private readonly IEmployeeCommandsRepository _repository;  
        public EmployeeCommands(IEmployeeCommandsRepository repository) {  
            _repository = repository;  
        }  
        public void SaveEmployeeData(Employee employee) {  
            _repository.SaveEmployee(employee);  
        }  
    }  
}  

Here we see that we have separate operation handling components. Two other classes are the main Employee class which mirrors our storage item and the Employee DTO class which is used by the Queries (Read) operations to return data in a shape required by the consuming client.

namespace ConsoleAppCQRSPattern.DTOs {  
    public class EmployeeDTO {  
        public int Id {  
            get;  
            set;  
        }  
        public string FullName {  
            get;  
            set;  
        }  
        public int Age {  
            get;  
            set;  
        }  
        public string Address {  
            get;  
            set;  
        }  
    }  
}  
using System;  
namespace ConsoleAppCQRSPattern.Models {  
    public class Employee {  
        public int Id {  
            get;  
            set;  
        }  
        public string FirstName {  
            get;  
            set;  
        }  
        public string LastName {  
            get;  
            set;  
        }  
        public DateTime DateOfBirth {  
            get;  
            set;  
        }  
        public string Street {  
            get;  
            set;  
        }  
        public string City {  
            get;  
            set;  
        }  
        public string PostalCode {  
            get;  
            set;  
        }  
    }  
}  

Finally, we call these operations from the main Program class. Please note that in this demo application, we create an instance of the repository directly. In a real-world scenario, we would probably use some dependency injection framework to do this.

using ConsoleAppCQRSPattern.Commands;  
using ConsoleAppCQRSPattern.Queries;  
using ConsoleAppCQRSPattern.Repositories;  
using System;  
namespace ConsoleAppCQRSPattern {  
    classProgram {  
        staticvoid Main(string[] args) {  
            // Command the Employee Domain to save data  
            var employeeCommand = new EmployeeCommands(new EmployeeCommandsRepository());  
            employeeCommand.SaveEmployeeData(new Models.Employee {  
                Id = 200, FirstName = "Jane", LastName = "Smith", Street = "150 Toronto Street", City = "Toronto", PostalCode = "j1j1j1", DateOfBirth = new DateTime(2002, 2, 2)  
            });  
            Console.WriteLine($ "Employee data stored");  
            // Query the Employee Domain to get data  
            var employeeQuery = new EmployeeQueries(new EmployeeQueriesRepository());  
            var employee = employeeQuery.FindByID(100);  
            Console.WriteLine($ "Employee ID:{employee.Id}, Name:{employee.FullName}, Address:{employee.Address}, Age:{employee.Age}");  
            Console.ReadKey();  
        }  
    }  
}  

When we run this application, we see the below output,

Going for an interview, here are the Top C# Interview Questions Guaranteed to Help You Pass Your C# Interview.

Summary

In this article, we looked at the CQRS (Command and Query Responsibility Segregation) pattern and what are the advantages of using this pattern. The example given here is a simple one, but the main idea was to give an outline of how this pattern is to be implemented. The overall layout might be modified further to meet your specific requirement e.g. the repositories could be combined. However, as mentioned earlier, this pattern is better suited to larger applications where the requirements for read-and-write operations may vary or be overly complex. For simple CRUD operations, we might not need to implement this pattern. Happy Coding!