Exceptions

Exception hierarchy, throwing conventions, C# to C++ mapping, and handling patterns.

System::Exception — The Base

include/System/Exception.hpp | src/System/Exception.cpp

System::Exception inherits from std::exception, giving it full integration with standard C++ exception handling:

class Exception : public std::exception {
public:
    Exception();
    explicit Exception(const char* msg);
    explicit Exception(const std::string& msg);
    virtual const std::string& getMessageProperty() const;
    const char* what() const noexcept override;
private:
    std::string message_;
};

Note: System::Exception does not inherit from System::Object. This keeps it compatible with std::exception and standard C++ exception mechanisms.

Exception Hierarchy

std::exception
└── System::Exception
      ├── System::SystemException
      │     ├── ArgumentException
      │     │     ├── ArgumentNullException
      │     │     └── ArgumentOutOfRangeException
      │     ├── ArithmeticException
      │     │     ├── DivideByZeroException
      │     │     └── OverflowException
      │     ├── FormatException
      │     ├── IndexOutOfRangeException
      │     ├── InvalidCastException
      │     ├── InvalidOperationException
      │     ├── NotImplementedException
      │     ├── NotSupportedException
      │     ├── NullReferenceException
      │     ├── ObjectDisposedException
      │     ├── OperationCanceledException
      │     ├── OutOfMemoryException
      │     ├── TimeoutException
      │     ├── UnauthorizedAccessException
      │     ├── IO::IOException
      │     │     ├── IO::DirectoryNotFoundException
      │     │     ├── IO::EndOfStreamException
      │     │     ├── IO::FileNotFoundException
      │     │     ├── IO::InvalidDataException
      │     │     └── IO::IsolatedStorage::IsolatedStorageException
      │     └── ... (many more)
      └── System::ApplicationException

Complete Exception List

Throwing Conventions

// Throw by value (standard C++ practice)
throw System::ArgumentNullException("Parameter 'name' cannot be null.");
throw System::ArgumentOutOfRangeException("index", "Index out of range.");
throw System::NotImplementedException("This method is not yet implemented.");
throw System::PlatformNotSupportedException("Not supported on this platform.");

Catching Conventions

try {
    // ...
}
catch (const System::ArgumentNullException& e) {
    // specific catch
    std::cerr << e.getMessageProperty() << "\n";
}
catch (const System::Exception& e) {
    // catch any sharp-runtime exception
    std::cerr << e.what() << "\n";
}
catch (const std::exception& e) {
    // catch std or sharp-runtime exceptions
    std::cerr << e.what() << "\n";
}

Stub Exceptions

Several exception types exist purely for API compatibility but are rarely thrown. They have headers but minimal or empty .cpp bodies:

• AccessViolationException
• AppDomainUnloadedException
• BadImageFormatException
• ExecutionEngineException
• StackOverflowException

Known Limitations vs .NET

• No inner exception (InnerException property) — not visible in the current implementation
• No stack trace capture — StackTrace property is a stub
• No unhandled exception event with real thread-pool integration
• OutOfMemoryException is not automatically thrown on allocation failure (C++ std::bad_alloc would be thrown instead)