Qu'est-ce que l'Exception interne

Vous pouvez voir le code ci-dessous.

Première étape, je lis "abc" en entier. Il va augmenter FormatException.

Dans le bloc catch, j'essaie d'ouvrir un fichier texte pour le journal de message d'exception. Mais ce fichier n'existe pas. FileNotFoundException sera augmenter.

Je veux savoir ce que soulever l'exception de deuxième, j'ajoute donc la première exception (ou FormatException) au constructeur de la deuxième exception.

Maintenant la première exception est InnerException de la deuxième exception.

Dans le bloc catch, je peux accéder à InnerException propriétés de savoir quelle est la première exception.

C'est utile?

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;
        }        
    }
}

OriginalL'auteur Thinh Vu

Objets d'Exception sont en lecture seule par le temps, vous arrivez à un catch bloc, parfois, votre code ne peut rien faire pour gérer l'exception, mais il peut ajouter de l'information par la création d'une nouvelle exception et d'emballage à l'origine de la levée d'une exception à l'intérieur d'elle. De ce fait, il de sorte que vous pouvez ajouter des informations, mais ne pas être nécessaire de copier champ par champ, chaque élément d'information de l'exception d'origine (qui peut même ne pas être possible si vous ne connaissez pas le type d'exception sera levée).

Ici est légèrement modifié extrait à partir d'un projet de mine qui utilise un peu de tout ce qui concerne les Exceptions.

    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; }
}
}

OriginalL'auteur Scott Chamberlain