In C#, how to determine if a class or an instance of the class implements an interface

I needed to determine if a class or one of its instances implements and interface. So I created this test project to see if this works.

Turns out it is really easy to do. Here is a test project that I used to learn. Just create a new console project and stick this code in the Program.cs and check it out.

namespace TestIfThisImplementsInterface
{
    class Program
    {
        static void Main(string[] args)
        {
            // Test if the type or its parent implements the interface
            bool bCarClass = typeof(IDrivable).IsAssignableFrom(typeof(Car));             // True
            bool bFordFocusClass = typeof(IDrivable).IsAssignableFrom(typeof(FordFocus)); // True
            bool bJunkerClass = typeof(IDrivable).IsAssignableFrom(typeof(Junker));       // False

            // Test if the exact type and not its parent implements the derived type
            bool bCarClassEx = typeof(Car).GetInterface(typeof(IDrivable).FullName) != null;           // True
            bool bFordFocusClassEx = typeof(Vehicle).GetInterface(typeof(IDrivable).FullName) != null; // False
            bool bJunkerClassEx = typeof(Junker).GetInterface(typeof(IDrivable).FullName) != null;     // True

            // Test if an instance implements or derivces from an oject that implements the interface
            bool bCarInstance = new Car() is IDrivable;             // True
            bool bFordFocusInstance = new FordFocus() is IDrivable; // True
            bool bJunkerInstance = new Junker() is IDrivable;       // False

            // Test if an instance implements or derivces from an oject that implements the interface
            bool bCarInstanceEx = new Car().GetType().GetInterface(typeof(IDrivable).FullName) != null;             // True
            bool bFordFocusInstanceEx = new FordFocus().GetType().GetInterface(typeof(IDrivable).FullName) != null; // False
            bool bJunkerInstanceEx = new Junker().GetType().GetInterface(typeof(IDrivable).FullName) != null;       // False

            // Show that the test can be in the parent class but the actual class is what is tested
            // This is actually what I needed. Glad it worked!
            bool bCarParentFunction = new Car().IsDrivable;             // True
            bool bFordFocusParentFunction = new FordFocus().IsDrivable; // True
            bool bJunkerParentFunction = new Junker().IsDrivable;       // False
        }
    }

    public interface IDrivable
    {
        void Drive();
    }

    public class Vehicle
    {
        public virtual bool IsDrivable
        {
            get { return this is IDrivable; }
        }
    }

    public class Car : Vehicle, IDrivable
    {
        #region IDrivable Members
        public void Drive()
        {
            // Drive code here
        }
        #endregion
    }

    public class FordFocus : Car
    {
    }

    public class Junker : Vehicle
    {
    }
}

Resource:
http://www.hanselman.com/blog/DoesATypeImplementAnInterface.aspx

Leave a Reply

*