C#实现产品生产统一管理

定义接口 IProductionFactory，包含生产鸭脖和鸭翅的方法。
定义类 WuhanFactory、NanjingFactory、ChangshaFactory 分别实现接口 IProductionFactory，用于具体的生产工厂。
使用委托 ProductionDelegate 定义生产委托。
在 Main 函数中，创建不同工厂的实例，并通过生产委托进行生产。

3 主要思路

3.1定义接口

定义接口 IProductionFactory，包含生产鸭脖和鸭翅的方法。

接口：

接口的语法结构：

[访问修饰符] interface 接口标识符 [:基接口列表]

{

接口体；

}

接口成员访问权限为public，但不能加访问修饰符
接口成员不能有定义
接口的成员必须是方法，属性，事件或索引器，不能包含常数、字段、运算符、实例构造函数、析构函数或类型。

// 定义接口 IProductionFactory
public interface IProductionFactory
{
    void ProduceDuckNeck();//生产鸭脖
    void ProduceDuckWing();//生产鸭翅
}

3.2定义类

定义类 WuhanFactory、NanjingFactory、ChangshaFactory 分别实现接口 IProductionFactory，用于具体的生产工厂。

接口实现：

类要继承某个接口用“:”，在类的定义中给出接口中所定义方法的实际实现。
除显示实现接口外，类中接口实现必须显示声明为public。

// 武汉工厂
public class WuhanFactory : IProductionFactory
{
    public void ProduceDuckNeck()
    {
        Console.WriteLine("武汉工厂生产鸭脖");
    }

    public void ProduceDuckWing()
    {
        Console.WriteLine("武汉工厂生产鸭翅");
    }
}

// 南京工厂
public class NanjingFactory : IProductionFactory
{
    public void ProduceDuckNeck()
    {
        Console.WriteLine("南京工厂不能生产鸭脖");
    }

    public void ProduceDuckWing()
    {
        Console.WriteLine("南京工厂生产鸭翅");
    }
}

// 长沙工厂
public class ChangshaFactory : IProductionFactory
{
    public void ProduceDuckNeck()
    {
        Console.WriteLine("长沙工厂生产鸭脖");
    }

    public void ProduceDuckWing()
    {
        Console.WriteLine("长沙工厂不能生产鸭翅");
    }
}

3.3定义委托

使用委托 ProductionDelegate 定义生产委托。

委托：

委托的语法结构：

[访问修饰符] delegate [委托类型] 委托名(参数)

C# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。委托（Delegate） 是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。
委托（Delegate）特别用于实现事件和回调方法

public delegate void ProductionDelegate(IProductionFactory factory);

这是一个C#中的委托定义，名为ProductionDelegate，它接受一个实现了IProductionFactory接口的对象作为参数，并且没有返回值。这个委托可以用于将生产方法作为参数传递给其他方法或存储在数据结构中。

3.4创建实例

在 Main 函数中，创建不同工厂的实例，并通过生产委托进行生产。

接口使用：

接口由类实现后，接口成员可以通过对象实例访问，就好像是类的成员一样。

 // 创建不同工厂的实例 
WuhanFactory wuhanFactory = new WuhanFactory();
NanjingFactory nanjingFactory = new NanjingFactory();
ChangshaFactory changshaFactory = new ChangshaFactory();

 // 通过生产委托进行生产
ProductionDelegate productionDelegate = (factory) =>
{
    factory.ProduceDuckNeck();
    factory.ProduceDuckWing();
};//使用Lambda表达式定义的ProductionDelegate委托实例

productionDelegate(wuhanFactory);
productionDelegate(nanjingFactory);
productionDelegate(changshaFactory);

这段代码定义了一个名为productionDelegate的委托实例，它接受一个实现了IProductionFactory接口的对象作为参数。然后，通过Lambda表达式来定义这个委托实例的行为，即调用传入对象的ProduceDuckNeck()和ProduceDuckWing()方法。

接下来，使用productionDelegate委托实例分别对三个工厂对象（wuhanFactory、nanjingFactory和changshaFactory）进行操作。由于这三个工厂对象都实现了IProductionFactory接口，因此它们都可以作为参数传递给productionDelegate委托实例。

