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. Berücksichtigen Sie nun die Umstände, unter denen Filialeinheiten erstellt, Mieten für verschiedene Filialen berechnet und zukünftige Ergänzungen und Änderungen ermöglicht werden. 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 Algorithmus für diesen Geschäftstyp verwendet werden sollte:

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, um ein Objekt zu erstellen , das die Methode der vorherigen Factory-Klasse zum Erstellen von Objekten durch Switch ersetzt, erleichtert das spätere Hinzufügen neuer Speichertypen und Algorithmusmodifikationen, -ergänzungen und -wartungen. Wenn sich die Projektanforderungen in Zukunft ändern, müssen wir nur C erneut hinzufügen und D-Typ-Speicher zum Projekt, erben Sie die Methoden in der Ishop-Implementierung und fügen Sie gleichzeitig die geerbte IFactroy-Schnittstelle hinzu, erstellen Sie das entsprechende Speicherobjekt, kompilieren Sie die ProductEnity.dll des Projekts und berechnen Sie dann die C, Speicheralgorithmus vom Typ D durch Reflexion. Der ursprüngliche technische Code muss geändert werden.

Das Obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass er für das Studium aller hilfreich sein wird, und ich hoffe auch, dass jeder die chinesische PHP-Website unterstützt.