.net - net - ¿Qué es la excepción interna?

duvaltaxcollect.net tag renewal

Question

He leído el MSDN pero no pude entender este concepto.

Corrígeme si estoy equivocado,

Se utilizará una excepción a la excepción actual.

La excepción interna se producirá primero y luego se producirá la excepción actual (si hay una excepción), es la razón por la que InnerException se comprueba con un null . Para conservar la excepción interna tenemos que pasarla como parámetro.

Estoy en lo cierto con esto?

Answer 1

Los objetos de excepción se leen solo cuando llega a un bloque catch , a veces su código no puede hacer nada para manejar la excepción, pero puede agregar más información creando una nueva excepción y envolviendo la excepción original lanzada dentro de él. Esto lo hace para que pueda agregar información, pero no se le puede solicitar que copie campo por campo toda la información de la excepción original (lo que puede que ni siquiera sea posible si no conoce el tipo de excepción que se lanzará).

Aquí hay un fragmento ligeramente modificado de un proyecto mío que usa un poco de todo lo relacionado con Excepciones.

    private void SomeFunction(string username, string password)
    {
        try
        {
            try
            {
                _someObject.DoSpecialPrivilegedFunction(username, password);
            }
            catch (UnauthorizedAccessException ex)
            {
                throw new UserUnauthorizedException(username, "DoSpecialPrivilegedFunction", ex);
            }
            catch (IOException ex)
            {
                throw new UserModuleActionException("A network IO error happend.", username, "DoSpecialPrivilegedFunction", ex);
            }

            //Other modules

        }
        catch (Exception ex)
        {
            //If it is one of our custom expections, just re-throw the exception.
            if (ex is UserActionException)
                throw;
            else
                throw new UserActionException("A unknown error due to a user action happened.", username, ex);
        }
    }

//elsewhere
[Serializable]
public class UserUnauthorizedException : UserModuleActionException
{
    private const string DefaultMessage = "The user attempted to use a non authorized module";

    public UserUnauthorizedException()
        : base(DefaultMessage)
    {
    }

    public UserUnauthorizedException(string message) 
        : base(message)
    {
    }

    public UserUnauthorizedException(string message, Exception innerException) 
        : base(message, innerException)
    {
    }

    public UserUnauthorizedException(string username, string module, Exception innerException = null) : base(DefaultMessage, username, module, innerException)
    {
    }

    protected UserUnauthorizedException(SerializationInfo info, StreamingContext context) 
        : base(info, context)
    {
    }
}

[Serializable]
public class UserModuleActionException : UserActionException
{
    private readonly string _module;

    public UserModuleActionException()
    {
    }

    public UserModuleActionException(string message) : base(message)
    {
    }

    public UserModuleActionException(string message, Exception innerException) : base(message, innerException)
    {
    }

    public UserModuleActionException(string message, string username, string module, Exception innerException = null)
        : base(message, username, innerException)
    {
        _module = module;
    }

    protected UserModuleActionException(SerializationInfo info, StreamingContext context) 
        : base(info, context)
    {
    }

    public virtual string Module
    {
        get { return _module; }
    }

    public override string Message
    {
        get
        {
            string s = base.Message;
            if (!String.IsNullOrEmpty(_module))
            {
                return s + Environment.NewLine + String.Format("Module: {0}", _module);
            }
            return base.Message;
        }
    }
}

[Serializable]
public class UserActionException : Exception
{
    private readonly string _username;

    public UserActionException()
    {
    }

    public UserActionException(string message)
        : base(message)
    {
    }

    public UserActionException(string message, Exception innerException)
        : base(message, innerException)
    {
    }

    public UserActionException(string message, string username, Exception innerException = null)
        : base(message, innerException)
    {
        _username = username;
    }

    protected UserActionException(SerializationInfo info, StreamingContext context) 
        : base(info, context)
    {
    }

    public override string Message
    {
        get
        {
            string s = base.Message;
            if (!String.IsNullOrEmpty(_username))
            {
                return s + Environment.NewLine + String.Format("Username: {0}", _username);
            }
            return base.Message;
        }
    }

    public virtual string Username
    {
        get { return _username; }
    }
}

Answer 2

Puedes ver el código de abajo.

Primer paso, analizo "abc" a entero. Se planteará FormatException.

En el bloque catch, trato de abrir el archivo de texto para registrar el mensaje de excepción. Pero este archivo no existía. FileNotFoundException será levantado.

Quiero saber qué provoca la segunda excepción, así que agrego la primera excepción (o FormatException) al constructor de la segunda excepción.

Ahora la primera excepción es InnerException de la segunda excepción.

En el bloque catch, puedo acceder a las propiedades de InnerException para saber cuál es la primera excepción.

¿Es útil?

using System;
using System.IO;
public class Program
{
    public static void Main( )
    {
        try
        {
            try
            {
                var num = int.Parse("abc");                
            }
            catch ( Exception inner )
            {
                try
                {
                    var openLog = File.Open("DoesNotExist", FileMode.Open);
                }
                catch
                {
                    throw new FileNotFoundException("OutterException", inner);
                }                              
            }
        }
        catch ( Exception e)
        {
            string inMes, outMes;
            if (e.InnerException != null)
                inMes = e.InnerException.Message;
            outMes = e.Message;
        }        
    }
}

Answer 3

Una excepción interna es la excepción que causó la excepción actual.

Se utiliza en los casos en los que desea que aparezca una excepción diferente a la que detectó su código, pero no desea deshacerse del contexto original.

Para que una nueva excepción tenga información sobre una anterior, como usted dijo, la pasa como parámetro de constructor a la nueva.

Por lo general , una excepción interna nula significa que la excepción actual es la causa raíz de la situación excepcional.