Comment puis-je compacter beaucoup de petits blocs Try-Catch lors de la gestion des exceptions en C#?

Question

Dans mon code de conversion d'objets que j'ai des tonnes de:

try 
    { 
     NativeObject.Property1= int.Parse(TextObject.Property1); 
    } 
    catch (Exception e) 
    { 
     Trace.WriteLineIf(ConverterSwitch.TraceVerbose, e); 
    } 
    try 
    { 
     NativeObject.Property2= DateTime.Parse(TextObject.Property2); 
    } 
    catch (Exception e) 
    { 
     Trace.WriteLineIf(ConverterSwitch.TraceVerbose, e); 
    } 

Et ainsi de suite ... Je ne veux pas toutes les conversions à l'échec cause de certains biens, donc je ne peux pas mettre tout cela dans un seul bloc d'essai, mais j'ai besoin de se connecter si quelque chose échoue et continue ..
Existe-t-il un moyen de compacter tout cela pour essayer d'attraper des choses?

Dommage que nous ne pouvons pas écrire dans le code C# comme:

try 
{ 
    int num = int.Parse("3"); 
    decimal num2 = decimal.Parse("3.4"); 
} 
catch (Exception e) 
{ 
    Trace.Write(e); 
    continue; //continue execution from the point we left. (line 2) 
} 

Answer 1

Non, mais vous pouvez:

private static void ExecuteAndCatchException(Action action) 
{ 
    try 
    { 
    action(); 
    } 
    catch (Exception e) 
    { 
    Trace.Write(e); 
    } 
} 

puis

ExecuteAndCatchException(() => NativeObject.Property1 = int.Parse(TextObject.Property1)); 
ExecuteAndCatchException(() => NativeObject.Property2 = DateTime.Parse(TextObject.Property2)); 

Answer 2

Vous pourriez faire quelque chose comme ça :

private static void Attempt(Action action) 
{ 
    try { action(); } 
    catch (Exception e) { 
     Trace.WriteLineIf(ConverterSwitch.TraceVerbose, e); 
    } 
} 

Puis:

Attempt(() => NativeObject.Property1 = int.Parse(TextObject.Property1)); 
Attempt(() => NativeObject.Property2 = DateTime.Parse(TextObject.Property2)); 

Answer 3

sonner comme vous cherchez quelque chose de semblable VBS On Error + Resume Next. C# n'a pas de telle facilité. Le meilleur moyen de compactage auquel je puisse penser est d'utiliser des expressions lambda et des méthodes auxiliaires.

private void Wrap(Action del) { 
    try { 
    del(); 
    } catch (Exception e) { 
    Trace.WriteLineIf(ConverterSwitch.TraceVerbose, e); 
    } 
} 

Wrap(() => { NativeObject.Property1= int.Parse(TextObject.Property1); }); 
Wrap(() => { NativeObject.Property2= DateTime.Parse(TextObject.Property2); }); 

Answer 4

Vous pouvez utiliser les méthodes TryParse, lorsqu'elles sont disponibles. Voir ci-dessous un exemple de code pour analyser une valeur Int32.

private static void TryToParse(string value) 
    { 
     int number; 
     bool result = Int32.TryParse(value, out number); 
     if (result) 
     { 
     Console.WriteLine("Converted '{0}' to {1}.", value, number);   
     } 
     else 
     { 
     if (value == null) value = ""; 
     Console.WriteLine("Attempted conversion of '{0}' failed.", value); 
     } 
    } 

Answer 5

Vous pouvez écrire une classe SafeConvert qui encapsule la conversion et l'enregistrement en tant que tel:

public static class SafeConvert{ 

    public static int ParseInt(string val) 
    { 
    int retval = default; 
    try 
    { 
     retval = int.Parse(val); 
    } 
    catch (Exception e) 
    { 
     Trace.WriteLineIf(ConverterSwitch.TraceVerbose, e); 
    } 
     return retval; 
} 

}

Answer 6

Alors que je ne suis pas sûr de la réduction du bloc d'exception, j'aime l'idée vous avez proposé. C'est similaire à On Error Resume Next dans VB de l'ancien. Lorsque j'effectue des analyses, j'utilise TryParse quand il est disponible. Vous pouvez alors dire quelque chose comme:

If(!DateTime.TryParse(TextObject.Property2, out NativeObject.Property2)) { 
    // Failed! 
}