Shulou(Shulou.com)06/02 Report--

This article mainly shows you "how to implement the factory pattern in the C# design pattern", the content is easy to understand, clear, hope to help you solve your doubts, the following let the editor lead you to study and learn "how to implement the factory pattern in the C# design pattern" this article.

I. introduction

Introduce a model that is easy to understand-the simple factory model.

2. Introduction of simple factory model

When it comes to simple factories, nature's first question is, of course, what is the simple factory model? In real life, the factory is responsible for producing products. Similarly, in the design pattern, the simple factory pattern can also be understood as a class responsible for producing objects. In our usual programming, when we use the "new" keyword to create an object, the class depends on the object, that is, the coupling between them is high. When the requirements change, we have to modify the source code of this class. At this time, we can use the very important principle of object-oriented (OO) to solve this problem, which is to encapsulate the change. Since we want to encapsulate the change, we naturally have to find the changed code, and then encapsulate the changed code with classes. This way of thinking is the implementation of our simple factory pattern. The following leads to a simple factory pattern through a real-life example.

People who work outside will inevitably eat out often. of course, we can also cook at home, but it is troublesome to cook and eat by ourselves, because we have to buy food by ourselves. however, there is no such trouble at all when we go out to eat. We just need to go to the restaurant to order, and the food shopping can be left to the restaurant, where the restaurant acts as a simple factory. Let's take a look at how real-life examples are represented in code.

The situation of cooking by yourself:

