Question

I created an exception class like this:

public class ServiceException : ApplicationException {

    public Dictionary<string, string> Errors { get; set; }

    public ServiceException(Exception ex) : base("Service Exception", ex) {
      Errors = new Dictionary<string, string>();
    }
    public ServiceException() : this(null) {}

}

The following code fails:

protected void log(Exception ex)
{
    if (ex is ServiceException)
    {
        var y = (ServiceException)
        ModelState.Merge(ex.Errors);
    }
    else
    {
        Trace.Write(ex);
        ModelState.AddModelError("", "Database access error: " + ex.Message);
    }
}

It generates the following error on compile:

Error 5 ‘System.Exception’ does not contain a definition for ‘Errors’
and no extension method ‘Errors’ accepting a first argument of type
‘System.Exception’ could be found (are you missing a using directive
or an assembly reference?)

I fixed it by doing the following:

if (ex is ServiceException)
{
    var y = (ServiceException)ex;
    ModelState.Merge(y.Errors);
}

Is there some way that I can avoid this messy code using a variable y and then casting it ? Without declaring the intermediate variable y the code does not pass a syntax check.

Answer 1

You need to cast because ex is not a ServiceException. The is operator is simply evaluating telling you that it is a ServiceException, but doesn’t perform the cast to the type.

Think about what type ex is. It’s of type Exception, and generally speaking you don’t know what it is. By calling ex is ServiceException, you’re checking if the dynamic type of ex is ServiceException. But the static type is still Exception. That doesn’t change.

C# is a statically typed language, so the static type of ex, which is Exception won’t magically change to ServiceException after you use the is operator. You still need to cast it yourself.

Rather, you may wish to use the as operator:

protected void log(Exception ex)
{
    ServiceException se = ex as ServiceException;
    if (se != null)
        ModelState.Merge(se.Errors);
    else
    {
        Trace.Write(ex);
        ModelState.AddModelError("", "Database access error: " + ex.Message);
    }
}

ex as ServiceException tries to cast ex to a ServiceException. If ex isn’t a ServiceException, the cast fails and it returns null.

Alternatively, if you’re really against using an extra local variable, then you can just cast it and then use it immediately:

if (se is ServiceException)
    ModelState.Merge(((ServiceException) se).Errors);

Honestly though, I don’t see why you’d want this though. Doing the check first (using as or is) followed by using the downcasted exception is the best idea here. It’s cleaner to actually use the extra variable because you’re showing your intent and it’s immediately obvious what you want to achieve.