patrón "TryParse/Parse like": cuál es la mejor manera de implementarlo

Question

Esta pregunta es una continuación de How to indicate that a method was unsuccessful. El patrón xxx() Tryxxx() es algo que puede ser muy útil en muchas bibliotecas. Me pregunto cuál es la mejor manera de ofrecer ambas implementaciones sin duplicar mi código.

lo que es mejor:

public int DoSomething(string a) 
{ 
    // might throw an exception 
} 
public bool TrySomething(string a, out result) 
{ 
    try 
    { 
     result = DoSomething(a) 
     return true; 
    } 
    catch (Exception) 
    { 
     return false; 
    } 

o

public int DoSomething(string a) 
{ 
    int result; 
    if (TrySomething(a, out result)) 
    { 
     return result; 
    } 
    else 
    { 
     throw Exception(); // which exception? 
    } 
} 
public bool TrySomething(string a, out result) 
{ 
    //... 
} 

Me instintivamente por hecho que el primer ejemplo es más correcto (usted sabe exactamente lo que sucedió excepción), pero se le fue el intento/¿La captura es demasiado cara? ¿Hay alguna forma de detectar la excepción en el segundo ejemplo?

Answer 1

Haciendo TrySomething acaba de coger y tragar la excepción es una muy mala idea. La mitad del punto del patrón TryXXX es evitar el golpe de rendimiento de las excepciones.

Si no necesita mucha información en la excepción, puede hacer que el método DoSomething solo llame a TrySomething y lanzar una excepción si falla. Si necesita detalles en la excepción, puede necesitar algo más elaborado. No he calculado el momento en que la mayor parte del rendimiento de las excepciones es - si es el lanzamiento en lugar de la creación, puede escribir un método privado que tiene una firma similar a TrySomething, pero que arrojó una excepción o nulo:

public int DoSomething(string input) 
{ 
    int ret; 
    Exception exception = DoSomethingImpl(input, out ret); 
    if (exception != null) 
    { 
     // Note that you'll lose stack trace accuracy here 
     throw exception; 
    } 
    return ret; 
} 

public bool TrySomething(string input, out int ret) 
{ 
    Exception exception = DoSomethingImpl(input, out ret); 
    return exception == null; 
} 

private Exception DoSomethingImpl(string input, out int ret) 
{ 
    ret = 0; 
    if (input != "bad") 
    { 
     ret = 5; 
     return null; 
    } 
    else 
    { 
     return new ArgumentException("Some details"); 
    } 
} 

¡Sin embargo, antes de comprometerse con esto!

Answer 2

El primer ejemplo es correcto si solo va a atrapar la excepción y no hace nada más que devolver falso con ella.

Puede cambiar TrySomething para que se vea como a continuación.

public bool TrySomething(string a, out result, bool throwException) 
{ 
    try 
    { 
    // Whatever 
    } 
    catch 
    { 
    if(throwException) 
    { 
     throw; 
    } 
    else 
    { 
     return false; 
    } 
    } 

} 

public bool TrySomething(string a, out result) 
{ 
    return TrySomething(a, out result, false); 
} 

Así HacerAlgo se vería

public int DoSomething(string a) 
{ 
    int result; 

    // This will throw the execption or 
    // change to false to not, or don't use the overloaded one. 
    TrySomething(a, out result, true) 

    return result;  
} 

Si no desea TrySomething con ThrowException expuesta al público se puede hacer un miembro privado.

Las excepciones pueden ser costosas y usted puede hacer algunas comprobaciones de RegEx en la cadena para evitar que una sea lanzada. Depende de lo que estés tratando de hacer.

Answer 3

Suponiendo que esta es C#, yo diría que el segundo ejemplo

public bool TrySomething(string a, out result) 
{ 
    try 
    { 
     result = DoSomething(a) 
     return true; 
    } 
    catch (Exception) 
    { 
     return false; 
    } 
} 

que imita el construido en int.TryParse(string s, out int result), y en mi opinión, es mejor permanecer consistente con el lenguaje/entorno.

Answer 4

Normalmente uso este patrón. Depende de cómo se implementa el método interno en cuanto a si esto tiene sentido o no. Si usted tiene que utilizar bloques catch condicional que puede ser un poco desagradable ...

public object DoSomething(object input){ 
    return DoSomethingInternal(input, true); 
} 

public bool TryDoSomething(object input, out object result){ 
    result = DoSomethingInternal(input, false); 
    return result != null; 
} 

private object DoSomethingInternal(object input, bool throwOnError){ 
    /* do your work here; only throw if you cannot proceed and throwOnError is true */ 
}