C# Gibt es eine Übersicht über Ausnahmen?

Question

Ich habe mich gefragt, ob es eine Liste mit allen Ausnahmetypen gibt. Ich kenne ein paar Exceptions, aber nicht alle. Manchmal werfe ich eine Exception und dann denke ich, vielleicht hat .NET bereits eine Exception für diese.

Ich brauche zum Beispiel eine Exception, die besagt, dass ein Prozess nicht existiert (wie eine Datei).

Meine Frage lautet also: Weiß jemand, wo man eine Liste aller Ausnahmen finden kann? Ich habe sie nicht gefunden.

Answer 1

Zunächst einmal müssen Sie verstehen, was Ausnahmen sind und wie man damit umgeht. Es gibt einige Ressourcen, die Ihnen helfen können, dieses Thema zu verstehen.

1. "Die Wahl des richtigen Ausnahmetyps" von Krzysztof Cwalina. http://blogs.msdn.com/kcwalina/archive/2006/07/05/657268.aspx

2. "Wie man Ausnahmehierarchien entwirft" von Krzysztof Cwalina. http://blogs.msdn.com/kcwalina/archive/2007/01/30/ExceptionHierarchies.aspx

3. Der Ausnahmemodus von Chris Brumme. http://blogs.msdn.com/cbrumme/archive/2003/10/01/51524.aspx

Kann hilfreich sein:

1. "Warum catch(Exception)/empty catch schlecht ist" von CLR Team Blog. http://blogs.msdn.com/b/dotnet/archive/2009/02/19/why-catch-exception-empty-catch-is-bad.aspx

2. "Schreiben Sie robusten Code zur Behandlung von Ausnahmen" von Bill Wagner. http://visualstudiomagazine.com/articles/2007/06/01/write-robust-exceptionhandling-code.aspx

3. "C#: Brauchen wir eine geprüfte Ausnahme in C#" https://blogs.msdn.com/abhinaba/archive/2005/12/16/504373.aspx

Auch Jeffrey Richter baut in seinem Buch CLR via C# eine Ausnahmehierarchie auf (S.430, Kapitel 19) und hat kürzlich ein Programm geschrieben, das alle Klassen anzeigt, die letztlich von System.Exception :

