{"id":447,"date":"2014-10-29T10:15:46","date_gmt":"2014-10-29T10:15:46","guid":{"rendered":"http:\/\/mairwa.com\/wordpress\/?p=447"},"modified":"2014-10-29T10:15:46","modified_gmt":"2014-10-29T10:15:46","slug":"design-pattern-2","status":"publish","type":"post","link":"http:\/\/mairwa.com\/wordpress\/?p=447","title":{"rendered":"design pattern"},"content":{"rendered":"

—factory and abstract factory pattern in .net———-<\/strong><\/p>\n

Note: \u2013 This is quiet a confusing architect question especially in design pattern section.<\/i><\/p>\n

Interviewer can take you for a nice ride. So get the difference in your heart.<\/i><\/p>\n

First read the definition provided in the first question about both these patterns. The\u00a0common thing they have is that they belong to creational patterns. In short they hide the\u00a0complexity of creating objects.<\/p>\n

The main difference between factory and Abstract factory is factory method uses<\/p>\n

inheritance to decide which object has to be instantiated while abstract factory uses<\/p>\n

delegation to decide instantiation of object. We can say Abstract factory uses factory<\/p>\n

259\u00a0method to complete the architecture. Abstract Factory is one level higher in abstraction\u00a0over Factory.<\/p>\n

 <\/p>\n

First figure shows a sample implementation of Factory Patterns. In this figure there are<\/p>\n

two basic sections:-<\/p>\n

\u221a\u00a0The actual product section i.e. Class \u201cProduct\u201d it inherits from an abstract<\/p>\n

class \u201cAbstractProduct\u201d.<\/p>\n

\u221a\u00a0The creational aspect section i.e. \u201cConcreteCreator\u201d class which inherits<\/p>\n

from class \u201cCreator\u201d.<\/p>\n

\u221a\u00a0Now there are some rules the client will have to follow who<\/p>\n

will need the \u201cProduct\u201d object. He will never refer directly to the actual \u201cProduct\u201d object<\/p>\n

he will refer the \u201cProduct\u201d object using \u201cAbstractProduct\u201d.<\/p>\n

\u221a\u00a0Second client will never use \u201cNew\u201d keyword to create the \u201cProduct\u201d object<\/p>\n

but will use the \u201cCreator\u201d class which in turn will use the \u201cConcreteCreator\u201d<\/p>\n

class to create the actual \u201cProduct\u201d object.<\/p>\n

 <\/p>\n

So what are the benefits from this architecture? All creational and initializing aspects are<\/p>\n

now detached from the actual client. As your creational aspect is now been handled in<\/p>\n

\u201cConcreteCreator\u201d and the client has reference to only \u201cCreator\u201d, so any implementation<\/p>\n

change in \u201cCreateProduct\u201d will not affect the client code. In short now your creational<\/p>\n

aspect of object is completely encapsulated from the client\u2019s logic.<\/p>\n

260<\/p>\n

Now let\u2019s look at the second class diagram which provides an overview of what actually<\/p>\n

\u201cAbstract factory\u201d pattern is. It creates objects for families of classes. In short it describes<\/p>\n

collection of factor methods from various different families. In short it groups related<\/p>\n

factory methods. Example in this the class \u201cCreator\u201d is implemented using the \u201cAbstract\u201d<\/p>\n

factory pattern. It now creates objects from multiple families rather one product.<\/p>\n

Note :- Just stick up to this definition that Abstract factory classifies factory methods or<\/i><\/p>\n

groups logically related factory method together.<\/i><\/p>\n

\u00a0<\/i><\/p>\n

How Singleton is different from Static class?<\/b><\/p>\n