Dapper - лучший среди микроORM под C#

using (var connection = new SqlConnection(connectionString))
{
    var users = connection.Query<User>("SELECT * FROM Users WHERE Active = @Active", new { Active = true });
    // Вот и всё!
}

public static IEnumerable<T> Query<T>(this IDbConnection cnn, string sql, object param = null, ...);
public static int Execute(this IDbConnection cnn, string sql, object param = null, ...);
public static T QueryFirst<T>(this IDbConnection cnn, string sql, object param = null, ...);
public static IEnumerable<TReturn> Query<TFirst, TSecond, TReturn>(this IDbConnection cnn, string sql, ...);

var customers = connection.Query<Customer>(@"
    SELECT c.*, a.* 
    FROM Customers c 
    LEFT JOIN Addresses a ON c.Id = a.CustomerId 
    WHERE c.Active = @isActive", 
    new { isActive = true });

var customers = context.Customers
    .Where(c => c.Active)
    .Include(c => c.Addresses)
    .ToList();

using (var multi = connection.QueryMultiple("SELECT * FROM Orders WHERE Id = @id; SELECT * FROM OrderLines WHERE OrderId = @id", new { id = 10 }))
{
    var order = multi.Read<Order>().First();
    var lines = multi.Read<OrderLine>().ToList();
    order.Lines = lines;
}

var results = connection.Query<Customer>("GetCustomerById", 
    new { Id = 42 }, 
    commandType: CommandType.StoredProcedure);

var p = new DynamicParameters();
p.Add("@id", 1);
p.Add("@totalCount", dbType: DbType.Int32, direction: ParameterDirection.Output);
 
connection.Execute("GetOrderCount", p, commandType: CommandType.StoredProcedure);
var count = p.Get<int>("@totalCount");

// Пример бенчмарка производительности
[Benchmark]
public List<User> DapperQuery()
{
    using (var connection = new SqlConnection(_connectionString))
    {
        return connection.Query<User>("SELECT * FROM Users WHERE Department = @Dept", 
            new { Dept = "IT" }).ToList();
    }
}
 
[Benchmark]
public List<User> EntityFrameworkQuery()
{
    using (var context = new AppDbContext(_connectionString))
    {
        return context.Users.Where(u => u.Department == "IT").ToList();
    }
}

// Правильное использование соединений с Dapper
using (var connection = new SqlConnection(_connectionString))
{
    connection.Open(); // Соединение берется из пула
    
    // Можно выполнить несколько запросов в рамках одного соединения
    var customers = connection.Query<Customer>("SELECT * FROM Customers");
    var orders = connection.Query<Order>("SELECT * FROM Orders");
    
} // Соединение автоматически возвращается в пул

using (var connection = new SqlConnection(_connectionString))
{
    connection.Open();
    using (var transaction = connection.BeginTransaction())
    {
        try
        {
            connection.Execute("INSERT INTO Orders (CustomerId) VALUES (@CustomerId)", 
                new { CustomerId = 42 }, transaction);
                
            connection.Execute("UPDATE Customers SET OrderCount = OrderCount + 1 WHERE Id = @Id", 
                new { Id = 42 }, transaction);
                
            transaction.Commit();
        }
        catch
        {
            transaction.Rollback();
            throw;
        }
    }
}

// Пример вставки множества записей с использованием табличного параметра
var table = new DataTable();
table.Columns.Add("Name", typeof(string));
table.Columns.Add("Age", typeof(int));
 
foreach (var person in people)
{
    table.Rows.Add(person.Name, person.Age);
}
 
var parameter = new SqlParameter("@People", SqlDbType.Structured)
{
    TypeName = "dbo.PersonTableType",
    Value = table
};
 
connection.Execute("INSERT INTO People (Name, Age) SELECT Name, Age FROM @People", 
    new { People = parameter });

// Потоковая обработка большого объема данных
var customers = connection.Query<Customer>(
    "SELECT * FROM Customers", 
    buffered: false);
 
foreach (var customer in customers)
{
    // Обработка по одной записи за раз, без загрузки всего набора в память
    ProcessCustomer(customer);
}

