Tag Archives: inheritence

C#: Interface

What is an interface?

Interface is a similar to a class it can contain properties, methods, events and indexers. Each member in an interface must have the public access modifier, and other access modifiers will not work with an interface. Interface do not contain any implementations, the only way to use an interface is by creating a subclass that implements the interface members.

public interface IDisplayMessage {
   public void Show();
}

How do you use an interface?

To use an interface you must create a subclass that inherits the interface and implement it’s members. For example below I have created a subclass called MyClass the implements the IDisplayMessage interface and it’s members. Inside the Show() method I write my own piece of code to output a text message to the console:

public class MyClass : IDisplayMessage {
   private string message;
   public MyClass() {
      message = "Hello, World!";
   }
   public void Show() {
      Console.WriteLine(message);
   }
}
void Main() {
   MyClass myClass = new MyClass();
   myClass.Show();
}

You can implicitly cast an object to any interface that it implements. For example below I am casting myClass to IDisplayMessage and still will be able to call the Show() method.

   IDisplayMessage displayMessage = new MyClass();
   displayMessage.Show();

Summary

Interface is similar to a class, it contains public properties and methods with no implementation. Subclass my using an interface must implement all the members and object can be implicitly cast to an interface that it implements.

 

 

C#: Abstract Class

If you are like me and you don’t like to repeat code in your project, I am going to talk about reusing code by creating an abstract class using c#.

What is an abstract class?

Abstract class is a class that must be declared with the keyword abstract and it can not be instantiated and must be inherited by another class. The abstract class can have abstract methods, abstract properties and virtual methods.

public abstract class MyAbstractClass {
   public abstract string MyProperty { get; set; }
   public abstract void MyAbstractMethod();
   public void MyMethod() {
     Console.WriteLine("Hello World!");
   }
   public virtual void MyVirtualMethod() {
     Console.WriteLine("This method can be overridden.");
   }
}

Why do we use abstract class?

We can use abstract class to implement a common method which will contain reusable code, which then the class can be inherited. For example you I can create a simple abstract class with a method that implements code to print a message  to a console and protected variable to hold a string message:

public abstract class DisplayMessage {
   protected string message;
   public void Show() {
     Console.WriteLine(message);
   } 
}

Now I will create a two classes that inherits my abstract class and define a two different text message inside their constructors:

public class MyClass1 : DisplayMessage {
   public MyClass1() {
     message = "This is my class 1";
   }
}

public class MyClass2 : DisplayMessage {
   public MyClass2() {
     message = "This is my class 2";
   }

Now in the main method I am going to instantiate the two classes and call the Show() method to display each of the message on the console.

void Main() {
   MyClass1 myClass1 = new MyClass1();
   myClass1.Show();

   MyClass2 myClass2 = new MyClass2();
   myClass2.Show();
}

What is a Virtual Method?

A virtual method can contain implementation and must be declared with the keyword virtual. You can override a virtual method from the inherited class to implement code that is completely different from the one in the abstract class. To demonstrate this I will use the DisplayMessage abstract class and modify the Show() to a virtual method:

public abstract class DisplayMessage {
   protected string message;
   public virtual void Show() {
     Console.WriteLine(message);
   } 
}

Now I will create two classes that inherits the DisplayMessage class, but one of the class will override the Show() method to display the text message four times:

public class MyClass1 : DisplayMessage {
   public MyClass1() {
     message = "This is my class 1";
   }
}

public class MyClass2 : DisplayMessage {
   public MyClass2() {
     message = "This is my class 2";
   }
   public override void Show() {
      for(int idx = 0; idx < 5; idx++)
      {
         Console.WriteLine(message);
      }
   }
}

Summary

Abstract class are very useful for implementing reusable code that uses a common method that will be inherited by other classes. Abstract methods and properties has no implementations but can be overridden by the inherited class. Virtual methods can have implementation and can be overridden by the inherited class. 

Remember not duplicate code in your project, reuse code by implementing appropriate design patterns.