2

I have read a lot of posts about different between Abstract Factory and Factory method, but there are a problem I can't understand.

One difference between the two is that with the Abstract Factory pattern, a class delegates the responsibility of object instantiation to another object via composition whereas the Factory Method pattern uses inheritance and relies on a subclass to handle the desired object instantiation

Maybe I know why Abstract Factory pattern use composition and delegates to create object, but I can't understand why Factory Method pattern uses inheritance to create concrete class objects.

This question is not about what abstract factory is or what factory method is and hence does not have answer here

It is about why factory method seems to use inheritance when a client can call factory method directly too. Please unmark it as duplicate.

Improve this question
0

1 Answer 1

Reset to default
6

Abstract Factory

public interface IMyFactory { IMyClass CreateMyClass(int someParameter); }

Usage:

public class SomeOtherClass { private readonly IMyFactory factory; public SomeOtherClass(IMyFactory factory) { this.factory = factory; } public void DoSomethingInteresting() { var mc = this.factory.CreateMyClass(42); // Do something interesting here } }

Notice that SomeOtherClass relies on Composition to be composed with an IMyFactory instance.

Factory Method

public abstract class SomeOtherClassBase { public void DoSomethingInteresting() { var mc = this.CreateMyClass(42); // Do something interesting here } protected abstract IMyClass CreateMyClass(int someParameter) }

Usage:

public class SomeOtherClass2 : SomeOtherClassBase { protected override IMyClass CreateMyClass(int someParameter) { // Return an IMyClass instance from here } }

Notice that this example relies on inheritance to work.

Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

ok, I understand but which style is better and what have advantages? Or we can use any of them?
If you favour composition over Inheritance it should be clear which one you should favour ;)
@grep Abstract Factory typically is used with families of products, meaning the interface has one method for each product in the family. This example oversimplifies the pattern with a one-product family. Even though it uses composition, Abstract Factory is also risky because of inheritance. If you need to add (or remove) a product in the families, you've got to change the interface (add or remove a method) and therefore all the factories. Benefits of "composition over inheritance" are not really an obvious difference as stated. The main difference is whether you have a family of products.
@MarkSeemann In your factory method design, you are assuming that the client will never call CreateMyClass(int someParameter) and will always call it through DoSomethingInteresting() indirectly. Why ? Because if it does call it directly, then the client also depended on object composition to get the created object.
@Number945 CreateMyClass is protected, so clients can't call it directly.
|

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.