Abstraction and Interface in C#

Abstraction

using System;
namespace OOPs
{
     /// <summary>
     /// Summary description for Abstract1.
     /// </summary>
     /// Abstract class
     abstract class Abstract1
     {
          public Abstract1()
          {
               // TODO: Add constructor logic here
          }
           //non-abstract method
           public void nonabmethod()
     {
          System.Console.WriteLine("Non Abstract Method!");
     }
          //abstract method
          public abstract void abmethod(); //they are implicitly virtual it is not contain the body of the method
          public static void Main()
          {
               myclass mycls = new myclass();
               mycls.nonabmethod();
               mycls.abmethod();
          }
     }
          class myclass : Abstract1 //class derived from abstract class
          {
               public override void abmethod() //must implement the abstract method derived in class
          {
               System.Console.WriteLine("Abstract Method!");
          }
     }

}

using System;
namespace OOPs
{
     /// <summary>
     /// Summary description for Abstract2. Partial implementation of abstract class
     /// </summary>
     abstract class Abstract2
     {
          public static void Main()
          {
               myclass2 mycl = new myclass2();
               mycl.method1();
               mycl.method2();
          }
          public Abstract2()
          {
               // TODO: Add constructor logic here
          }
           public abstract void method1();
           public abstract void method2();
          }
           abstract class myclass1 : Abstract2
          {
               public override void method1()
               {
                    Console.WriteLine("Abstract Method #1");
               }
          }
           class myclass2 : myclass1
          {
           public override void method2()
          {
               Console.WriteLine("Abstract Method #2");
          }
     }
}

using System;
namespace OOPs
{
     /// <summary>
     /// Summary description for Abstract3.
     /// </summary>
     /// abstract class derived from non abstract class
     public class Abstract3
     {
          public static void Main()
     {
          mainclass mcl = new mainclass();
          mcl.noabsmethod();
          mcl.absmethod();
     }
      public Abstract3()
     {
          // TODO: Add constructor logic here
     }
      public void noabsmethod()
     {
          Console.WriteLine("Non-Abs class method");
     }
}
abstract class absclass : Abstract3
{
     public abstract void absmethod();
}
class mainclass : absclass
{
     public override void absmethod()
{
     Console.WriteLine("Abstract method call");
}
}
}

using System;
namespace OOPs
{
     /// <summary>
     /// Summary description for Abstract4.
     /// </summary>
     /// abstract class dervied from interface
     public abstract class Abstract4 : myowninterface
     {
          public static void Main()
     {
          myclasses mc = new myclasses();
          mc.IMethod();
     }
          public Abstract4()
          {
               // TODO: Add constructor logic here
          }
           public void IMethod()
          {
               Console.WriteLine("Method implementation from interface");
          }
}
interface myowninterface
{
     void IMethod();
}
class myclasses : Abstract4
{
}
}

using System;
namespace OOPs
{
     /// <summary>
     /// Summary description for Abstract5.
     /// </summary>
     public abstract class Abstract5
     {
          public static void Main()
          {
               Abstract5 abs = new baseclass(); // Polymorphism
               abs.method();
               abs.method1();
          }
      public Abstract5()
     {
          // TODO: Add constructor logic here
     }
         public abstract void method();
         public abstract void method1();
}
class baseclass : Abstract5
{
     public override void method()
{
     Console.WriteLine("Abstract Method1 of baseclass");
}
     public override void method1()
{
     Console.WriteLine("Abstract Method2 of baseclass");
}
}
}

Interface

using System;
namespace OOPs
{
     /// <summary>
     /// Summary description for Interface1.
     /// </summary>
     public class Interface1 : myinterface
     {
          public static void Main()
     {
          Interface1 inf1 = new Interface1();
          inf1.callmethod();
     }
      public Interface1()
     {
          // TODO: Add constructor logic here
     }
      public void callmethod()
     {
          Console.WriteLine("callmethod implemented!");
     }

}
interface myinterface
{
void callmethod();
}
}

using System;
namespace OOPs
{
/// <summary>
/// Combining Interfaces
/// </summary>
public class Interface2 : combineinterface
{
     public static void Main()
{
     Interface2 inf2 = new Interface2();
     inf2.show();
     inf2.display();
}
public Interface2()
{
     // TODO: Add constructor logic here
}
public void show()
{
     Console.WriteLine("Show Method Call!");
}
     public void display()
{
     Console.WriteLine("Dislay Method Call!");
}
}
interface myinterface1
{
void show();
}
interface myinterface2
{
void display();
}
interface combineinterface : myinterface1, myinterface2
{
}
}

using System;
namespace OOPs
{
     public class Interface3 : interdemo
     {
          public static void Main()
          {
               Interface3 inf3 = new Interface3();
               inf3.show();
               if (inf3 is interdemol)
               {
                    interdemol id = (interdemol)inf3;
                    bool ok = id.display();
                    Console.WriteLine("Method implmented");
               }
               else
               {
                    Console.WriteLine("Method not implmented");
               }
          }
           public Interface3()
          {
               // TODO: Add constructor logic here
          }
           public bool show()
          {
               Console.WriteLine("Show method call");
               return true;
          }
     }
interface interdemo
{
     bool show();
}
interface interdemol
{
     bool display();
}
}

using System;
namespace OOPs
{
     public class Interface4 : inf1, inf2
{
     public static void Main()
{
     Interface4 infobj = new Interface4();
}
     public Interface4()
{
     // TODO: Add constructor logic here
}
void inf1.show12()
{
     Console.WriteLine("call show method1!");
}
void inf2.show12()
{
     Console.WriteLine("call show method2!");
}
}
interface inf1
{
     void show12();
}
interface inf2
{
     void show12();
}
interface inf : inf1, inf2
{
}
}