// Асинхронное выполнение запроса
public async Task<IEnumerable<Customer>> GetCustomersAsync(string country)
{
    using (var connection = new SqlConnection(_connectionString))
    {
        await connection.OpenAsync();
        return await connection.QueryAsync<Customer>(
            "SELECT * FROM Customers WHERE Country = @Country", 
            new { Country = country });
    }
}

// Статическая типизация
var customers = connection.Query<Customer>("SELECT * FROM Customers");
 
// Динамическая типизация
var dynamicResults = connection.Query("SELECT Name, Age FROM Customers");
foreach (dynamic result in dynamicResults)
{
    string name = result.Name; // Доступ к свойству динамически
    int age = result.Age;
}

var sql = @"
    SELECT * FROM Orders WHERE CustomerId = @customerId;
    SELECT * FROM OrderItems WHERE OrderId IN (SELECT Id FROM Orders WHERE CustomerId = @customerId);
    SELECT * FROM Customers WHERE Id = @customerId";
 
using (var multi = connection.QueryMultiple(sql, new { customerId = 10 }))
{
    var orders = multi.Read<Order>().ToList();
    var items = multi.Read<OrderItem>().ToList();
    var customer = multi.Read<Customer>().SingleOrDefault();
    
    // Связывание объектов в памяти
    foreach (var order in orders)
    {
        order.Items = items.Where(i => i.OrderId == order.Id).ToList();
        order.Customer = customer;
    }
}

// Работа с SQL Server
using (var sqlConnection = new SqlConnection(sqlServerConnectionString))
{
    var result = sqlConnection.Query<User>("SELECT * FROM Users");
}
 
// Работа с PostgreSQL 
using (var npgsqlConnection = new NpgsqlConnection(postgresConnectionString))
{
    var result = npgsqlConnection.Query<User>("SELECT * FROM Users");
}
 
// Работа с SQLite
using (var sqliteConnection = new SQLiteConnection(sqliteConnectionString))
{
    var result = sqliteConnection.Query<User>("SELECT * FROM Users");
}

var sql = @"
    WITH MenuCTE AS (
        SELECT Id, Name, ParentId, 0 AS Level
        FROM MenuItems
        WHERE ParentId IS NULL
        
        UNION ALL
        
        SELECT m.Id, m.Name, m.ParentId, cte.Level + 1
        FROM MenuItems m
        INNER JOIN MenuCTE cte ON m.ParentId = cte.Id
    )
    SELECT * FROM MenuCTE ORDER BY Level, Name";
 
var flatMenu = connection.Query<MenuItem>(sql);
var rootItems = flatMenu.Where(i => i.ParentId == null).ToList();
 
// Преобразование плоского списка в дерево
foreach (var item in flatMenu.Where(i => i.ParentId != null))
{
    var parent = flatMenu.First(p => p.Id == item.ParentId);
    if (parent.Children == null) parent.Children = new List<MenuItem>();
    parent.Children.Add(item);
}

Dapper.SqlMapper.AddTypeHandler(new SqlGeographyTypeHandler());
 
var locations = connection.Query<Location>(
    "SELECT Id, Name, Coordinates FROM Locations WHERE Coordinates.STDistance(@point) < 10000",
    new { point = DbGeography.FromText("POINT(37.4220 -122.0841)") });

using (var reader = connection.ExecuteReader("SELECT * FROM HugeTable"))
{
    while (reader.Read())
    {
        var item = new DataItem
        {
            Id = reader.GetInt32(0),
            Name = reader.GetString(1),
            // ...другие поля
        };
        
        ProcessItem(item); // Обработка одной записи вместо загрузки всех в память
    }
}

// Использование C# records
public record User(int Id, string Name, string Email);
 
// Использование интерполированных строк и неявной типизации
string name = "John";
var users = connection.Query<User>($"SELECT * FROM Users WHERE Name LIKE @Name", new { Name = $"%{name}%" });
 
