Questione : transactionscopes annidati

ciao experts

see che il codice di codice below.
this ottiene eseguito ogni volta che conservo una fila o una tabella al database.
A (entità (di ISaveable)). Conservare () il ; il metodo può anche denominare un altro salvo () il metodo per le tabelle del bambino o il bambino rows.
so il metodo di InternalUpdateEntity () ottiene i periodi multipli denominati e i transactionscopes multipli sono used.

Now che devo domande/Problems.
1. tutto l'uso lo stesso transactionscope o sempre un nuovo e faccio questo persino ho significato. Dovrei migliorare appena genero un transactionscope?

2. quando ottengo un errore di concorrenza in un transactionscope annidato. la mia applicazione getterà un'eccezione transactionaborted, malgrado il fatto che realmente interferisca esattamente questa eccezione? il
What ha potuto causare quello?

thanks in anticipo per il vostro help
I usando CONTRO 2008, C#, .NET 3.5, vittoria Forms

 class= > " libero " del
> " del codeSnippet " del class= del
class= " lineNumbers " del
class= del 
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:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
>private notpretty InternalUpdateEntity vuoto " del class= " del id= " codeSnippet787896 del 
 1 && rema [0]. Tabella! = posizione di segnale minimo)
                Entità = file [0]. Tabella;
            altrimenti
                ritorno;

            se (entità del && di vaeCollection.IsCollectionValid! = posizione di segnale minimo)
            {
                ConcurrencyError booleano = falso;
                
                usando (st di TransactionScope = ((posizione di segnale minimo del == di this.ParentTransaction)? nuovo TransactionScope (): nuovo TransactionScope (this.ParentTransaction)))
                {
                    prova
                    {
                        se (posizione di segnale minimo del == di this.ParentTransaction)
                            this.ParentTransaction = Transaction.Current.DependentClone (DependentCloneOption.BlockCommitUntilComplete);

                        se (== UpdateAction.Update di UpdateAction)
                        {
                            se (entità è ISaveable || L'entità è ISaveMultipleRows)
                            {
                                se (entità è && di ISaveMultipleRows Rows.Length > 1)
                                    (Entità (di ISaveMultipleRows)). Risparmiare (file);
                                altrimenti
                                    (Entità (di ISaveable)). Risparmiare ();
                            }
                        }
                        altrimenti se (== UpdateAction.Delete di UpdateAction)
                        {
                            se (entità è IDeleteable || L'entità è IDeleteMultipleRows)
                            {
                                se (entità è && di IDeleteMultipleRows Rows.Length > 1)
                                {
                                    (Entità (di IDeleteMultipleRows)) .DeleteObject (file);

                                    se (DoCommit)
                                        (Entità (di IDeleteMultipleRows)) .CommitDeletedObject (file);
                                }
                                altrimenti
                                {
                                    (Entità (di IDeleteable)) .DeleteObject ();

                                    se (DoCommit)
                                        (Entità (di IDeleteable)) .CommitDeletedObject ();
                                }
                            }
                        }

                        Ts.Complete ();
                    }
                    fermo (TransactionAbortedException ex)
                    {
                        se (this.DatabaseUpdateError! = posizione di segnale minimo)
                        {
                            mettere insieme il messaggio = “Fehler \ r \ n„;

                            se (ex.InnerException! = posizione di segnale minimo)
                                Messaggio += ex.InnerException.Message + “\ r \ nStacktrace: „ + ex.InnerException.StackTrace;
                            altrimenti
                                Messaggio += ex. Messaggio + “\ r \ nStacktrace: „ + ex.StackTrace;

                            this.DatabaseUpdateError (nuovo ExceptionEventArgs (messaggio));
                        }
                        altrimenti se (ex.InnerException! = posizione di segnale minimo)
                            tiro ex.InnerException;
                        altrimenti
                            tiro ex;
                    }
                    fermo (dex di DBConcurrencyException)
                    {
                        se (ConcurrencyErrorOccured! = posizione di segnale minimo)
                            this.ConcurrencyErrorOccured (dex. Fila, nuovo EventArgs ());
                        //ConcurrencyError = allinea;
                        Ts.Dispose ();
                        ritorno;
                    }
                }
        }
}
class= > " libero " del
> " del codeSnippet " del class= del
class= " lineNumbers " del
class= del 
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:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
>private notpretty InternalUpdateEntity vuoto " del class= " del id= " codeSnippet787912 del 
 1 && rema [0]. Tabella! = posizione di segnale minimo)
                Entità = file [0]. Tabella;
            altrimenti
                ritorno;

            se (entità del && di vaeCollection.IsCollectionValid! = posizione di segnale minimo)
            {
                ConcurrencyError booleano = falso;
                
                usando (st di TransactionScope = (nuovo TransactionScope ())
                {
                    prova
                    {
                       
                        se (== UpdateAction.Update di UpdateAction)
                        {
                            se (entità è ISaveable || L'entità è ISaveMultipleRows)
                            {
                                se (entità è && di ISaveMultipleRows Rows.Length > 1)
                                    (Entità (di ISaveMultipleRows)). Risparmiare (file);
                                altrimenti
                                    (Entità (di ISaveable)). Risparmiare ();
                            }
                        }
                        altrimenti se (== UpdateAction.Delete di UpdateAction)
                        {
                            se (entità è IDeleteable || L'entità è IDeleteMultipleRows)
                            {
                                se (entità è && di IDeleteMultipleRows Rows.Length > 1)
                                {
                                    (Entità (di IDeleteMultipleRows)) .DeleteObject (file);

                                    se (DoCommit)
                                        (Entità (di IDeleteMultipleRows)) .CommitDeletedObject (file);
                                }
                                altrimenti
                                {
                                    (Entità (di IDeleteable)) .DeleteObject ();

                                    se (DoCommit)
                                        (Entità (di IDeleteable)) .CommitDeletedObject ();
                                }
                            }
                        }

                        Ts.Complete ();
                    }
                    fermo (TransactionAbortedException ex)
                    {
                        se (this.DatabaseUpdateError! = posizione di segnale minimo)
                        {
                            mettere insieme il messaggio = “Fehler \ r \ n„;

                            se (ex.InnerException! = posizione di segnale minimo)
                                Messaggio += ex.InnerException.Message + “\ r \ nStacktrace: „ + ex.InnerException.StackTrace;
                            altrimenti
                                Messaggio += ex. Messaggio + “\ r \ nStacktrace: „ + ex.StackTrace;

                            this.DatabaseUpdateError (nuovo ExceptionEventArgs (messaggio));
                        }
                        altrimenti se (ex.InnerException! = posizione di segnale minimo)
                            tiro ex.InnerException;
                        altrimenti
                            tiro ex;
                    }
                    fermo (dex di DBConcurrencyException)
                    {
                        se (ConcurrencyErrorOccured! = posizione di segnale minimo)
                            this.ConcurrencyErrorOccured (dex. Fila, nuovo EventArgs ());
                        //ConcurrencyError = allinea;
                        Ts.Dispose ();
                        ritorno;
                    }
                }
        }
}
class= del

Risposta : transactionscopes annidati

verificare questo articolo piacevole:

http://www.15seconds.com/issue/060413.htm
Altre soluzioni  
 
programming4us programming4us