Come identificare la duplicazione della chiave primaria da un codice di errore di SQL Server 2008?

Question

Desidero sapere come identifichiamo l'errore di duplicazione della chiave primaria dal codice di errore di SQL Server in C#.

Ad esempio, ho un modulo C# per immettere dati in un database SQL Server, quando si verifica un errore durante l'immissione dei dati, come posso identificare il motivo dell'errore dall'eccezione?

Answer 1

Se si cattura SqlException quindi vedere il suo numero, il numero 2627 significherebbe violazione del vincolo univoco (compresa la chiave primaria).

try 
{ 
    // insertion code 
} 
catch (SqlException ex) 
{ 
    if (ex.Number == 2627) 
    { 
     //Violation of primary key. Handle Exception 
    } 
    else throw; 
} 

MSSQL_ENG002627

Si tratta di un errore generale che può essere sollevato indipendentemente dal fatto che un database viene replicato. Nei database replicati, l'errore è in genere generato perché le chiavi primarie non sono state gestite in modo appropriato nella topologia.

Answer 2

In caso di Entity Framework, la risposta accettata non funzionerà e l'errore finirà per non essere catturato. Ecco un codice di prova, solo la dichiarazione dell'entità cattura sarà colpito o, naturalmente, l'eccezione generica if entità rimosso:

try 
{ 
    db.InsertProcedureCall(id); 
} 
catch (SqlException e0) 
{ 
    // Won't catch 
} 
catch (EntityCommandExecutionException e1) 
{ 
    // Will catch 
    var se = e1.InnerException as SqlException; 
    var code = se.Number; 
} 
catch (Exception e2) 
{ 
    // if the Entity catch is removed, this will work too 
    var se = e2.InnerException as SqlException; 
    var code = se.Number; 
} 

Answer 3

Questo è un vecchio thread, ma credo che vale la pena notare che dal C# 6 si può :

try 
{ 
    await command.ExecuteNonQueryAsync(cancellation); 
} 
catch (SqlException ex) when (ex.Number == 2627) 
{ 
    // Handle unique key violation 
} 

e con C# 7 e un'eccezione involucro (come Entity Framework core):

try 
{ 
    await _context.SaveChangesAsync(cancellation); 
} 
catch (DbUpdateException ex) 
    when ((ex.InnerException as SqlException)?.Number == 2627) 
{ 
    // Handle unique key violation 
} 

il più grande vantaggio di questo approccio rispetto alla risposta accettata è:

Nel caso in cui il numero di errore sia non uguale a 2627 e, quindi, non si tratta di una violazione di chiave univoca, l'eccezione non viene rilevata.

Senza il filtro di eccezione (when) è meglio ricordare di rilanciare quell'eccezione nel caso in cui non sia possibile gestirla. E idealmente non dimenticare di usare ExceptionDispatchInfo in modo che lo stack originale non vada perso.