// Использование кортежей
var results = connection.Query<(int Id, string Name, string Email)>("SELECT Id, Name, Email FROM Users");
foreach (var (id, name, email) in results)
{
    Console.WriteLine($"User {name} (ID: {id}) has email {email}");
}

// Извлечение данных из JSON-поля в SQL Server
var products = connection.Query<Product>(@"
    SELECT 
        Id,
        JSON_VALUE(Attributes, '$.Color') AS Color,
        JSON_VALUE(Attributes, '$.Size') AS Size
    FROM Products
    WHERE ISJSON(Attributes) = 1
      AND JSON_VALUE(Attributes, '$.Color') = @Color",
    new { Color = "Red" });

Install-Package Dapper

public class OrderRepository : IOrderRepository
{
    private readonly string _connectionString;
 
    public OrderRepository(string connectionString)
    {
        _connectionString = connectionString;
    }
 
    public Order GetById(int id)
    {
        using var connection = new SqlConnection(_connectionString);
        var order = connection.QueryFirstOrDefault<Order>(
            "SELECT * FROM Orders WHERE Id = @Id", new { Id = id });
            
        if (order != null)
        {
            // Загрузка связанных элементов заказа
            order.Items = connection.Query<OrderItem>(
                "SELECT * FROM OrderItems WHERE OrderId = @OrderId", 
                new { OrderId = id }).ToList();
        }
        
        return order;
    }
    
    public void Save(Order order)
    {
        using var connection = new SqlConnection(_connectionString);
        connection.Open();
        using var transaction = connection.BeginTransaction();
        
        try
        {
            if (order.Id == 0)
            {
                // Вставка нового заказа
                order.Id = connection.ExecuteScalar<int>(
                    "INSERT INTO Orders (CustomerId, OrderDate, Status) VALUES (@CustomerId, @OrderDate, @Status); SELECT SCOPE_IDENTITY()",
                    order,
                    transaction);
            }
            else
            {
                // Обновление существующего заказа
                connection.Execute(
                    "UPDATE Orders SET CustomerId = @CustomerId, OrderDate = @OrderDate, Status = @Status WHERE Id = @Id",
                    order,
                    transaction);
                    
                // Удаление существующих элементов заказа
                connection.Execute(
                    "DELETE FROM OrderItems WHERE OrderId = @Id",
                    new { order.Id },
                    transaction);
            }
            
            // Вставка элементов заказа
            if (order.Items?.Any() == true)
            {
                foreach (var item in order.Items)
                {
                    item.OrderId = order.Id;
                    connection.Execute(
                        "INSERT INTO OrderItems (OrderId, ProductId, Quantity, Price) VALUES (@OrderId, @ProductId, @Quantity, @Price)",
                        item,
                        transaction);
                }
            }
            
            transaction.Commit();
        }
        catch
        {
            transaction.Rollback();
            throw;
        }
    }
}

public class OrderProcessor
{
    private readonly string _connectionString;
    
    public OrderProcessor(string connectionString)
    {
        _connectionString = connectionString;
    }
    
    public ProcessResult ProcessOrder(int orderId)
    {
        using var connection = new SqlConnection(_connectionString);
        
        var parameters = new DynamicParameters();
        parameters.Add("@OrderId", orderId);
        parameters.Add("@ProcessedBy", Environment.UserName);
        parameters.Add("@Success", dbType: DbType.Boolean, direction: ParameterDirection.Output);
        parameters.Add("@Message", dbType: DbType.String, size: 500, direction: ParameterDirection.Output);
        
        connection.Execute(
            "ProcessOrder",
            parameters,
            commandType: CommandType.StoredProcedure);
            
        return new ProcessResult
        {
            Success = parameters.Get<bool>("@Success"),
            Message = parameters.Get<string>("@Message")
        };
    }
}