当调用productionDelegate(wuhanFactory)时，将会执行wuhanFactory.ProduceDuckNeck()和wuhanFactory.ProduceDuckWing()方法；同样地，调用productionDelegate(nanjingFactory)和productionDelegate(changshaFactory)也会执行相应工厂对象的生产方法。

这样，通过使用Lambda表达式定义的委托实例，可以方便地将不同的生产方法作为参数传递给其他方法或存储在数据结构中，从而实现多态的效果。

4 实验难点

4.1接口

接口是一种规范，它定义了一组方法和属性，实现该接口的类需要实现这些方法和属性。在这个实验中，我们定义了一个接口 IProductionFactory，它包含了生产鸭脖和鸭翅的方法。然后，我们分别定义了三个工厂类 WuhanFactory、NanjingFactory 和 ChangshaFactory，它们都实现了 IProductionFactory 接口，并实现相应的生产方法。

4.2委托

委托是一种类型，它可以封装方法，使得可以将方法作为参数传递给其他方法或存储在数据结构中。在这个实验中，我们需要定义一个委托 ProductionDelegate，它接受一个实现了 IProductionFactory 接口的对象作为参数，并调用该对象的 ProduceDuckNeck 和 ProduceDuckWing 方法。

4.3多态

多态是指同一个方法在不同对象上具有不同的行为。在这个实验中，我们通过委托 ProductionDelegate 调用不同工厂的生产方法，实现了多态的效果。

4.4Lambda表达式

在C#中，Lambda表达式的一般格式如下：

(parameters) => expression

或者

(parameters) => { statements; }

其中parameters是输入参数，expression是一个表达式，而statements是一组语句块。如果Lambda表达式的主体只有一条语句，那么花括号是可选的；如果有多条语句，则需要使用花括号。

例如，之前提到的ProductionDelegate委托可以使用Lambda表达式来实例化

ProductionDelegate productionDelegate = (factory) =>

{
    factory.ProduceDuckNeck(); 
    factory.ProduceDuckWing(); 
};

这里，(factory)是参数列表，而花括号内包含了两个方法调用，它们是Lambda表达式的主体。

5 实现代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Wintest3
{
    // 定义接口 IProductionFactory
    public interface IProductionFactory
    {
        void ProduceDuckNeck();
        void ProduceDuckWing();
    }

    // 武汉工厂
    public class WuhanFactory : IProductionFactory
    {
        public void ProduceDuckNeck()
        {
            Console.WriteLine("武汉工厂生产鸭脖");
        }

        public void ProduceDuckWing()
        {
            Console.WriteLine("武汉工厂生产鸭翅");
        }
    }

    // 南京工厂
    public class NanjingFactory : IProductionFactory
    {
        public void ProduceDuckNeck()
        {
            Console.WriteLine("南京工厂不能生产鸭脖");
        }

        public void ProduceDuckWing()
        {
            Console.WriteLine("南京工厂生产鸭翅");
        }
    }

    // 长沙工厂
     public class ChangshaFactory : IProductionFactory
    {
        public void ProduceDuckNeck()
        {
            Console.WriteLine("长沙工厂生产鸭脖");
        }

        public void ProduceDuckWing()
        {
            Console.WriteLine("长沙工厂不能生产鸭翅");
        }
    }

    public delegate void ProductionDelegate(IProductionFactory factory);
   
    internal class Program
    {
        static void Main(string[] args)
        {
            // 创建不同工厂的实例
            WuhanFactory wuhanFactory = new WuhanFactory();
            NanjingFactory nanjingFactory = new NanjingFactory();
            ChangshaFactory changshaFactory = new ChangshaFactory();

            // 通过生产委托进行生产
            ProductionDelegate productionDelegate = (factory) =>
            {
                factory.ProduceDuckNeck();
                factory.ProduceDuckWing();
            };//使用Lambda表达式定义的ProductionDelegate委托实例

            productionDelegate(wuhanFactory);
            productionDelegate(nanjingFactory);
            productionDelegate(changshaFactory);

            Console.ReadLine();
        }
    }
}