Cuestión : transactionscopes jerarquizados

hola experts

see que el código del código below.
this consigue ejecutado siempre que ahorre una fila o una tabla al database.
A (entidad (de ISaveable)). Ahorrar () el ; el método puede también llamar otro excepto () el método para las tablas del niño o el niño rows.
so el método de InternalUpdateEntity () consigue épocas múltiples llamadas y los transactionscopes múltiples son used.

Now que tengo que las preguntas/Problems.
1. ellos todo el uso el mismo transactionscope o siempre un nuevo y hago esto incluso tengo sentido. ¿Debo mejorar apenas creo un transactionscope?

2. cuando consigo un error de la concurrencia en un transactionscope jerarquizado. ¿mi uso lanzará una excepción transactionaborted, a pesar de que cojo realmente exactamente esta excepción? ¿el
What podía causar eso?

thanks por adelantado para su help
I usando CONTRA 2008, C#, .NET 3.5, triunfo Forms

 class= > " claro " 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 vacío " del class= " del id= " codeSnippet787896 del 
 1 && rema [0]. ¡Tabla! = falta de información)
                Entidad = filas [0]. Tabla;
            
                vuelta;

            ¡si (entidad del && de vaeCollection.IsCollectionValid! = falta de información)
            {
                ConcurrencyError boleano = falso;
                
                ¿el usar (Ts de TransactionScope = ((falta de información del == de this.ParentTransaction)? nuevo TransactionScope (): nuevo TransactionScope (this.ParentTransaction)))
                {
                    intento
                    {
                        si (falta de información del == de this.ParentTransaction)
                            this.ParentTransaction = Transaction.Current.DependentClone (DependentCloneOption.BlockCommitUntilComplete);

                        si (== UpdateAction.Update de UpdateAction)
                        {
                            si (la entidad es ISaveable || La entidad es ISaveMultipleRows)
                            {
                                si (la entidad es && de ISaveMultipleRows Rows.Length > 1)
                                    (Entidad (de ISaveMultipleRows)). Ahorrar (filas);
                                
                                    (Entidad (de ISaveable)). Ahorrar ();
                            }
                        }
                        si (== UpdateAction.Delete de UpdateAction)
                        {
                            si (la entidad es IDeleteable || La entidad es IDeleteMultipleRows)
                            {
                                si (la entidad es && de IDeleteMultipleRows Rows.Length > 1)
                                {
                                    (Entidad (de IDeleteMultipleRows)) .DeleteObject (filas);

                                    si (DoCommit)
                                        (Entidad (de IDeleteMultipleRows)) .CommitDeletedObject (filas);
                                }
                                
                                {
                                    (Entidad (de IDeleteable)) .DeleteObject ();

                                    si (DoCommit)
                                        (Entidad (de IDeleteable)) .CommitDeletedObject ();
                                }
                            }
                        }

                        Ts.Complete ();
                    }
                    retén (TransactionAbortedException ex)
                    {
                        ¡si (this.DatabaseUpdateError! = falta de información)
                        {
                            encadenar el mensaje = “Fehler \ r \ n”;

                            ¡si (ex.InnerException! = falta de información)
                                Mensaje += ex.InnerException.Message + “\ r \ nStacktrace: ” + ex.InnerException.StackTrace;
                            
                                Mensaje += ex. Mensaje + “\ r \ nStacktrace: ” + ex.StackTrace;

                            this.DatabaseUpdateError (nuevo ExceptionEventArgs (mensaje));
                        }
                        ¡si (ex.InnerException! = falta de información)
                            tiro ex.InnerException;
                        
                            tiro ex;
                    }
                    retén (dex de DBConcurrencyException)
                    {
                        ¡si (ConcurrencyErrorOccured! = falta de información)
                            this.ConcurrencyErrorOccured (dex. Fila, nuevo EventArgs ());
                        //ConcurrencyError = verdad;
                        Ts.Dispose ();
                        vuelta;
                    }
                }
        }
}
class= > " claro " 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 vacío " del class= " del id= " codeSnippet787912 del 
 1 && rema [0]. ¡Tabla! = falta de información)
                Entidad = filas [0]. Tabla;
            
                vuelta;

            ¡si (entidad del && de vaeCollection.IsCollectionValid! = falta de información)
            {
                ConcurrencyError boleano = falso;
                
                el usar (Ts de TransactionScope = (nuevo TransactionScope ())
                {
                    intento
                    {
                       
                        si (== UpdateAction.Update de UpdateAction)
                        {
                            si (la entidad es ISaveable || La entidad es ISaveMultipleRows)
                            {
                                si (la entidad es && de ISaveMultipleRows Rows.Length > 1)
                                    (Entidad (de ISaveMultipleRows)). Ahorrar (filas);
                                
                                    (Entidad (de ISaveable)). Ahorrar ();
                            }
                        }
                        si (== UpdateAction.Delete de UpdateAction)
                        {
                            si (la entidad es IDeleteable || La entidad es IDeleteMultipleRows)
                            {
                                si (la entidad es && de IDeleteMultipleRows Rows.Length > 1)
                                {
                                    (Entidad (de IDeleteMultipleRows)) .DeleteObject (filas);

                                    si (DoCommit)
                                        (Entidad (de IDeleteMultipleRows)) .CommitDeletedObject (filas);
                                }
                                
                                {
                                    (Entidad (de IDeleteable)) .DeleteObject ();

                                    si (DoCommit)
                                        (Entidad (de IDeleteable)) .CommitDeletedObject ();
                                }
                            }
                        }

                        Ts.Complete ();
                    }
                    retén (TransactionAbortedException ex)
                    {
                        ¡si (this.DatabaseUpdateError! = falta de información)
                        {
                            encadenar el mensaje = “Fehler \ r \ n”;

                            ¡si (ex.InnerException! = falta de información)
                                Mensaje += ex.InnerException.Message + “\ r \ nStacktrace: ” + ex.InnerException.StackTrace;
                            
                                Mensaje += ex. Mensaje + “\ r \ nStacktrace: ” + ex.StackTrace;

                            this.DatabaseUpdateError (nuevo ExceptionEventArgs (mensaje));
                        }
                        ¡si (ex.InnerException! = falta de información)
                            tiro ex.InnerException;
                        
                            tiro ex;
                    }
                    retén (dex de DBConcurrencyException)
                    {
                        ¡si (ConcurrencyErrorOccured! = falta de información)
                            this.ConcurrencyErrorOccured (dex. Fila, nuevo EventArgs ());
                        //ConcurrencyError = verdad;
                        Ts.Dispose ();
                        vuelta;
                    }
                }
        }
}
class= del

Respuesta : transactionscopes jerarquizados

comprobar hacia fuera este artículo agradable:

http://www.15seconds.com/issue/060413.htm
Otras soluciones  
 
programming4us programming4us