public BlogPost GetFullBlogPost(int id)
{
    using var connection = new SqlConnection(_connectionString);
    
    var sql = @"
        SELECT p.*, a.* FROM BlogPosts p
        LEFT JOIN Authors a ON p.AuthorId = a.Id
        WHERE p.Id = @Id;
        
        SELECT c.*, u.* FROM Comments c
        LEFT JOIN Users u ON c.UserId = u.Id
        WHERE c.PostId = @Id;
        
        SELECT t.* FROM Tags t
        INNER JOIN PostTags pt ON t.Id = pt.TagId
        WHERE pt.PostId = @Id;";
    
    using var multi = connection.QueryMultiple(sql, new { Id = id });
    
    var blogPostWithAuthor = multi.Read<BlogPost, Author, BlogPost>(
        (post, author) => {
            post.Author = author;
            return post;
        },
        splitOn: "Id").FirstOrDefault();
    
    if (blogPostWithAuthor != null)
    {
        var comments = multi.Read<Comment, User, Comment>(
            (comment, user) => {
                comment.User = user;
                return comment;
            },
            splitOn: "Id").ToList();
            
        var tags = multi.Read<Tag>().ToList();
        
        blogPostWithAuthor.Comments = comments;
        blogPostWithAuthor.Tags = tags;
    }
    
    return blogPostWithAuthor;
}

public class GetRecentOrdersQuery : IQuery<List<OrderSummary>>
{
    private readonly string _connectionString;
    
    public GetRecentOrdersQuery(string connectionString)
    {
        _connectionString = connectionString;
    }
    
    public List<OrderSummary> Execute(int customerId, int days = 30)
    {
        using var connection = new SqlConnection(_connectionString);
        
        return connection.Query<OrderSummary>(@"
            SELECT o.Id, o.OrderDate, o.Status, 
                  (SELECT COUNT(*) FROM OrderItems WHERE OrderId = o.Id) AS ItemCount,
                  (SELECT SUM(Price * Quantity) FROM OrderItems WHERE OrderId = o.Id) AS TotalAmount
            FROM Orders o
            WHERE o.CustomerId = @CustomerId
              AND o.OrderDate >= @StartDate
            ORDER BY o.OrderDate DESC",
            new { 
                CustomerId = customerId,
                StartDate = DateTime.Now.AddDays(-days)
            }).ToList();
    }
}

public class CreateOrderCommand : ICommand
{
    private readonly IUnitOfWork _unitOfWork;
    
    public CreateOrderCommand(IUnitOfWork unitOfWork)
    {
        _unitOfWork = unitOfWork;
    }
    
    public int Execute(OrderDto orderDto)
    {
        _unitOfWork.Begin();
        
        try
        {
            var orderId = _unitOfWork.Connection.ExecuteScalar<int>(
                "INSERT INTO Orders (CustomerId, OrderDate, Status) VALUES (@CustomerId, @OrderDate, @Status); SELECT SCOPE_IDENTITY()",
                new { 
                    CustomerId = orderDto.CustomerId,
                    OrderDate = DateTime.Now,
                    Status = "New"
                },
                _unitOfWork.Transaction);
                
            foreach (var item in orderDto.Items)
            {
                _unitOfWork.Connection.Execute(
                    "INSERT INTO OrderItems (OrderId, ProductId, Quantity, Price) VALUES (@OrderId, @ProductId, @Quantity, @Price)",
                    new {
                        OrderId = orderId,
                        item.ProductId,
                        item.Quantity,
                        item.Price
                    },
                    _unitOfWork.Transaction);
            }
            
            _unitOfWork.Commit();
            return orderId;
        }
        catch
        {
            _unitOfWork.Rollback();
            throw;
        }
    }
}

public interface IUnitOfWork : IDisposable
{
    IDbConnection Connection { get; }
    IDbTransaction Transaction { get; }
    
    void Begin();
    void Commit();
    void Rollback();
}
 
public class DapperUnitOfWork : IUnitOfWork
{
    private readonly string _connectionString;
    private IDbConnection _connection;
    private IDbTransaction _transaction;
    private bool _disposed = false;
    
    public DapperUnitOfWork(string connectionString)
    {
        _connectionString = connectionString;
    }
    
    public IDbConnection Connection
    {
        get
        {
            if (_connection == null)
            {
                _connection = new SqlConnection(_connectionString);
                _connection.Open();
            }
            return _connection;
        }
    }
    