using System;
using System.Text;
using System.Reflection;
using System.Collections.Generic;
public static class Program
{
    public static void Main()
    {
        // Explicitly load the assemblies that we want to reflect over
        LoadAssemblies();
        // Initialize our counters and our exception type list
        Int32 totalPublicTypes = 0, totalExceptionTypes = 0;
        List<String> exceptionTree = new List<String>();
        // Iterate through all assemblies loaded in this AppDomain
        foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
        {
            // Iterate through all types defined in this assembly
            foreach (Type t in a.GetExportedTypes())
            {
                totalPublicTypes++;
                // Ignore type if not a public class
                if (!t.IsClass || !t.IsPublic) continue;
                // Build a string of the type's derivation hierarchy
                StringBuilder typeHierarchy = new StringBuilder(t.FullName, 5000);
                // Assume that the type is not an Exception-derived type
                Boolean derivedFromException = false;
                // See if System.Exception is a base type of this type
                Type baseType = t.BaseType;
                while ((baseType != null) && !derivedFromException)
                {
                    // Append the base type to the end of the string
                    typeHierarchy.Append("-" + baseType);
                    derivedFromException = (baseType == typeof(System.Exception));
                    baseType = baseType.BaseType;
                }
                // No more bases and not Exception-derived, try next type
                if (!derivedFromException) continue;
                // We found an Exception-derived type
                totalExceptionTypes++;
                // For this Exception-derived type,
                // reverse the order of the types in the hierarchy
                String[] h = typeHierarchy.ToString().Split('-');
                Array.Reverse(h);
                // Build a new string with the hierarchy in order
                // from Exception -> Exception-derived type
                // Add the string to the list of Exception types
                exceptionTree.Add(String.Join("-", h, 1, h.Length - 1));
            }
        }
        // Sort the Exception types together in order of their hierarchy
        exceptionTree.Sort();
        // Display the Exception tree
        foreach (String s in exceptionTree)
        {
            // For this Exception type, split its base types apart
            string[] x = s.Split('-');
            // Indent based on the number of base types
            // and then show the most-derived type
            Console.WriteLine(new String(' ', 3 * x.Length) + x[x.Length - 1]);
        }
        // Show final status of the types considered
        Console.WriteLine("\n---> of {0} types, {1} are " +
        "derived from System.Exception.",
        totalPublicTypes, totalExceptionTypes);
    }
    private static void LoadAssemblies()
    {
        String[] assemblies = {
                "System, PublicKeyToken={0}",
                "System.Data, PublicKeyToken={0}",
                "System.Design, PublicKeyToken={1}",
                "System.DirectoryServices, PublicKeyToken={1}",
                "System.Drawing, PublicKeyToken={1}",
                "System.Drawing.Design, PublicKeyToken={1}",
                "System.Management, PublicKeyToken={1}",
                "System.Messaging, PublicKeyToken={1}",
                "System.Runtime.Remoting, PublicKeyToken={0}",
                "System.Security, PublicKeyToken={1}",
                "System.ServiceProcess, PublicKeyToken={1}",
                "System.Web, PublicKeyToken={1}",
                "System.Web.RegularExpressions, PublicKeyToken={1}",
                "System.Web.Services, PublicKeyToken={1}",
                "System.Windows.Forms, PublicKeyToken={0}",
                "System.Xml, PublicKeyToken={0}",
                };
        String EcmaPublicKeyToken = "b77a5c561934e089";
        String MSPublicKeyToken = "b03f5f7f11d50a3a";
        // Get the version of the assembly containing System.Object
        // We'll assume the same version for all the other assemblies
        Version version =
        typeof(System.Object).Assembly.GetName().Version;
        // Explicitly load the assemblies that we want to reflect over
        foreach (String a in assemblies)
        {
            String Assemblyldentity =
            String.Format(a, EcmaPublicKeyToken, MSPublicKeyToken) +
            ", Culture=neutral, Version=" + version;
            Assembly.Load(AssemblyIdentity);
        }
    }
}

Answer 2

Es gibt eine Hierarchie der Ausnahmen .

Außerdem hat MSDN eine Vererbungshierarchie auf der Seite für die Klasse der Ausnahmen . Aber das ist nur eine lange Liste, die nicht sehr detailliert ist.

Im Allgemeinen scheint .NET nur wenige allgemeine integrierte Ausnahmen zu haben.

Answer 3

ZU IHRER INFORMATION,

Wenn Sie Visual Studio 2008 verwenden, gehen Sie zum Menü Debug/Exceptions und sehen Sie alle Exceptions innerhalb der

• CLR-Ausnahmen
• C++ Ausnahmen
• Managed-Debugging-Unterstützung
• und auch Native RunTime Checks.

Mit diesen Einstellungen können Sie festlegen, was zu tun ist, wenn eine der folgenden Ausnahmen eintritt

Sehen Sie sich das an http://explodingcoder.com/cms/content/visual-studio-fail-how-not-debug-net-exception-handling

Answer 4

Eine gute Möglichkeit, alles zu sehen Typen, die sich von System.Exception ableiten im .NET-Framework ist durch die Verwendung von Reflektor .

1. Geben Sie F3 ein, um nach 'System.Exception' zu suchen.
2. Wählen Sie den Typ 'System.Exception'.
3. Erweitern Sie die ' Abgeleitete Typen ' Baumknoten.

Beachten Sie, dass Reflector das Hinzufügen beliebiger .NET-Assemblies erlaubt, d.h. es wird nach abgeleiteten System.Exception-Typen in jedem von Ihnen bereitgestellten Satz von Assemblies gesucht. Die gängigsten .NET-Framework-Assemblies werden standardmäßig hinzugefügt.

Answer 5

Die Dokumentation von Visual Studio Code Analysis (d.h. FxCop) enthält einige allgemeine Hinweise zum Auslösen von vorhandenen Ausnahmen.

Keine reservierten Ausnahmetypen auslösen