Factory Pattern - [Creational Patterns]

Factory Pattern

Logical Model

As with other design patterns, there are countless variations of the Factory pattern, although most variants typically used the same set of primary actors, a client, a factory, and a product. The client is an object that requires an instance of another object (the product) for some purpose. Rather than creating the product instance directly, the client delegates this responsibility to the factory. Once invoked, the factory creates a new instance of the product, passing it back to the client. Put simply, the client uses the factory to create an instance of the product. Bellow shows this logical relationship between these elements of the pattern.

abstract class Page

{

}

class Education : Page

{

}

class SkillPage : Page

{

}

class Experiance : Page

{

}

//----

abstract class Document

{

private List<Page> _pages = new List<Page>();

        public abstract void CreatePages();

        public Document()

        {

            this.CreatePages();

        }

        public List<Page> Page

        {

            get { return _pages; }

        }

    }

class Resume : Document

{

   public override void CreatePages()

   {

Page.Add(new Education());

       Page.Add(new SkillPage());

       Page.Add(new Experiance());

   }

}

 

Read More

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