using System;

​

// Declare abstract product interface

public interface IAbstractChair {

  string FunctionOfChair();

}

public interface IAbstractTable {

  string FunctionOfTable();

}

// Implement concrete products

class ModerChair: IAbstractChair {

  public string FunctionOfChair() {

    return "Function of Modern Chair";

  }

}

class VictorianChair: IAbstractChair {

  public string FunctionOfChair() {

    return "Function of Victorian Chair";

  }

}

class ModerTable: IAbstractTable {

  public string FunctionOfTable() {

    return "Function of Modern Table";

  }

}

class VictorianTable: IAbstractTable {

  public string FunctionOfTable() {

    return "Function of Victorian Table";

  }

}

// Declare abstract factory interface

public interface IFurnitureFactory {

  IAbstractChair CreateChair();

  IAbstractTable CreateTable();

}

// Implement concrete factories

class ModernFactory: IFurnitureFactory {

  public IAbstractChair CreateChair() {

    return new ModerChair();

  }

​

  public IAbstractTable CreateTable() {

    return new ModerTable();

  }

}

class VictorianFactory: IFurnitureFactory {

  public IAbstractChair CreateChair() {

    return new VictorianChair();

  }

​

  public IAbstractTable CreateTable() {

    return new VictorianTable();

  }

}

​

// Main program

class Client {

  public void ClientExecution() {

    Console.WriteLine("Client: Testing client code with the first factory type...");

    ClientMethod(new ModernFactory());

    Console.WriteLine();

​

    Console.WriteLine("Client: Testing the same client code with the second factory type...");

    ClientMethod(new VictorianFactory());

  }

​

  public void ClientMethod(IFurnitureFactory factory) {

    var chair = factory.CreateChair();

    var table = factory.CreateTable();

​

    Console.WriteLine(chair.FunctionOfChair());

    Console.WriteLine(table.FunctionOfTable());

  }

}

​

public class Program {

  public static void Main() {

    new Client().ClientExecution();

  }

}