Comment dois-je gérer efficacement les connexions et les transactions avec Dapper ?

Gestion des connexions avec Dapper

Dans Dapper, la gestion des connexions est gérée de deux manières principales :

Gestion complète des connexions

Dans cette approche, le développeur est responsable de l'ouverture et de la fermeture explicite de la connexion. Semblable à la gestion des connexions dans ADO.NET.

Autoriser Dapper à gérer les connexions

Dapper peut ouvrir et fermer automatiquement les connexions si elles ne sont pas déjà gérées par le développeur. Cela revient à utiliser la méthode DataAdapter.Fill().

Cependant, il est recommandé aux développeurs de gérer leurs propres connexions, en particulier pour les scénarios impliquant plusieurs requêtes avec une granularité plus large (par exemple, par requête).

Meilleures pratiques de gestion des connexions

Pour éviter les fuites de ressources et améliorer les performances, les connexions doivent être fermées après utiliser. Ceci peut être réalisé en :

• Appelant Close(), Dispose() ou en enfermant la connexion dans un bloc using.

Pour améliorer davantage la gestion des ressources, envisagez de mettre en œuvre une unité de travail pour gérer les transactions.

Exemple de code pour l'unité de travail dans C#

L'exemple suivant fournit un exemple d'implémentation d'un UnitOfWork qui gère la gestion des transactions :

public sealed class UnitOfWork : IUnitOfWork
{
    internal UnitOfWork(IDbConnection connection)
    {
        _id = Guid.NewGuid();
        _connection = connection;
    }

    IDbConnection _connection = null;
    IDbTransaction _transaction = null;
    Guid _id = Guid.Empty;

    IDbConnection IUnitOfWork.Connection
    {
        get { return _connection; }
    }
    IDbTransaction IUnitOfWork.Transaction
    {
        get { return _transaction; }
    }
    Guid IUnitOfWork.Id
    {
        get { return _id; }
    }

    public void Begin()
    {
        _transaction = _connection.BeginTransaction();
    }

    public void Commit()
    {
        _transaction.Commit();
        Dispose();
    }

    public void Rollback()
    {
        _transaction.Rollback();
        Dispose();
    }

    public void Dispose()
    {
        if(_transaction != null)
            _transaction.Dispose();
        _transaction = null;
    }
}

Modèle de référentiel avec unité de travail

Les référentiels de ce code s'appuient sur l'injection de dépendances avec le constructeur pour recevoir le UnitOfWork, fournissant un emplacement central pour contrôler l'accès au base de données.

Exemple de code pour le référentiel avec unité de travail

public sealed class MyRepository
{
    public MyRepository(IUnitOfWork unitOfWork) 
    {
        this.unitOfWork = unitOfWork;
    }
    
    IUnitOfWork unitOfWork = null;

    public MyPoco Get()
    {
        return unitOfWork.Connection.Query(sql, param, unitOfWork.Transaction, .......);
    }

    public void Insert(MyPoco poco)
    {
        return unitOfWork.Connection.Execute(sql, param, unitOfWork.Transaction, .........);
    }
}

Utilisation de l'unité de travail

Exemple d'utilisation du UnitOfWork avec une transaction :

using(DalSession dalSession = new DalSession())
{
    UnitOfWork unitOfWork = dalSession.UnitOfWork;
    unitOfWork.Begin();
    try
    {
        //Database code
        MyRepository myRepository = new MyRepository(unitOfWork);
        myRepository.Insert(myPoco);
        unitOfWork.Commit();
    }
    catch
    {
        unitOfWork.Rollback();
        throw;
    }
}

Exemple d'utilisation de sans transaction :

using(DalSession dalSession = new DalSession())
{
    //Database code
    MyRepository myRepository = new MyRepository(dalSession.UnitOfWork);
    myRepository.Insert(myPoco);
}

En contrôlant les connexions et les transactions de manière centralisée avec une unité de travail, les développeurs peuvent améliorer la gestion des ressources et garantir une bonne intégrité des données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!