    public IDbTransaction Transaction => _transaction;
    
    public void Begin()
    {
        if (_transaction != null)
            throw new InvalidOperationException("Транзакция уже начата");
            
        _transaction = Connection.BeginTransaction();
    }
    
    public void Commit()
    {
        if (_transaction == null)
            throw new InvalidOperationException("Нет активной транзакции для подтверждения");
            
        try
        {
            _transaction.Commit();
        }
        finally
        {
            _transaction.Dispose();
            _transaction = null;
        }
    }
    
    public void Rollback()
    {
        if (_transaction == null)
            throw new InvalidOperationException("Нет активной транзакции для отката");
            
        try
        {
            _transaction.Rollback();
        }
        finally
        {
            _transaction.Dispose();
            _transaction = null;
        }
    }
    
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                if (_transaction != null)
                {
                    _transaction.Dispose();
                    _transaction = null;
                }
                
                if (_connection != null)
                {
                    _connection.Dispose();
                    _connection = null;
                }
            }
            
            _disposed = true;
        }
    }
}

public interface IDbConnectionFactory
{
    IDbConnection CreateConnection();
}
 
public class SqlConnectionFactory : IDbConnectionFactory
{
    private readonly string _connectionString;
    
    public SqlConnectionFactory(string connectionString)
    {
        _connectionString = connectionString;
    }
    
    public IDbConnection CreateConnection()
    {
        return new SqlConnection(_connectionString);
    }
}

public class CustomerRepository : ICustomerRepository
{
    private readonly IDbConnectionFactory _connectionFactory;
    
    public CustomerRepository(IDbConnectionFactory connectionFactory)
    {
        _connectionFactory = connectionFactory;
    }
    
    public Customer GetById(int id)
    {
        using var connection = _connectionFactory.CreateConnection();
        return connection.QueryFirstOrDefault<Customer>(
            "SELECT * FROM Customers WHERE Id = @Id", 
            new { Id = id });
    }
}

[Fact]
public void GetById_ReturnsCustomer_WhenCustomerExists()
{
    // Arrange
    var customer = new Customer { Id = 1, Name = "Test Customer" };
    
    var mockConnection = new Mock<IDbConnection>();
    var mockConnectionFactory = new Mock<IDbConnectionFactory>();
    
    mockConnectionFactory.Setup(f => f.CreateConnection())
        .Returns(mockConnection.Object);
        
    mockConnection.SetupDapper(c => c.QueryFirstOrDefault<Customer>(
        It.IsAny<string>(), 
        It.Is<object>(p => p.GetType().GetProperty("Id").GetValue(p).Equals(1)), 
        null, null, null))
        .Returns(customer);
    
    var repository = new CustomerRepository(mockConnectionFactory.Object);
    
    // Act
    var result = repository.GetById(1);
    
    // Assert
    Assert.Equal(1, result.Id);
    Assert.Equal("Test Customer", result.Name);
}

public static class DapperMockExtensions
{
    public static Mock<IDbConnection> SetupDapper<T>(
        this Mock<IDbConnection> mock,
        Expression<Func<IDbConnection, T>> expression,
        T returns)
    {
        mock.Setup(expression).Returns(returns);
        return mock;
    }
}

public class CustomerRepositoryTests : IDisposable
{
    private readonly string _connectionString = "Data Source=:memory:;Version=3;New=True;";
    private readonly IDbConnection _connection;
    private readonly CustomerRepository _repository;
    
