Erklärung des .NET Factory-Methodenmusters

Einführung in das Factory-Methodenmuster:

Die Bedeutung des Factory-Methodenmusters besteht darin, eine Factory-Schnittstelle zu definieren, die Produktobjekte erstellt und die eigentliche Erstellungsarbeit auf Unterklassen verlagert. Die Kern-Factory-Klasse ist nicht mehr für die Erstellung von Produkten verantwortlich. Auf diese Weise wird die Kernklasse zu einer abstrakten Factory-Rolle, die nur für die Schnittstellen verantwortlich ist, die bestimmte Factory-Unterklassen implementieren müssen ermöglicht den Betrieb des Systems, ohne die spezifische Fabrikrolle zu ändern. Einführung neuer Produkte.

Strukturdiagramm des Fabrikmethodenmusters:

Rollenklassifizierung:

Abstrakte Fabrikrolle: Sie ist der Kern des Fabrikmethodenmusters und hängt mit der Anwendung zusammen. Nichts zu tun. Jede Factory-Klasse für im Muster erstellte Objekte muss diese Schnittstelle implementieren.
Konkrete Fabrikrolle: Dies ist eine konkrete Fabrikklasse, die die abstrakte Fabrikschnittstelle implementiert, eine eng mit der Anwendung verbundene Logik enthält und von der Anwendung aufgerufen wird, um Produktobjekte zu erstellen.
Abstrakte Produktrolle: das von der erstellte Objekt Factory-Methodenmuster Der Supertyp ist die gemeinsame übergeordnete Klasse oder gemeinsame Schnittstelle von Produktobjekten. Im Bild oben ist dieser Charakter Light.
Konkrete Produktrolle: Diese Rolle implementiert die durch die abstrakte Produktrolle definierte Schnittstelle. Ein bestimmtes Produkt wird in einer bestimmten Fabrik hergestellt und es besteht häufig eine Eins-zu-eins-Entsprechung zwischen ihnen.

Wir stellen praktische Beispiele vor:

Im vorherigen Blog-Beitrag „Simple Factory Pattern“ wurde die folgende Implementierung mithilfe des einfachen Factory-Musters durchgeführt: Wenn ein Resident-Management-System vorhanden ist, geben die Residenten darin ein ist variabel, es gibt Unterschiede in der Mietberechnungsformel für jeden Mietertyp, zum Beispiel: der Mietbetrag für Bewohner des Typs A = Anzahl der Tage * Einheitspreis + Leistung * 0,005; der Mietbetrag für Bewohner des Typs B = Monat * (monatlich). Preis + Leistung * 0,001) Hier werden zwar die Anforderungen des Kunden erfüllt, aber wenn der Kunde später einen C-Typ-Speicher und einen D-Typ-Speicher hinzufügen muss und ihre Algorithmusanforderungen unterschiedlich sind, müssen wir zu diesem Zeitpunkt C und erstellen D-Typ-Speicher und die Ishop-Schnittstelle erben, müssen Sie die Factory-Klasse weiter ändern und Fälle im Schalter hinzufügen, um entsprechende Speicherobjekte zu erfassen und zu erstellen des Programms und die Pflege des späteren Projekts.

1. Geschäfte haben gemeinsame Verhaltensmerkmale und müssen ein Verhalten zur Berechnung der Ladenmiete durchführen. Wir haben Ishop abstrahiert, das das Verhalten der zu implementierenden Methode zur Berechnung der Ladenmiete enthält.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace FactoryEntiy
{
  public interface Ishop
  {
    double Getrent(int days, double dayprice, double performance);
  }
}

2. Wir implementieren die Methoden in der Isho-Schnittstelle und erstellen Geschäfte vom Typ A und B.

using FactoryEntiy;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ProductEnity
{
  /// <summary>
  /// 继承商店接口，实现里面的行为方法，即算法
  /// </summary>
  public class Ashop:Ishop
  {
    /// <summary>
    /// /// A类型商店租金额，天数*单价+绩效*0.005
    /// </summary>
    /// <param name="days">天数</param>
    /// <param name="dayprice">每天单价</param>
    /// <param name="performance">日平均绩效</param>
    /// <returns></returns>
    public double Getrent(int days, double dayprice, double performance)
    {
      Console.WriteLine("A商店的租金算法");
      return days * dayprice + performance * 0.01;
    }
  }
}

