Abstrakt fabrikalar naqshining amalga oshirilishi qanday?

Abstract Factory naqshoni, bog'liq yoki bir-biriga bog'liq bo'lgan obyektlar oilasini ularning aniq sinflarini belgilamasdan yaratish uchun interfeys taqdim etadi.

Asosiy komponentlar:

1. Abstract Factory: Abstrakt mahsulotlarni yaratish operatsiyalari uchun interfeysni e'lon qiladi.
2. Concrete Factory: Aniq mahsulotlar oilasi uchun abstrakt mahsulotlarni yaratish operatsiyalarini amalga oshiradi.
3. Abstract Product: Mahsulot turining interfeysini e'lon qiladi.
4. Concrete Product: Aniq mahsulot uchun abstrakt mahsulot interfeysini amalga oshiradi.
5. Client: Abstract Factory va Abstract Product interfeyslaridan foydalanadi, ammo Concrete Factory va Concrete Product haqida bilmaydi.

Amalga oshirish:

• Har bir mahsulot turi uchun yaratish metodlari bilan abstrakt fabrika aniqlanadi.
• Har bir mahsulot oilasi uchun, mos keladigan aniq mahsulotlarni yaratadigan konkret fabrika yaratiladi.
• Har bir mahsulot turi uchun, abstrakt mahsulot interfeysi aniqlanadi.
• Har bir konkret mahsulot uchun, mos keladigan interfeysni amalga oshiradigan sinf yaratiladi.
• Client, abstrakt fabrika ob'ektini oladi va uning metodlarini chaqiradi, faqat mahsulot interfeyslar bilan ishlaydi.

// Abstrakt fabrika
public interface IAbstractFactory
{
    IAbstractProductA CreateProductA();
    IAbstractProductB CreateProductB();
}

// Konkrekt fabrika 1
public class ConcreteFactory1 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA1();
    }

    public IAbstractProductB CreateProductB()
    {
        return new ConcreteProductB1();
    }
}

// Konkrekt fabrika 2
public class ConcreteFactory2 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA2();
    }

    public IAbstractProductB CreateProductB()
    {
        return new ConcreteProductB2();
    }
}

// Abstrakt mahsulot A
public interface IAbstractProductA
{
    string UsefulFunctionA();
}

// Konkrekt mahsulot A1
public class ConcreteProductA1 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "A1 mahsulotining natijasi.";
    }
}

// Konkrekt mahsulot A2
public class ConcreteProductA2 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "A2 mahsulotining natijasi.";
    }
}

// Abstrakt mahsulot B
public interface IAbstractProductB
{
    string UsefulFunctionB();
    string AnotherUsefulFunctionB(IAbstractProductA collaborator);
}

// Konkrekt mahsulot B1
public class ConcreteProductB1 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "B1 mahsulotining natijasi.";
    }

    // B1 mahsuloti faqat A mahsulotlari bilan ishlash mumkin
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"B1, ({result}) bilan hamkorlikda";
    }
}

// Konkrekt mahsulot B2
public class ConcreteProductB2 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "B2 mahsulotining natijasi.";
    }

    // B2 mahsuloti faqat A mahsulotlari bilan ishlash mumkin
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"B2, ({result}) bilan hamkorlikda";
    }
}

// Mijoz kodi
public class Client
{
    public void Main()
    {
        // Mijoz kodi abstrakt fabrikadan ishlaydi
        Console.WriteLine("Mijoz: Birinchi turdagi fabrik bilan mijoz kodini sinovdan o'tkazish:");
        ClientMethod(new ConcreteFactory1());
        Console.WriteLine();

        Console.WriteLine("Mijoz: Ikkinchi turdagi fabrik bilan bir xil mijoz kodini sinovdan o'tkazish:");
        ClientMethod(new ConcreteFactory2());
    }

    public void ClientMethod(IAbstractFactory factory)
    {
        var productA = factory.CreateProductA();
        var productB = factory.CreateProductB();

        Console.WriteLine(productB.UsefulFunctionB());
        Console.WriteLine(productB.AnotherUsefulFunctionB(productA));
    }
}