რა არის აბსტრაქტული ფაბრიკის ნიმუშის განხორციელება?

აბსტრაქტული ფაბრიკა უზრუნველყოფს ინტერფეისს ურთიერთდაკავშირებული ან ურთიერთდაკავშირებული ობიექტების ოჯახების შექმნისთვის, მათი კონკრეტული კლასების მითითების გარეშე.

ძირითადი კომპონენტები:

1. Abstract Factory: გამოაცხადებს ინტერფეისს აბსტრაქტული პროდუქტების შექმნის ოპერაციებისათვის.
2. Concrete Factory: ახორციელებს კონკრეტული ოჯახისთვის აბსტრაქტული პროდუქტების შექმნის ოპერაციებს.
3. Abstract Product: გამოაცხადებს პროდუქტის ტიპის ინტერფეისს.
4. Concrete Product: ახორციელებს Abstract Product-ის ინტერფეისს კონკრეტული პროდუქტისთვის.
5. Client: იყენებს Abstract Factory და Abstract Product ინტერფეისებს, მაგრამ არ იცის Concrete Factory და Concrete Product-ების შესახებ.

შესრულება:

• განისაზღვრება აბსტრაქტული ფაბრიკა, რომელიც შეიცავს თითოეული ტიპის პროდუქტის შექმნის მეთოდებს.
• თითოეულ პროდუქტს ოჯახისთვის ქმნის კონკრეტული ფაბრიკა, რომელიც ახორციელებს აბსტრაქტული ფაბრიკის მეთოდებს და ქმნის შესაბამის კონკრეტულ პროდუქტებს.
• თითოეულ პროდუქტის ტიპისთვის განსაზღვრულია აბსტრაქტული პროდუქტის ინტერფეისი.
• თითოეულ კონკრეტულ პროდუქტისთვის შექმნილია კლასი, რომელიც ახორციელებს შესაბამის პროდუქტის ინტერფეისს.
• კლიენტური კოდი იღებს აბსტრაქტული ფაბრიკის ობიექტს და ახორციელებს მისი მეთოდების გამოძახებას პროდუქტის შექმნისთვის, მუშაობს მხოლოდ პროდუქტის ინტერფეისებთან.

// აბსტრაქტული ფაბრიკა
public interface IAbstractFactory
{
    IAbstractProductA CreateProductA();
    IAbstractProductB CreateProductB();
}

// კონკრეტული ფაბრიკა 1
public class ConcreteFactory1 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA1();
    }

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

// კონკრეტული ფაბრიკა 2
public class ConcreteFactory2 : IAbstractFactory
{
    public IAbstractProductA CreateProductA()
    {
        return new ConcreteProductA2();
    }

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

// აბსტრაქტული პროდუქტი A
public interface IAbstractProductA
{
    string UsefulFunctionA();
}

// კონკრეტული პროდუქტი A1
public class ConcreteProductA1 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "The result of the product A1.";
    }
}

// კონკრეტული პროდუქტი A2
public class ConcreteProductA2 : IAbstractProductA
{
    public string UsefulFunctionA()
    {
        return "The result of the product A2.";
    }
}

// აბსტრაქტული პროდუქტი B
public interface IAbstractProductB
{
    string UsefulFunctionB();
    string AnotherUsefulFunctionB(IAbstractProductA collaborator);
}

// კონკრეტული პროდუქტი B1
public class ConcreteProductB1 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "The result of the product B1.";
    }

    // B1 პროდუქტი მხოლოდ იმავე ვარიანტის A პროდუქტებთან მუშაობს
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"The result of the B1 collaborating with the ({result})";
    }
}

// კონკრეტული პროდუქტი B2
public class ConcreteProductB2 : IAbstractProductB
{
    public string UsefulFunctionB()
    {
        return "The result of the product B2.";
    }

    // B2 პროდუქტი მხოლოდ იმავე ვარიანტის A პროდუქტებთან მუშაობს
    public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
    {
        var result = collaborator.UsefulFunctionA();
        return $"The result of the B2 collaborating with the ({result})";
    }
}

// კლიენტური კოდი
public class Client
{
    public void Main()
    {
        // კლიენტური კოდი მუშაობს აბსტრაქტულ ფაბრიკასთან
        Console.WriteLine("Client: Testing client code with the first factory type:");
        ClientMethod(new ConcreteFactory1());
        Console.WriteLine();

        Console.WriteLine("Client: Testing the same client code with the second factory type:");
        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));
    }
}