Abstraction

using System;
namespace MyNamespace
{
/// <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 MyNamespace
{
/// <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 MyNamespace
{
/// <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 MyNamespace
{
/// <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 MyNamespace
{
/// <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 MyNamespace
{
/// <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 MyNamespace
{
/// <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 MyNamespace
{
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 MyNamespace
{
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
{
}
}

Hi,

Very useful info!!!!!

hi dinesh

good one

thanks for sharing

Thanks for sharing

Great thanks for sharing.