EntityFramework - DbTransaction - Traitement multi-BLL
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:
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:
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:
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:
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