    public CustomerRepositoryTests()
    {
        _connection = new SQLiteConnection(_connectionString);
        _connection.Open();
        
        // Создание таблиц
        _connection.Execute(@"
            CREATE TABLE Customers (
                Id INTEGER PRIMARY KEY,
                Name TEXT,
                Email TEXT
            )");
            
        // Заполнение тестовыми данными
        _connection.Execute(@"
            INSERT INTO Customers (Id, Name, Email) VALUES 
            (1, 'John Doe', 'john@example.com'),
            (2, 'Jane Smith', 'jane@example.com')");
            
        _repository = new CustomerRepository(new SqliteConnectionFactory(_connectionString));
    }
    
    [Fact]
    public void GetById_ReturnsCustomer_WhenCustomerExists()
    {
        // Act
        var customer = _repository.GetById(1);
        
        // Assert
        Assert.NotNull(customer);
        Assert.Equal("John Doe", customer.Name);
    }
    
    public void Dispose()
    {
        _connection.Close();
        _connection.Dispose();
    }
}

public class MongoRepository<T> where T : class, IEntity
{
    private readonly IMongoDatabase _database;
    private readonly string _collectionName;
    
    public MongoRepository(IMongoDatabase database, string collectionName)
    {
        _database = database;
        _collectionName = collectionName;
    }
    
    public IEnumerable<T> Query(string filterJson)
    {
        var collection = _database.GetCollection<BsonDocument>(_collectionName);
        var filter = BsonDocument.Parse(filterJson);
        var documents = collection.Find(filter).ToList();
        
        // Используем Dapper для маппинга BsonDocument в наши объекты
        return documents.Select(doc => {
            var json = doc.ToJson();
            using var reader = new StringReader(json);
            using var jsonReader = new JsonTextReader(reader);
            return Dapper.SqlMapper.DeserializeObject<T>(jsonReader);
        });
    }
}

// В Entity Framework это делается автоматически
context.SaveChanges();
 
// В Dapper нужно писать явный UPDATE-запрос
connection.Execute("UPDATE Users SET Name = @Name, Email = @Email WHERE Id = @Id", 
    new { user.Id, user.Name, user.Email });

// Пример использования DbUp для выполнения миграций
var upgrader = DeployChanges.To
    .SqlDatabase(connectionString)
    .WithScriptsEmbeddedInAssembly(Assembly.GetExecutingAssembly())
    .LogToConsole()
    .Build();
 
var result = upgrader.PerformUpgrade();

// Сложный динамический запрос в Dapper
var sql = "SELECT u.*, a.* FROM Users u";
if (includeAddresses)
    sql += " LEFT JOIN Addresses a ON u.Id = a.UserId";
sql += " WHERE 1=1";
if (!string.IsNullOrEmpty(name))
    sql += " AND u.Name LIKE @Name";
// ... и так далее
 
var results = connection.Query<User, Address, User>(sql, /* ... */);

public class HybridRepository
{
    private readonly MyDbContext _context;
    
    public HybridRepository(MyDbContext context)
    {
        _context = context;
    }
    
    public List<SimpleEntity> GetSimpleEntities()
    {
        // Используем Entity Framework для простых запросов
        return _context.SimpleEntities.Where(e => e.IsActive).ToList();
    }
    
    public List<ComplexReport> GetComplexReport()
    {
        // Используем Dapper для сложных запросов
        var connection = _context.Database.GetDbConnection();
        var sql = @"SELECT d.DepartmentName, COUNT(e.Id) as EmployeeCount, 
                   SUM(e.Salary) as TotalSalary
                   FROM Employees e
                   JOIN Departments d ON e.DepartmentId = d.Id
                   GROUP BY d.DepartmentName
                   HAVING COUNT(e.Id) > 5";
                   
        return connection.Query<ComplexReport>(sql).ToList();
    }
}

// Command - используем EF для изменения данных
public void CreateOrder(Order order)
{
    _dbContext.Orders.Add(order);
    _dbContext.SaveChanges();
}
 
// Query - используем Dapper для быстрого чтения
public List<OrderSummary> GetOrderSummaries(int customerId)
{
    return _dbContext.Database.GetDbConnection()
        .Query<OrderSummary>(@"
            SELECT o.Id, o.OrderDate, COUNT(i.Id) as ItemCount 
            FROM Orders o
            LEFT JOIN OrderItems i ON o.Id = i.OrderId
            WHERE o.CustomerId = @CustomerId
            GROUP BY o.Id, o.OrderDate",
            new { CustomerId = customerId })
        .ToList();
}

_dbContext.ChangeTracker.Clear(); // Для EF Core 5.0+