What is the difference between an interface and a class, and why I should use an interface when I can implement the methods directly in the class?

by

Interfaces are excellent when you want to create something like it:

using System;

namespace MyInterfaceExample
{
    public interface IMyLogInterface
    {
        //I want to have a specific method that I'll use in MyLogClass
        void WriteLog();       
    }

    public class MyClass : IMyLogInterface
    {

        public void WriteLog()
        {
            Console.Write("MyClass was Logged");
        }
    }

    public class MyOtherClass : IMyLogInterface
    {

        public void WriteLog()
        {
            Console.Write("MyOtherClass was Logged");
            Console.Write("And I Logged it different, than MyClass");
        }
    }

    public class MyLogClass
    {
        //I created a WriteLog method where I can pass as a parameter any object that implements IMyLogInterface.
        public static void WriteLog(IMyLogInterface myLogObject)
        {
            myLogObject.WriteLog(); //So I can use WriteLog here.
        }
    }

    public class MyMainClass
    {
        public void DoSomething()
        {
            MyClass aClass = new MyClass();
            MyOtherClass otherClass = new MyOtherClass();

            MyLogClass.WriteLog(aClass);//MyClass can log, and have his own implementation
            MyLogClass.WriteLog(otherClass); //As MyOtherClass also have his own implementation on how to log.
        }
    }
}

In my example, I could be a developer who writes MyLogClass, and the other developers, could create their classes, and when they wanted to log, they implement the interface IMyLogInterface. It is as they were asking me what they need to implement to use WriteLog() method in MyLogClass. The answer they will find in the interface.

More Related Contents:

  1. What is abstraction in C#? [duplicate]
  2. Program * does not contain a static ‘Main’ method suitable for an entry point
  3. Static vs non-static class members
  4. How abstraction and encapsulation differ?
  5. When should I choose inheritance over an interface when designing C# class libraries? [closed]
  6. C# : Converting Base Class to Child Class
  7. Why we do create object instance from Interface instead of Class?
  8. Method vs Property in C# – what’s the difference [duplicate]
  9. Why must an C# interface method implemented in a class be public?
  10. Why Doesn’t C# Allow Static Methods to Implement an Interface?
  11. Why does C# not provide the C++ style ‘friend’ keyword? [closed]
  12. What characters are allowed in C# class name?
  13. C#: Class for decoding Quoted-Printable encoding?
  14. Why does calling a method in my derived class call the base class method?
  15. ‘namespace’ but is used like a ‘type’
  16. Main method code entirely inside try/catch: Is it bad practice?
  17. C# – Cannot implicitly convert type List to List
  18. C# inheritance and default constructors
  19. XmlSerializer serialize generic List of interface
  20. Static and Instance methods with the same name?
  21. How can I serialize internal classes using XmlSerializer?
  22. Why are constructors not inherited in C#?
  23. .NET: Unable to cast object to interface it implements
  24. C# using others code
  25. C# static class constructor
  26. downcast and upcast
  27. Is it possible to override a constructor in C#?
  28. Is there a way to reach a `protected` member of another object from a derived type?
  29. Method Overloading with different return type [duplicate]
  30. Why doesn’t generic ICollection implement IReadOnlyCollection in .NET 4.5?

Leave a Comment