Erklärung des einfachen .NET-Factory-Musters

Einführung in das einfache Fabrikmuster:

Das einfache Fabrikmuster ist ein Erstellungsmuster, das auch als statische Fabrikmethode (Static Factory Method) bezeichnet wird, aber nicht zu den 23 GOF-Entwurfsmustern gehört. Das einfache Factory-Muster verwendet ein Factory-Objekt, um zu entscheiden, welche Produktklasseninstanz erstellt werden soll. Das einfache Factory-Pattern ist das einfachste und praktischste Pattern in der Factory-Pattern-Familie und kann als spezielle Implementierung verschiedener Factory-Patterns verstanden werden.

Strukturmusterdiagramm:

Rollenklassifizierung:

Fabrikrolle (Ersteller)
Der Kern des Einfachen Factory-Muster, das für die Implementierung der internen Logik zum Erstellen aller Instanzen verantwortlich ist. Die Methode zum Erstellen einer Produktklasse in der Factory-Klasse kann direkt von der Außenwelt aufgerufen werden, um das erforderliche Produktobjekt zu erstellen.

Abstrakte Produktrolle
Die übergeordnete Klasse aller durch das einfache Factory-Muster erstellten Objekte, die für die Beschreibung der allen Instanzen gemeinsamen öffentlichen Schnittstelle verantwortlich ist.

Die Rolle „Betonprodukt“
ist das Erstellungsziel des einfachen Factory-Musters. Alle erstellten Objekte sind Instanzen einer bestimmten Klasse, die diese Rolle spielt.

Einführung in die aktuelle Situation:

Wenn es ein Mieterverwaltungssystem gibt, sind die Mietertypen darin variabel und die Mietberechnungsformel für jeden Mietertyp ist unterschiedlich

Der Mietbetrag für Bewohner des Typs A = Anzahl der Tage * Einheitspreis + Leistung * 0,005

Der Mietbetrag für Bewohner des Typs B = Monat * (Monatspreis + Leistung * 0,001)

Analyse:

1. Geschäfte haben eine gemeinsame Berechnungsmethode. Sie verhalten sich jedoch unterschiedlich. Daher abstrahieren wir die Ladenklasse und der Code ist wie folgt >

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

2. Nach der Abstraktion des Geschäfts müssen wir eine bestimmte Produktklasse erstellen. Hier ist der spezifische Typ „Geschäft“, der die Verhaltensmethode des Geschäfts implementiert . Erstellen Sie ein Geschäft vom Typ A

using SimpleFactory.App.IFactroy;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace SimpleFactory.App.product
{
  //A类型的商店的创建
  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;
    }
  }
}

3. Erstellen Sie ein Geschäft vom Typ B:

using SimpleFactory.App.IFactroy;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace SimpleFactory.App.product
{
  /// <summary>
  /// B类型的商店的创建
  /// </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);
    }
  }
}

4. Überlegen Sie nach dem Erstellen des Typspeichers und der Implementierung der Methode, wie Sie unter welchen Umständen ein solches Objekt erstellen können. So entstand der Kernteil des einfachen Factory-Musters: die Factory-Klasse

using SimpleFactory.App.IFactroy;
using SimpleFactory.App.product;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace SimpleFactory.App.factoryMethod
{
  public class factorymethod
  {
    public Ishop CreateShow(string show)
    {
      switch (show.Trim().ToLower())
      {
        case"ashop":
          return new Ashop();
        case "bshop":
          return new Ashop();
        default:
          throw new Exception("该商店不存在");
      }
    }
  }
}

5. Beurteilen Sie dann anhand des aktuellen Geschäftstyps, welcher Algorithmus für diesen Geschäftstyp verwendet werden sollte:

using SimpleFactory.App.factoryMethod;
using SimpleFactory.App.IFactroy;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace SimpleFactory.App
{
  class Program
  {
    static void Main(string[] args)
    {
      Ishop As;
      factorymethod afm = new factorymethod();
      As = afm.CreateShow("ashop"); //a 类型的某商店
      double total = As.Getrent(30, 300, 2000);   //30 天/100元 日平均绩效为2000
      Console.WriteLine("该A类型商店的租金为：" + total);
 
      Console.WriteLine("=============");
 
      Ishop Bs;
      factorymethod bfm = new factorymethod();
      Bs = bfm.CreateShow("bshop"); //b 类型的某商店
      total = Bs.Getrent(3, 3000, 60000);     //3 月/4000元 月平均绩效为60000
      Console.WriteLine("该B类型商店的租金为：" + total);
      Console.ReadKey();
    }
  }
}

Hier haben wir die Algorithmusanforderungen für die beiden vom Kunden geforderten Arten von Geschäften implementiert. Als gute Designarchitektur sollten wir jedoch auch die späteren Nachfrageänderungen berücksichtigen Fügt Typ-C-Stores und D-Type-Stores hinzu, die unterschiedliche Algorithmusanforderungen haben. Zu diesem Zeitpunkt müssen wir C- und D-Type-Stores erstellen, die Ishop-Schnittstelle erben, die darin enthaltenen Methoden implementieren und gleichzeitig die Factory-Klasse weiter ändern und fügen Sie Fälle in Switch Capture hinzu und erstellen Sie entsprechende Speicherobjekte. Sobald eine solche Situation auftritt, ist dies nicht förderlich für die Skalierbarkeit des Programms und die Wartung des späteren Projekts.

Vorteile:

Das einfache Fabrikmuster kann basierend auf den von der Außenwelt bereitgestellten Informationen entscheiden, welche spezifische Klasse von Objekten erstellt werden soll. Dadurch kann sich die Außenwelt von der peinlichen Situation befreien, bestimmte Produktobjekte direkt zu erstellen.

Die Außenwelt ist von der konkreten Klasse isoliert und die Kopplung ist gering.

Schenkt klar ihre jeweiligen Verantwortlichkeiten und Befugnisse ab, was der Optimierung der gesamten Softwarearchitektur förderlich ist.

Nachteile:

Die Factory-Klasse konzentriert die Erstellungslogik aller Instanzen, was leicht gegen das GRASPR-Prinzip der Verantwortungszuweisung mit hoher Kohäsion verstößt

Obwohl das einfache Factory-Muster dies sein kann angepasst Es gibt gewisse Änderungen, aber die Probleme, die damit gelöst werden können, sind sehr begrenzt. Die Klassen, die erstellt werden können, können nur im Voraus berücksichtigt werden. Wenn Sie eine neue Klasse hinzufügen müssen, müssen Sie die Factory-Klasse ändern.

Wie die auftretende Beschwerdesituation gelöst werden kann, ist eine Überlegung wert und wird im nächsten Fabrikmethodenmuster gut gelöst.

Das Obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass er zum Lernen aller beiträgt. Ich hoffe auch, dass jeder die PHP-Chinesisch-Website unterstützt.