using FactoryEntiy;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ProductEnity
{
  /// <summary>
  /// 继承商店接口，实现里面的行为方法，即算法
  /// </summary>
  public class Bshop:Ishop
  {
    /// <summary>
    /// B类型商店的租金=月份*(每月价格+performance*0.001)
    /// </summary>
    /// <param name="month">月数</param>
    /// <param name="monthprice">月单价</param>
    /// <param name="performance">月平均绩效</param>
    /// <returns></returns>
    public double Getrent(int month, double monthprice, double performance)
    {
      Console.WriteLine("B商店的租金算法");
      return month * (monthprice + performance * 0.001);
    }
  }
}

3. Betrachten Sie nun die Umstände, unter denen Filialeinheiten erstellt und Mietberechnungen für verschiedene Filialen durchgeführt werden und erleichtern zukünftige Ergänzungen und Änderungen. Deshalb erstellen wir die IFactroy-Schnittstelle, die Methoden zum Erstellen von zu implementierenden Speicherobjekten enthält.

using FactoryEntiy;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace FactoryMethod
{
  /// <summary>
  /// 工厂类，创建商店类型实体
  /// </summary>
  public interface IFactory
  {
    Ishop CreateShop();
  }
}

4 Jetzt können wir von IFactory erben und darin das entsprechende Store-Objekt erstellen.

using FactoryEntiy;
using FactoryMethod;
using ProductEnity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ProductEnity
{
  /// <summary>
  /// 继承工厂类，创建A类型商店实体
  /// </summary>
  public class CreateBshop : IFactory
  {
    public Ishop CreateShop()
    {
      return new Ashop();
    }
  }
}

using FactoryEntiy;
using FactoryMethod;
using ProductEnity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ProductEnity
{
  /// <summary>
  /// 继承工厂类，创建B类型商店实体
  /// </summary>
  public class CreateAshop : IFactory
  {
    public Ishop CreateShop()
    {
      return new Bshop();
    }
  }
}

5. Beurteilen Sie dann anhand des aktuellen Geschäftstyps, welcher Geschäftstyp ausgeführt werden soll :

using FactoryEntiy;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Reflection;
using System.Text;
 
namespace FactoryMethod.App
{
  class Program
  {
    static void Main(string[] args)
    {
      string shopname = ConfigurationManager.AppSettings["CreateShopClassName"];
      //shopname为创建商店类名称，此处=CreateAshop
      IFactory af = (IFactory)Assembly.Load("ProductEnity").CreateInstance("ProductEnity." + shopname);
      //第一个ProductEnity是dll的名称，第二个ProductEnity是项目的命名空间。
      Ishop As = af.CreateShop(); double total = As.Getrent(30, 300, 2000); //30 天/100元 日平均绩效为2000
      Console.WriteLine("该A类型商店的租金为：" + total);
       
      Console.WriteLine("=============");
      IFactory bf = (IFactory)Assembly.Load("ProductEnity").CreateInstance("ProductEnity." + "CreateBshop");
      //CreateBshop可以保存为配置或者存在数据库中，
      //注意该保存字符串应该与项目中创建的类名一样，
      //否则反射的方式会找不到该项目下的类。
      Ishop Bs = bf.CreateShop(); total = Bs.Getrent(30, 300, 2000); //30 天/100元 日平均绩效为2000
      Console.WriteLine("该A类型商店的租金为：" + total);
    }
  }
}

Hier verwenden wir Reflektion zum Erstellen von Objekten und ersetzen die Methode der vorherigen Factory-Klasse zum Erstellen von Objekten durch Schalter, was für nachfolgende neue von Vorteil ist. Nachdem der Typspeicher hinzugefügt und der Algorithmus geändert und gewartet wurde und sich die Projektanforderungen ändern, müssen wir nur noch C- und D-Typspeicher zum Projekt hinzufügen, die Methoden in der Ishop-Implementierung erben und gleichzeitig Fügen Sie die IFactroy-Schnittstelle hinzu und erben Sie sie, um das entsprechende Speicherobjekt zu erstellen. Kompilieren Sie die ProductEnity.dll des Projekts und berechnen Sie dann die Speicheralgorithmen vom Typ C und D durch Reflektion, ohne den ursprünglichen technischen Code zu ändern.

Das Strukturdiagramm des gesamten Projekts lautet wie folgt: