Как реорганизовать избыточный код catch?

Question

Я пытаюсь определить лучший способ рефакторинга этого кода. Как вы можете видеть, попытка ... поймать .. поймать .. поймать ... строки кода идентичны. Единственное различие между этими двумя методами - это асинхронное, а другое - нет.

public override int SaveChanges() 
{ 
    try 
    { 
     return base.SaveChanges(); 
    } 
    catch (DbEntityValidationException ex) 
    { 
     var entityValidationErrors = ex.EntityValidationErrors 
      .SelectMany(e => e.ValidationErrors) 
      .Select(x => string.Format("{0} - {1}", x.PropertyName, x.ErrorMessage)); 

     var fullErrorMessage = string.Join(Environment.NewLine, entityValidationErrors); 
     var exceptionMessage = string.Concat(ex.Message, " Entity validation errors: ", fullErrorMessage); 

     throw new DbEntityValidationException(exceptionMessage, ex.EntityValidationErrors); 
    } 
    catch (DbUpdateConcurrencyException ex) 
    { 
     Debug.WriteLine(ex.Message); 
     throw; 
    } 
    catch (DbUpdateException ex) 
    {     
     var sqlException = ex.GetBaseException() as SqlException; 

     if (sqlException == null || sqlException.Errors.Count <= 0) 
      throw; 

     var errors = new List<string>(); 

     for (var i = 0; i < sqlException.Errors.Count; i++) 
     { 
      errors.Add(string.Format("{0} - {1}", sqlException.Errors[i].Number, sqlException.Errors[i].Message)); 
     } 

     throw new DbUpdateException(string.Join(Environment.NewLine, errors)); 
    } 
} 
public override async Task<int> SaveChangesAsync() 
{ 
    try 
    { 
     return await base.SaveChangesAsync(); 
    } 
    catch (DbEntityValidationException ex) 
    { 
     var entityValidationErrors = ex.EntityValidationErrors 
      .SelectMany(e => e.ValidationErrors) 
      .Select(x => string.Format("{0} - {1}", x.PropertyName, x.ErrorMessage)); 

     var fullErrorMessage = string.Join(Environment.NewLine, entityValidationErrors); 
     var exceptionMessage = string.Concat(ex.Message, " Entity validation errors: ", fullErrorMessage); 

     throw new DbEntityValidationException(exceptionMessage, ex.EntityValidationErrors); 
    } 
    catch (DbUpdateConcurrencyException ex) 
    { 
     Debug.WriteLine(ex.Message); 
     throw; 
    } 
    catch (DbUpdateException ex) 
    { 
     var sqlException = ex.GetBaseException() as SqlException; 

     if (sqlException == null || sqlException.Errors.Count <= 0) 
      throw; 

     var errors = new List<string>(); 

     for (var i = 0; i < sqlException.Errors.Count; i++) 
     { 
      errors.Add(string.Format("{0} - {1}", sqlException.Errors[i].Number, sqlException.Errors[i].Message)); 
     } 

     throw new DbUpdateException(string.Join(Environment.NewLine, errors)); 
    } 
} 

Answer 1

Один из способов сделать как синхронную и асинхронную методу, чтобы иметь реальную логику в методе синхронизации и методе асинхронного, чтобы обернуть первый в задачу.

public override Task<int> SaveChangesAsync() 
{ 
    return new Task(SaveChanges); 
} 

Answer 2

Я решил решить это с помощью делегата (Func). Вот два метода «duplicate» .SaveChanges.

public override int SaveChanges() 
{ 
    return SaveChangesWrapper<int>(() => base.SaveChanges()); 
} 
public override async Task<int> SaveChangesAsync() 
{ 
    return await SaveChangesWrapper<Task<int>>(async() => await base.SaveChangesAsync()); 
} 

И вот обертка.

private T SaveChangesWrapper<T>(Func<T> function) 
{ 
    try 
    { 
     //do some work up front.... 

     return function(); 
    } 
    catch (DbEntityValidationException ex) 
    { 
     //parse exception and rethrow... 
    } 
    catch (DbUpdateConcurrencyException ex) 
    { 
     //parse and rethrow... 
    } 
    catch (DbUpdateException ex) 
    { 
     //parse and rethrow... 
    } 
    catch (Exception ex) 
    { 
     //parse and rethrow.. 
    } 
}