Abstract methods

When an instance method declaration includes an abstract modifier, that method is said to be an abstract method. Although an abstract method is implicitly also a virtual method, it cannot have the modifier virtual.

An abstract method declaration introduces a new virtual method but does not provide an implementation of that method. Instead, non-abstract derived classes are required to provide their own implementation by overriding that method. Because an abstract method provides no actual implementation, the method-body of an abstract method simply consists of a semicolon.

Abstract method declarations are only permitted in abstract classes

public abstract class AbstractClass

{

public abstract void PrintName();

}

Implementation

public sealed class AbstractImp1:AbstractClass

{

public override void PrintName()

       {

           Console.WriteLine("Im Aruna");

}

}

Calling

AbstractClass abs = new AbstractImp1();

abs.PrintName();

Read More

Abstract

The abstract modifier can be used with classes, methods, properties, indexers, and events.

Use the abstract modifier in a class declaration to indicate that a class is intended only to be a base class of other classes.

Abstract classes have the following features:

• An abstract class cannot be instantiated.
• An abstract class may contain abstract methods and accessors.
• It is not possible to modify an abstract class with the sealed modifier, which means that the class cannot be inherited.
• A non-abstract class derived from an abstract class must include actual implementations of all inherited abstract methods and accessors.

Use the abstract modifier in a method or property declaration to indicate that the method or property does not contain implementation.

Abstract methods have the following features:

• An abstract method is implicitly a virtual method.
• Abstract method declarations are only permitted in abstract classes.
• Because an abstract method declaration provides no actual implementation, there is no method body; the method declaration simply ends with a semicolon and there are no braces ({ }) following the signature. For example:

·         The implementation is provided by an overriding method, which is a member of a non-abstract class.

•  It is an error to use the static or virtual modifiers in an abstract method declaration.

public abstract void MyMethod();

An abstract class must provide implementation for all interface members.
An abstract class that implements an interface might map the interface methods onto abstract methods. For example:

interface I

{

    void M();

}

abstract class C : I

{

    public abstract void M();

}

Example

In this example, the class MyDerivedC is derived from an abstract class MyBaseC. The abstract class contains an abstract method, MyMethod(), and two abstract properties, GetX() and GetY().

// abstract_keyword.cs

// Abstract Classes

using System;

abstract class MyBaseC   // Abstract class

{

   protected int x = 100;

   protected int y = 150;

   public abstract void MyMethod();   // Abstract method

   public abstract int GetX   // Abstract property

   {

      get;

   }

   public abstract int GetY   // Abstract property

   {

      get;

   }

}

class MyDerivedC: MyBaseC

{

   public override void MyMethod()

   {

      x++;

      y++;  

   }  

   public override int GetX   // overriding property

   {

      get

      {

         return x+10;

      }

   }

   public override int GetY   // overriding property

   {

      get

      {

         return y+10;

      }

   }

   public static void Main()

   {

      MyDerivedC mC = new MyDerivedC();

      mC.MyMethod();

      Console.WriteLine("x = {0}, y = {1}", mC.GetX, mC.GetY);   

   }

}

Output

x = 111, y = 161

In the preceding example, if you attempt to instantiate the abstract class by using a statement like this:

MyBaseC mC1 = new MyBaseC();   // Error

you will get the following error message:

Cannot create an instance of the abstract class 'MyBaseC'.

Read More

Singleton - [Creational Patterns]

Singleton Definition

Ensure a class has only one instance and provide a global point of access to it.

This structural code demonstrates the Singleton pattern which assures only a single instance (the singleton) of the class can be created.

namespace Singleton

{

    class Program

    {

        static void Main(string[] args)

        {

            Singleton s1 = Singleton.Instance();

            Singleton s2 = Singleton.Instance();

            if (s1 == s2)

            {

                Console.WriteLine("Indenticle Instances");

            }

            Console.ReadKey();

        }

    }

}

Singleton Class

namespace Singleton

{

    class Singleton

    {

        public static Singleton _instance;

        protected Singleton()

        {

        }

        public static Singleton Instance()

        {

            if (_instance == null)

            {

                _instance = new Singleton();

            }

            return _instance;

        }

    }

}

Read More