Ignora TransactionScope per query specifiche

Question

Sto cercando un modo per eseguire una query mentre TransactionScope è vivo, e ignoro TransactionScope: in pratica, voglio eseguire questa particolare query indipendentemente da cosa.

Sto utilizzando il codice EF, e il modo in cui l'applicazione è progettata, un nuovo contesto di dati viene aperto più volte in una singola chiamata, ognuno con le proprie modifiche e tutte queste sono contenute in un singolo TransactionScope , che ha chiamato Complete() alla fine, senza problemi. All'interno del contesto abbiamo sovrascritto lo SaveChanges in modo che se si verifica un'eccezione su base.SaveChanges(), possiamo prenderlo e accedere al database prima di eseguire il rollback della transazione.

Poiché il SaveChanges si verifica all'interno della transazione, la registrazione ovviamente non si verifica, perché appartiene alla stessa transazione della chiamata originale. Sto cercando di ignorare completamente TransactionScope solo per il codice di registrazione.

Ecco po 'di codice stripped-down:

// From the context 
public override int SaveChanges() { 
    try { 
     return base.SaveChanges(); 
    } catch (Exception ex) { 

     // Writes to the log table - I want this to run no matter what 
     LogRepo.Log(/*stuff to log from the context*/); 

     throw; 
    } 
} 

// Inside the business logic 
public void DoSomething() { 
    try { 
     using (var scope = new TransactionScope()) { 

      using (var context = new FooContext()) { 
       // Do something 
       context.SaveChanges(); 
      } 
      using (var context = new FooContext()) { 
       // Do something else 
       context.SaveChanges(); 
      } 

      scope.Complete(); 
     } 
    } catch (Exception ex) { 
     // scope.Complete is never called, so the transaction is rolled back 
    } 
} 

Ho provato ad utilizzare ADO.NET regolare invece di EF per la registrazione, ma ancora gli stessi risultati - si ottiene il rollback troppo.

Ho bisogno che la gestione degli errori si verifichi all'interno di SaveChanges, perché quello che sto registrando è lo stato delle entità che vengono salvate - quindi non posso semplicemente spostare facilmente la registrazione da qualche altra parte. Potrei costruire il messaggio all'interno dello SaveChanges catch, e lanciarlo e lasciare che sia DoSomething catch loggarlo, ma ci sono dozzine di metodi DoSomething, e preferirei semplicemente occuparmene in un posto.

Answer 1

Se si avvolge la chiamata di registro all'interno di un altro ambito di transazione con l'opzione di eliminazione attivata, l'ambito della transazione non verrà utilizzato.

public override int SaveChanges() { 
try { 
    return base.SaveChanges(); 
} catch (Exception ex) { 

    string message = /*stuff to log from the context*/; 
    using (var scope = new TransactionScope(TransactionScopeOption.Suppress)) 
    { 
     LogRepo.Log(msg); 

    } 

    throw; 
} 

}

Answer 2

Solo il mio pensiero iniziale, ma è necessario mettere il LogRepo sul proprio DataContext (DC2) in modo che il TransactionScope circostante (con DC1) non lo arrotoli indietro quando non è impegnato.

Fondamentalmente, è necessario rendere la registrazione autosufficiente e atomica.

EDIT Nel guardarlo ancora un po ', mi sembra che se hai spostato il tuo logout da SaveChanges nel catch() su DoSomething(), la registrazione funzionerebbe. Ma il tuo logging deve ancora essere autonomo e atomico.

Answer 3

Ho trovato una soluzione di cui non sono veramente soddisfatto, ma sembra funzionare. Apparentemente TransactionScope influisce solo sul thread corrente, quindi la registrazione usando un nuovo thread sembra funzionare correttamente.

public override int SaveChanges() { 
    try { 
     return base.SaveChanges(); 
    } catch (Exception ex) { 

     string message = /*stuff to log from the context*/; 
     new Thread(msg => {  

      LogRepo.Log(msg); 

     }).Start(message); 

     throw; 
    } 
}