¿Cómo marcar un método se lanzará incondicionalmente?

Question

¿Hay alguna manera de decorar un método que haga algo de registro, y luego lanzar una excepción incondicionalmente, como tal?

tengo código como este:

void foo(out int x) 
{ 
    if(condition()) { x = bar(); return; } 

    // notice that x is not yet set here, but compiler doesn't complain 

    throw new Exception("missed something."); 
} 

si trato de escribirlo como esto consigo un problema:

void foo(out int x) 
{ 
    if(condition()) { x = bar(); return; } 

    // compiler complains about x not being set yet 

    MyMethodThatAlwaysThrowsAnException("missed something."); 
} 

¿Alguna sugerencia? Gracias.

Answer 1

¿Qué le parece esto?

bool condition() { return false; } 
int bar() { return 999; } 
void foo(out int x) 
{ 
    if (condition()) { x = bar(); return; } 
    // compiler complains about x not being set yet 
    throw MyMethodThatAlwaysThrowsAnException("missed something."); 
} 
Exception MyMethodThatAlwaysThrowsAnException(string message) 
{ 
    //this could also be a throw if you really want 
    // but if you throw here the stack trace will point here 
    return new Exception(message); 
} 

Answer 2

Si sabe que la excepción siempre será arrojada, ¿por qué es importante? Sólo hay que establecer la variable a algo por lo que puede compilar:

void foo(out int x) 
{ 
    if(condition()) { x = bar(); return; } 

    x = 0; 

    MyMethodThatAlwaysThrowsAnException("missed something."); 
} 

Answer 3

No responde a su pregunta, pero al utilizar parámetros cabo siempre es una buena idea para inicializar ellos en el principio del método. De esta manera usted no tiene ningún errores de compilación:

void foo(out int x) 
{ 
    x = 0; 
    if(condition()) { x = bar(); return; } 
    MyMethodThatAlwaysThrowsAnException("missed something."); 
} 

Answer 4

x es un cabo parámetros y se debe establecer antes de seguir adelante

Answer 5

No hay manera de marcar un método de esta manera.

Posiblemente irrelevante, pero el patrón en su ejemplo, usando un parámetro out, es un poco extraño. ¿Por qué no simplemente tener un tipo de devolución en el método?

int Foo() 
{ 
    if (condition()) return bar(); 

    MyMethodThatAlwaysThrowsAnException("missed something."); 
} 

Answer 6

Si no desea tener que establecer x, ¿por qué no utiliza simplemente un parámetro ref?

void foo(ref int x) 
{ 
    if(condition()) { x = bar(); return; } 

    // nobody complains about anything 

    MyMethodThatAlwaysThrowsAnException("missed something."); 
} 

Answer 7

Es un hilo muy antiguo, pero sólo quiero añadir que debe escribirlo diferente desde el principio:

void foo(out int x) 
{ 
    if (!condition()) 
     MyMethodThatAlwaysThrowsAnException("missed something."); 

    x = bar(); 
    // and so on... 
} 

De esa manera compilador no se quejará y su código es mucho más clara.