Why cast to interface is not compile time checked in C# ?

Question

1.00/5 (1 vote)

See more:

Hi,

I just saw a question asked by someone on a different to which no one has porivded a staisfacotry answer, and just out of curiousity i also wanted to know why is it compile time legal, but ofcourse it would fail at run-time, here is the code:

C#

public class DummyClassFactory
    {
        public Object GetDummyClassInstance()
        { 
            var dummyClass = new DummyClass();
			
            switch (DateTime.Now.DayOfWeek)
            {
                // Starting on monday.
                case DayOfWeek.Monday:
                    return (IDisposable)dummyClass;
                
               
                case DayOfWeek.Thursday:
                    return (IServiceProvider)dummyClass;
                case DayOfWeek.Friday:
                    return (IEquatable<List<Single>>)dummyClass;
                case DayOfWeek.Saturday:
                    return (IFormattable)dummyClass;
                
            }
            // return (DummyClassFactory)dummyClass; 
            return dummyClass;
        }
    }

    public class DummyClass { }
    public interface IDummyClass { }

Can someone please shed some light, why is it so?

Here is the demo fiddle : .NET DEMO Fiddle[^]

Thanks,
Ehsan Sajjad

What I have tried:

C#

public class DummyClassFactory
    {
        public Object GetDummyClassInstance()
        { 
            var dummyClass = new DummyClass();
			
            switch (DateTime.Now.DayOfWeek)
            {
                // Starting on monday.
                case DayOfWeek.Monday:
                    return (IDisposable)dummyClass;
                
               
                case DayOfWeek.Thursday:
                    return (IServiceProvider)dummyClass;
                case DayOfWeek.Friday:
                    return (IEquatable<List<Single>>)dummyClass;
                case DayOfWeek.Saturday:
                    return (IFormattable)dummyClass;
                
            }
            // return (DummyClassFactory)dummyClass; 
            return dummyClass;
        }
    }

    public class DummyClass { }
    public interface IDummyClass { }

Posted 25-Sep-17 5:38am

Ehsan Sajjad

Updated 25-Sep-17 6:02am

Add a Solution

Comments

Graeme_Grant 25-Sep-17 22:49pm

This will better explain what you are seeing: Difference between Early Binding and Late binding[^]

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

OriginalGriff · Accepted Answer · 2017-09-25T05:58:00

It's a bit complicated, but I'll try to explain...

Remember that a class can derive from a single base class (concrete or abstract), but can also inherit multiple interfaces. So descendant classes can implement interfaces that the original base class did not.

C#

class MyBase{}
class MyDerived : MyBase {}
class MyOtherDerived : MyDerived, IInterface1, IInterface2 {}

Since a variable of type MyBase could contain any type of object based on MyBase, it could conceivably contain a MyOtherDerived class instance - which supports two interfaces, so it can be cast to either (with the appropriate runtime checks to make sure it works).
That's all simple enough, and you could say "No derived class implements IDontKnowWhatToCallIt, so you shouldn't be able to cast to it and you should get a compiler error".

But ... the system doesn't know that. It's entirely possible that a different assembly altogether does create a class derived from MyBase and that does implement the IDontKnowWhatToCallIt Interface - so it can't create a compile time error without seriously mucking up your code!

If your base class is sealed it can check - and it does, and will raise a compiler error. But for derivable classes, it has to err on the "safe" side and let the cast through and rely on the run time checks to throw an exception.

Wendelius · Accepted Answer · 2017-09-25T06:02:00

Solution 2

As far as I understand the situation, your class can be extended to support the mentioned interfaces in the code for example by inheritance. So the compiler is not sure if the cast would always fail.

Things change dramatically if you seal the class:

C#

public sealed class DummyClass { }

Posted 25-Sep-17 6:02am

Wendelius