Bonjour,

j'ai une petite question concernant le context de base de données et les transactions.

j'ai plusieurs class BLL (ClientBLL, projetBLL, ...). Pour certains opérations, j'utilise plusieurs BLL en même temps, par exemple :
dans clientBLL :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
 
public void Traitement1()
{
    // .... faire des calculs
    // .... faire des choses avec la BDD
 
    projetBLL.Traitement();
 
    // ..... faire des autres choses avec BDD
}
("projetBLL.Traitement()" fait également des opérations en BDD)
Bien entendu, il peut m'arrive d'appeler directement "projetBLL.Traitement()" sans passer par ClientBLL.

Ma question, j'aimerai une transaction autour du bloc :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
 
    // .... faire des choses avec la BDD
 
    projetBLL.Traitement()
 
    // ..... faire des autres choses avec BDD
tout en conservant "l'autonomie" de "projetBLL.Traitement()" (qui peut lui avoir sa propre transaction seulement si je l'appelle directement).

J'ai donc pensé à utiliser un objet "DataContext" :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
public class DataContext : IDisposable
    {
        public static ModelContainer Context
 
        protected DbTransaction _transaction;
        public DataContext()
        {
            if (Context == null)
            {
                Context = new KCModelContainer();
                Context.Connection.Open();
                _transaction = Context.Connection.BeginTransaction();
            }
        }
 
        public void Commit()
        {
            if (_transaction != null)
            {
                _transaction.Commit();
                _transaction.Dispose();
                _transaction = null;
            }
        }
 
        public void Rollback()
        {
            if (_transaction != null)
            {
                _transaction.Rollback();
                _transaction.Dispose();
                _transaction = null;
            }
        }
 
        public void Dispose()
        {
            if (_transaction != null)
            {
                _transaction.Rollback();
                if (Context.Connection.State != System.Data.ConnectionState.Closed)
                {
                    Context.Connection.Close();
                }
                Context.Dispose();
                Context = null;
            }
        }
    }
que j'utiliserai comme ça :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
 
public void Traitement1()
{
    // ..... faire des calculs
    using(DataContext context = new DataContext())
    {
            // .... faire des choses avec la BDD
 
            projetBLL.Traitement()
 
            // ..... faire des autres choses avec BDD
 
           context.Commit();
    }
}
Et dans "projetBLL.Traitement()" je fais le même "using" ; comme ca, c'est l'objet BLL qui a initialisé la connexion (et donc la transaction) qui "commit" le tout.

Qu'en pensez vous ?

Est-ce une bonne approche ?

Si non, comment faire pour "partager" une transaction entre objet business ?

Merci