Vraag : genesteld transactionscopes

hallo experts

see de codebelow.
this uitgevoerd wordt wanneer ik een rij of een lijst aan database.
A ((ISaveable) bewaar Entiteit). Sparen () ; de methode kan een andere sparen () methode voor kindlijsten ook roepen of het kind rows.
so de () methode InternalUpdateEntity krijgt geroepen veelvoudige tijden en veelvoudige transactionscopes zijn used.

Now ik vragen/Problems.
1 moet. zullen zij allen zelfde transactionscope gebruiken of altijd nieuwe en dit ontdekt zelfs merk. ik beter één transactionscope enkel om tot stand te brengen moeten zou?

2. wanneer ik een overeenstemmingsfout in genesteld transactionscope krijg. mijn toepassing zal a transactionaborted uitzondering, ondanks het feit werpen dat ik precies deze uitzondering eigenlijk vang?
What kon dat veroorzaken?

thanks vooraf voor uw help
I am die VERSUS 2008, C# gebruiken, .NET 3.5, wint Forms
" codeBody " 
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 nietige InternalUpdateEntity ([] Rijen DataRow, ValidationErrorCollection vaeCollection, UpdateAction UpdateAction, DoCommit Van Boole)
        {
            objecten de Entiteit = verklaart nietig;

            als (Rows.Length == 1)
                Entiteit = Rijen [0];
            als anders (Rows.Length > Rijen 1 && [0]. Lijst! = verklaar) nietig
                Entiteit = Rijen [0]. Lijst;
            anders
                terugkeer;

            als (Entiteit vaeCollection.IsCollectionValid &&! = verklaar) nietig
            {
                ConcurrencyError van Boole = vals;
                
                het gebruiken (TransactionScope Ts = ((ongeldige this.ParentTransaction ==)? nieuwe TransactionScope (): nieuwe TransactionScope (this.ParentTransaction)))
                {
                    probeer
                    {
                        als (ongeldige this.ParentTransaction ==)
                            this.ParentTransaction = Transaction.Current.DependentClone (DependentCloneOption.BlockCommitUntilComplete);

                        als (UpdateAction == UpdateAction.Update)
                        {
                            als (de Entiteit is ISaveable || De entiteit is ISaveMultipleRows)
                            {
                                als (de Entiteit is ISaveMultipleRows && Rows.Length > 1)
                                    ((ISaveMultipleRows) Entiteit). Sparen (Rijen);
                                anders
                                    ((ISaveable) Entiteit). Sparen ();
                            }
                        }
                        als anders (UpdateAction == UpdateAction.Delete)
                        {
                            als (de Entiteit is IDeleteable || De entiteit is IDeleteMultipleRows)
                            {
                                als (de Entiteit is IDeleteMultipleRows && Rows.Length > 1)
                                {
                                    ((IDeleteMultipleRows) Entiteit) .DeleteObject (Rijen);

                                    als (DoCommit)
                                        ((IDeleteMultipleRows) Entiteit) .CommitDeletedObject (Rijen);
                                }
                                anders
                                {
                                    ((IDeleteable) Entiteit) .DeleteObject ();

                                    als (DoCommit)
                                        ((IDeleteable) Entiteit) .CommitDeletedObject ();
                                }
                            }
                        }

                        Ts.Complete ();
                    }
                    vangst (ex TransactionAbortedException)
                    {
                        als (this.DatabaseUpdateError! = verklaar) nietig
                        {
                            koord Bericht = „Fehler \ r \ n“;

                            als (ex.InnerException! = verklaar) nietig
                                Bericht += ex.InnerException.Message + „\ r \ nStacktrace: “ + ex.InnerException.StackTrace;
                            anders
                                Ex bericht +=. Bericht + „\ r \ nStacktrace: “ + ex.StackTrace;

                            this.DatabaseUpdateError (nieuwe ExceptionEventArgs (Bericht));
                        }
                        als anders (ex.InnerException! = verklaar) nietig
                            werp ex.InnerException;
                        anders
                            werp ex;
                    }
                    vangst (DBConcurrencyException dex)
                    {
                        als (ConcurrencyErrorOccured! = verklaar) nietig
                            this.ConcurrencyErrorOccured (dex. Rij, nieuwe EventArgs ());
                        //ConcurrencyError = waar;
                        Ts.Dispose ();
                        terugkeer;
                    }
                }
        }
}
" codeBody " 
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 nietige InternalUpdateEntity ([] Rijen DataRow, ValidationErrorCollection vaeCollection, UpdateAction UpdateAction, DoCommit Van Boole)
        {
            objecten de Entiteit = verklaart nietig;

            als (Rows.Length == 1)
                Entiteit = Rijen [0];
            als anders (Rows.Length > Rijen 1 && [0]. Lijst! = verklaar) nietig
                Entiteit = Rijen [0]. Lijst;
            anders
                terugkeer;

            als (Entiteit vaeCollection.IsCollectionValid &&! = verklaar) nietig
            {
                ConcurrencyError van Boole = vals;
                
                het gebruiken (TransactionScope Ts = (nieuwe TransactionScope ())
                {
                    probeer
                    {
                       
                        als (UpdateAction == UpdateAction.Update)
                        {
                            als (de Entiteit is ISaveable || De entiteit is ISaveMultipleRows)
                            {
                                als (de Entiteit is ISaveMultipleRows && Rows.Length > 1)
                                    ((ISaveMultipleRows) Entiteit). Sparen (Rijen);
                                anders
                                    ((ISaveable) Entiteit). Sparen ();
                            }
                        }
                        als anders (UpdateAction == UpdateAction.Delete)
                        {
                            als (de Entiteit is IDeleteable || De entiteit is IDeleteMultipleRows)
                            {
                                als (de Entiteit is IDeleteMultipleRows && Rows.Length > 1)
                                {
                                    ((IDeleteMultipleRows) Entiteit) .DeleteObject (Rijen);

                                    als (DoCommit)
                                        ((IDeleteMultipleRows) Entiteit) .CommitDeletedObject (Rijen);
                                }
                                anders
                                {
                                    ((IDeleteable) Entiteit) .DeleteObject ();

                                    als (DoCommit)
                                        ((IDeleteable) Entiteit) .CommitDeletedObject ();
                                }
                            }
                        }

                        Ts.Complete ();
                    }
                    vangst (ex TransactionAbortedException)
                    {
                        als (this.DatabaseUpdateError! = verklaar) nietig
                        {
                            koord Bericht = „Fehler \ r \ n“;

                            als (ex.InnerException! = verklaar) nietig
                                Bericht += ex.InnerException.Message + „\ r \ nStacktrace: “ + ex.InnerException.StackTrace;
                            anders
                                Ex bericht +=. Bericht + „\ r \ nStacktrace: “ + ex.StackTrace;

                            this.DatabaseUpdateError (nieuwe ExceptionEventArgs (Bericht));
                        }
                        als anders (ex.InnerException! = verklaar) nietig
                            werp ex.InnerException;
                        anders
                            werp ex;
                    }
                    vangst (DBConcurrencyException dex)
                    {
                        als (ConcurrencyErrorOccured! = verklaar) nietig
                            this.ConcurrencyErrorOccured (dex. Rij, nieuwe EventArgs ());
                        //ConcurrencyError = waar;
                        Ts.Dispose ();
                        terugkeer;
                    }
                }
        }
}

Antwoord : genesteld transactionscopes

controleer dit aardige artikel:

http://www.15seconds.com/issue/060413.htm
Andere oplossingen  
 
programming4us programming4us