C# Possible to have a generic return type?

Question

Here is a typical function that returns either true/false;

private static bool hasValue()
{
    return true; 
}

Now on an error, I would like to return my own custom error object with definition:

public class Failure
{
    public string FailureDateTime { get; set; }
    public string FailureReason { get; set; }
}

I would have expected to be able to throw this custom object for example...

private static bool hasValue() 
{
    try 
    {
        // do something
    }
    catch 
    {
        throw new Failure();
    }
    
    return true;
}

This is not possible, and I don't want to derive Failure from System.IO.Exception because I have personally had issues serializing exceptions in C# (This was with .net v2).

What is the best practice / or ideal solution to this problem. Should I just work with private static object? Or is there a cleaner way to return a custom object or bypass the typical return type on an error (not using System.IO.Exception)?

I am not entirely wild about using an object either, because then I need to validate the result by using casting and more boolean.

Answer 1

This kind of solution may fit to this case:

var exception = new Exception();
exception.Data.Add("Failure", new Failure());
throw exception;

You can throw the exception (recommended to define your own exception type), and use the Data dictionary to hold the Failure. In the catch code you can take the data and serialize it. If you do create your own exception type you can place the Failure on a property.

Comment: I didn't check it, but are you sure exceptions are not serializable?

Answer 2

I don't want to derive Failure from System.IO.Exception because of the inability to serialize an exception in C#.

The assumption that this question is based on is that you cannot serialize exceptions derived from IOException. However I wish to challenge this assumption. IOException is marked as Serializable. All you have to do is mark your subclass as serializable too.

See the documentation for IOException:

[SerializableAttribute]
[ComVisibleAttribute(true)]
public class IOException : SystemException

Answer 3

You need to derive from System.Exception (or any other non-sealed subclass of it) if you want to create your own exception class. Failure to serialize that you are talking about is likely the fact that you didn't implement the serialization constructor.

Visual Studio has a code snippet that creates a recommended template for subclassing exception. You can get it by typing exception and pressing tab twice.

This is what comes out:

[Serializable]
public class MyException : Exception {
    public MyException() { }
    public MyException(string message) : base(message) { }
    public MyException(string message, Exception inner) : base(message, inner) { }
    protected MyException(
      System.Runtime.Serialization.SerializationInfo info,
      System.Runtime.Serialization.StreamingContext context)
        : base(info, context) { }
}