/ the situation of cooking by oneself / before there is no simple factory, customers can only stir-fry what they want to eat / public class Customer {/ cooking method / public static Food Cook (string type) {Food food = null / / customer A said: what if I want to eat Scrambled Egg with Tomato? / / customer B said: then burn it yourself / / customer A says: all right, then do it yourself if (type.Equals ("Scrambled Egg with Tomato")) {food = new TomatoScrambledEggs () } / / I want to eat shredded potatoes again. I still have to make this by myself. / / I feel so tired. I wish someone could help me do it. Else if (type.Equals ("shredded potatoes") {food = new ShreddedPorkWithPotatoes ();} return food;} static void Main (string [] args) {/ / do Scrambled Egg with Tomato Food food1 = Cook ("Scrambled Egg with Tomato"); food1.Print () Food food2 = Cook ("shredded potatoes"); food1.Print (); Console.Read ();}} / vegetable abstract class / public abstract class Food {/ / output what dish public abstract void Print () } / scrambled eggs with tomatoes / public class TomatoScrambledEggs: Food {public override void Print () {Console.WriteLine ("one Scrambled Egg with Tomato!") / public class ShreddedPorkWithPotatoes: Food {public override void Print () {Console.WriteLine ("one shredded potato");}}

We cook by ourselves, and if we want to eat other dishes, we need to buy this kind of food and wash it. After we have a restaurant (that is, a simple factory), we can leave these operations to the restaurant. At this time, the dependence of consumers (that is, us) on food (that is, specific objects) has changed from direct to indirect. This is another object-oriented principle-reducing the coupling between objects. Let's take a look at the implementation code after having a restaurant (that is, the implementation of a simple factory):

/ / the customer acts as the client and is responsible for calling the simple factory to produce the object / / that is, the customer orders. The chef (equivalent to a simple factory) is responsible for cooking (the object of production) / / class Customer {static void Main (string [] args) {/ / the customer wants to order a Scrambled Egg with Tomato Food food1 = FoodSimpleFactory.CreateFood ("Scrambled Egg with Tomato") Food1.Print (); / / customer wants to order a shredded potato Food food2 = FoodSimpleFactory.CreateFood ("shredded potato"); food2.Print (); Console.Read () }} / Food Abstract Class / public abstract class Food {/ / output what dish public abstract void Print () } / scrambled eggs with tomatoes / public class TomatoScrambledEggs: Food {public override void Print () {Console.WriteLine ("one Scrambled Egg with Tomato!") / public class ShreddedPorkWithPotatoes: Food {public override void Print () {Console.WriteLine ("one shredded potato") }} / simple factory class, responsible for cooking / public class FoodSimpleFactory {public static Food CreateFood (string type) {Food food= null; if (type.Equals ("shredded potato meat")) {food= new ShreddedPorkWithPotatoes () } else if (type.Equals ("Scrambled Egg with Tomato")) {food= new TomatoScrambledEggs ();} return food;}} III. Advantages and disadvantages

After watching the implementation of the simple factory pattern, you and your friends will definitely have this confusion (because I also had it when I was studying)-- so we just moved the change to the factory class, and there seems to be no change problem, because if the customer wants to eat other dishes, we still need to modify the method in the factory class (that is, add more case statements, before applying the simple factory pattern). What is modified is the customer class. First of all, I would like to say that you and your partner are quite right, and this is the disadvantage of the simple factory model (the factory method described later can be solved very well). However, the simple factory pattern and the previous implementation also have its advantages:

The simple factory pattern solves the problem that the client directly depends on the specific object, and the client can eliminate the responsibility of creating the object directly, instead of just consuming the product. The simple factory model realizes the division of responsibility.

The simple factory pattern also plays a role in code reuse, because in the previous implementation (in the case of self-cooking), a different person also has to implement the method of cooking in his own class, and then with a simple factory, everyone who goes to a restaurant doesn't have to bother so much, just be responsible for consumption. At this time, the cooking method of the simple factory is shared by all customers. (at the same time, this is also a disadvantage of the simple factory method-- because the factory class centralizes all the product creation logic, once it does not work properly, the whole system will be affected, and it is not difficult to understand, just as things have two sides.)

Although the shortcomings of the simple factory model have been described above, here is a summary of the disadvantages of the simple factory model:

The factory class centralizes all the product creation logic, and once it doesn't work properly, the whole system will be affected (popular meaning: once the restaurant is out of food or closed, many people who don't want to cook will have nothing to eat.)

It is difficult to expand the system, and once a new product is added, the factory logic has to be modified, which will cause the factory logic to be too complex.

After understanding the advantages and disadvantages of the simple factory model, we can then know the application scenario of the simple factory:

Consider using the simple factory pattern when the factory class is responsible for creating fewer objects ()

If customers only know the parameters passed in to the factory class, they can consider using the simple factory pattern if they are not concerned about the logic of how to create the object.

4. UML diagram of simple factory model

The simple factory pattern is also called the static method pattern (because the factory class defines a static method). It is up to a factory class to decide which instance of the product class to create based on the passed parameters (popular point expression: responsible for cooking that dish through the order placed by the customer). The UML diagram of the simple factory pattern is as follows:

Fifth, the implementation of simple factory pattern in .NET.

After introducing the simple factory pattern, I learned something like: are there any classes in the .NET class library that implement the simple factory pattern? It is true that the System.Text.Encoding class in .NET implements the simple factory pattern, and the GetEncoding (int codepage) in this class is the factory method. The specific code can be viewed through the Reflector decompiler tool. I will also post some of the code in this method:

Public static Encoding GetEncoding (int codepage) {Encoding unicode = null; if (encodings! = null) {unicode = (Encoding) encodings [codepage];} if (unicode = = null) {object obj2; bool lockTaken = false; try {Monitor.Enter (obj2 = InternalSyncObject, ref lockTaken) If (encodings = = null) {encodings = new Hashtable ();} unicode = (Encoding) encodings [codepage]; if (unicode! = null) {return unicode } switch (codepage) {case 0: unicode = Default; break Case 1: case 2: case 3: case 0x2a: throw new ArgumentException (Environment.GetResourceString ("Argument_CodepageNotSupported", new object [] {codepage}), "codepage"); case 0x4b0: unicode = Unicode; break Case 0x4b1: unicode = BigEndianUnicode; break; case 0x6faf: unicode = Latin1; break; case 0xfde9: unicode = UTF8; break Case 0x4e4: unicode = new SBCSCodePageEncoding (codepage); break; case 0x4e9f: unicode = ASCII; break; default: unicode = GetEncodingCodePage (codepage) If (unicode = = null) {unicode = GetEncodingRare (codepage);} break;} encodings.Add (codepage, unicode); return unicode;}}

The simple factory pattern implemented in the Encoding class is an evolution of the simple factory pattern, where the simple factory class is played by abstract products, but how does the Encoding class in .NET solve the problems in the simple factory pattern (that is, what if a new code is added)? The switch function in the GetEncoding method has the following code:

Switch (codepage) {. Default: unicode = GetEncodingCodePage (codepage); if (unicode = = null) {unicode = GetEncodingRare (codepage); / / when coding is rare} break;. }

There is some instantiated code that is not commonly coded in the GetEncodingRare method, and Microsoft officially uses this method to solve the problem of adding a new kind of coding. (that is, listing all possible coding situations), the reason why Microsoft solves this problem in this way may be that the code is now stable and the possibility of adding new code is relatively low. so this part of the code has not been changed in .NET 4.5.

These are all the contents of the article "how to implement the Factory pattern in the C# Design pattern". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.