c# - try - Pedir un método genérico para lanzar el tipo de excepción específica en FAIL

tipos de excepciones programacion

Question

Bien, sé que voy a parecer un idiota con esta, pero mi cerebro no está empezando a funcionar esta mañana.

Quiero tener un método donde pueda decir "si sale mal, regrese con este tipo de Excepción", ¿verdad?

Por ejemplo, algo así como ( y esto no funciona ):

    static ExType TestException<ExType>(string message) where ExType:Exception
    {
        Exception ex1 = new Exception();
        ExType ex = new Exception(message);
        return ex;
    }

Ahora lo que me confunde es que SABEMOS que el tipo genérico va a ser de tipo Excepción debido a la cláusula where . Sin embargo, el código falla porque no podemos convertir implícitamente Exception a ExType . Tampoco podemos convertirlo explícitamente, como por ejemplo:

    static ExType TestException<ExType>(string message) where ExType:Exception
    {
        Exception ex1 = new Exception();
        ExType ex = (ExType)(new Exception(message));
        return ex;
    }

Como eso también falla ... Entonces, ¿ es posible este tipo de cosas? Tengo una fuerte sensación de que va a ser muy simple, pero estoy teniendo un día difícil con el viejo noggin, así que déjame un poco de holgura: P

Actualizar

Gracias por las respuestas chicos, parece que no fui yo un completo idiota! ;)

OK, así que Vegard y Sam me llevaron al punto donde pude crear una instancia del tipo correcto, pero obviamente me quedé atrapado porque el param del mensaje es de solo lectura luego de la instanciación.

Matt golpeó el clavo justo en la cabeza con su respuesta, lo he probado y todo funciona bien. Aquí está el código de ejemplo:

    static ExType TestException<ExType>(string message) where ExType:Exception, new ()
    {
        ExType ex = (ExType)Activator.CreateInstance(typeof(ExType), message);
        return ex;
    }

¡Dulce! :)

¡Gracias chicos!

Answer 1

¿Lo has intentado, en cambio?

static T TestException<Exception>(string message)
{}

porque tengo la sensación de que no es necesario aplicar la restricción genérica, ya que todas las excepciones arrojables deben heredar de System.Exception de todos modos.

Recuerde que los genéricos aceptan tipos heredados.

Answer 2

Casi puedes hacerlo así:

static void TestException<E>(string message) where E : Exception, new()
{
    var e = new E();
    e.Message = message;
    throw e;
}

Sin embargo, eso no se compila porque Exception.Message es de solo lectura. Solo se puede asignar pasándolo al constructor, y no hay forma de restringir un tipo genérico con algo que no sea un constructor predeterminado.

Creo que tendrías que usar la reflexión (Activator.CreateInstance) para "actualizar" el tipo de excepción personalizado con el parámetro del mensaje, como este:

static void TestException<E>(string message) where E : Exception
{
    throw Activator.CreateInstance(typeof(E), message) as E;
}

Editar Vaya, solo se dio cuenta de que desea devolver la excepción, no tirarla. Se aplica el mismo principio, así que dejaré mi respuesta tal como está con las declaraciones de tiro.

Answer 3

Creo que viendo que todas las excepciones deben tener un constructor sin parámetros, y tener la propiedad de Message , entonces lo siguiente debería funcionar:

static ExType TestException<ExType>(string message) where ExType:Exception
{
    ExType ex = new ExType();
    ex.Message = message;
    return ex;
}

Editar: OK, el mensaje es de solo lectura, por lo que tendrá que esperar que la clase implemente el constructor Excepción (cadena).

static ExType TestException<ExType>(string message) where ExType:Exception
{
    return new ExType(message);
}

Answer 4

El único problema con la solución es que es posible crear una subclase de Excepción que no implemente un constructor con un solo parámetro de cadena, por lo que se podría lanzar MethodMissingException.

static void TestException<E>(string message) where E : Exception, new()
{
    try 
    {
      return Activator.CreateInstance(typeof(E), message) as E;
    } 
    catch(MissingMethodException ex) 
    {
      return new E();
    }
}

Answer 5

He estado instanciando en línea el tipo de excepción que deseo lanzar, así:

if (ItemNameIsValid(ItemName, out errorMessage))
    throw new KeyNotFoundException("Invalid name ''" + ItemName + "'': " + errorMessage);
if (null == MyArgument)
    throw new ArgumentNullException("MyArgument is null");