windows程序设计课程作业一：使用 C# 编码（涉及类、接口、委托等关键知识点），实现对周黑鸭工厂的产品生产统一管理 。

目录

一、功能说明

二、类、接口、委托三个关键知识点（如需详细学习，请参考其他文章）

 1、类的使用

 2、接口的使用

3、委托的使用

三、关键源码展示+讲解

1、定义接口 IProductionFactory

 2、定义类 WuhanFactory

3、定义类NanjingFactory

4、定义类ChangshaFactory

5、定义生产委托

6、主函数

四、源码

五、结果测试图片

六、难点

---

一、功能说明

        使用 C# 编码（涉及类、接口、委托等关键知识点），实现对周黑鸭工厂的产品生产统一管理，主要产品包括鸭脖和鸭翅。武汉工厂能生生产鸭脖和鸭翅，南京工厂只能生产鸭翅，长沙工厂只能生产鸭脖。具体要求如下：

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

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

（3）使用委托 ProductionDelegate 定义生产委托。在 Main 函数中，创建不同工厂的实例，并通过生产委托进行生产。

二、类、接口、委托三个关键知识点（如需详细学习，请参考其他文章）

 1、类的使用

类的定义：类使用class关键字定义，后面跟着类名。类名通常遵循PascalCasing（首字母大写，每个单词的首字母也大写）的命名约定。

class MyClass  
{  
    // 类的成员  
}

类的成员：类可以包含以下类型的成员：

• 字段：存储数据。
• 属性：提供字段的访问和修改。
• 方法：执行特定的操作。
• 事件：通知其他对象当某些特殊事情发生时。
• 嵌套类：在类内部定义的类。
• 常量：表示不可变的值。
• 索引器：允许对象像数组一样进行索引。
• 运算符重载：为自定义类型定义运算符的行为。
• 构造函数和析构函数：用于对象的初始化和清理。

 2、接口的使用

接口的定义：接口使用interface关键字来定义，后面跟着接口的名称。接口名称通常遵循PascalCasing的命名约定。

interface IMyInterface  
{  
    // 成员声明  
}

接口的成员：接口可以包含以下几种类型的成员：

• 方法：只声明方法签名，不包含方法体。
• 属性：只声明属性的访问器签名。
• 事件：声明事件的类型。
• 索引器：声明索引器的签名

interface IMyInterface  
{  
    void MyMethod();  
    int MyProperty { get; set; }  
    event Action MyEvent;  
    int this[int index] { get; set; }  
}

 实现接口：一个类可以使用冒号(:)后跟接口名称的列表来实现一个或多个接口。实现接口的类必须提供接口中声明的所有成员的具体实现。

class MyClass : IMyInterface  
{  
    // 实现接口中的所有方法、属性、事件和索引器  
    public void MyMethod()  
    {  
        // 方法实现  
    }  
  
    public int MyProperty  
    {  
        get { return _myProperty; }  
        set { _myProperty = value; }  
    }  
  
    private int _myProperty;  
  
    public event Action MyEvent;  
  
    public int this[int index]  
    {  
        get { /* 索引器实现 */ }  
        set { /* 索引器实现 */ }  
    }  
}

接口的继承：一个接口可以继承自一个或多个其他接口，从而组合多个接口的成员。

interface IAnotherInterface  
{  
    void AnotherMethod();  
}  
  
interface ICombinedInterface : IMyInterface, IAnotherInterface  
{  
    // 可以添加更多成员，或者只继承成员  
}

接口的使用：通过接口，你可以创建对象的引用，这些对象可以是任何实现了该接口的类的实例。这使得代码更加灵活，因为你可以将接口引用指向任何实现该接口的类。

IMyInterface myObject = new MyClass(); // MyClass实现了IMyInterface接口  
myObject.MyMethod(); // 调用接口方法

3、委托的使用

创建委托实例：你可以将一个与委托签名匹配的方法赋值给委托变量。

MyDelegate myDelegate = MyMethod; // 假设MyMethod是一个无参数且返回void的方法

调用委托：调用委托实例就像调用方法一样。

myDelegate(); // 调用MyMethod方法

委托的链式调用：你可以将多个方法赋值给同一个委托，并依次调用它们（称为委托的多播）。

MyDelegate anotherDelegate = AnotherMethod; // 另一个匹配的方法  
myDelegate += anotherDelegate; // 将AnotherMethod添加到委托的调用列表中  
myDelegate(); // 将依次调用MyMethod和AnotherMethod

移除委托：你可以从委托的调用列表中移除之前添加的方法。

myDelegate -= anotherDelegate; // 从委托中移除AnotherMethod

委托作为参数和返回值：委托可以作为方法的参数或返回值，从而实现回调机制和高度的灵活性。

public void ExecuteWithDelegate(MyDelegate del)  
{  
    del(); // 执行传入的委托  
}

委托与Lambda表达式：Lambda表达式常用于创建委托实例，它们提供了一种简洁的方式来表示匿名方法。

MyDelegate lambdaDelegate = () => Console.WriteLine("Lambda expression invoked.");  
lambdaDelegate(); // 输出 "Lambda expression invoked."

内置委托类型：C#还提供了一些内置的委托类型，如Action和Func，它们用于表示没有返回值的方法（Action）和返回特定类型值的方法（Func）。

// 使用Action委托，它表示没有参数且没有返回值的方法  
Action action = () => Console.WriteLine("Action invoked.");  
action(); // 输出 "Action invoked."  
  
// 使用Func委托，它表示接受一个int参数并返回int的方法  
Func<int, int> func = x => x * 2;  
int result = func(5); // result为10

三、关键源码展示+讲解

1、定义接口 IProductionFactory

    包含生产鸭脖和鸭翅的方法

• interface IProdutionFactory：这一行声明了一个名为 IProdutionFactory 的接口。接口定义了一组方法，这些方法由实现接口的类来实现。
• void CreateYaBo();：在接口中声明了一个名为 CreateYaBo 的方法，它没有返回值（void 表示无返回值），这个方法应该由实现接口的类来实现，用于生产鸭脖。
• void CreateYaChi();：同样，这也是一个无返回值的方法声明，名为 CreateYaChi，它应该由实现接口的类来实现，用于生产鸭翅。

    interface IProductionFactory//周黑鸭工厂中鸭脖和鸭翅的生产方法创建接口
    {
        void CreateYaBo();//生产鸭脖
        void CreateYaChi();//生产鸭翅
    }

 2、定义类 WuhanFactory

    实现IProductionFactory，用于具体的生产工厂。

• class WuHanFactory : IProductionFactory：这里声明了一个名为 WuHanFactory 的类，并指定它实现了 IProductionFactory 接口。这意味着 WuHanFactory 类必须提供 IProductionFactory 接口中声明的所有方法的具体实现。

• public void CreateYaBo()：这是 CreateYaBo 方法的实现。当调用这个方法时，它会使用 Console.WriteLine 方法在控制台上输出一条消息，表明是武汉工厂生产的鸭脖。

• public void CreateYaChi()：这是 CreateYaChi 方法的实现。同样，当调用这个方法时，它会使用 Console.WriteLine 方法在控制台上输出一条消息，表明是武汉工厂生产的鸭翅。

     class WuHanFactory : IProductionFactory
    {
        public void CreateYaBo()//武汉工厂制作鸭脖
        {
            Console.WriteLine("武汉工厂生产的鸭脖");
        }
        public void CreateYaChi()//武汉工厂制作鸭翅
        {
            Console.WriteLine("武汉工厂生产的鸭翅");
        }
    }

3、定义类NanjingFactory

    实现IProductionFactory，用于具体的生产工厂。

   注意：南京工厂只生产鸭翅！！！

• class NanJingFactory : IProductionFactory：这里声明了一个名为 NanJingFactory 的类，并指定它实现了 IProductionFactory 接口。这意味着 NanJingFactory 类必须提供 IProductionFactory 接口中声明的所有方法的具体实现。

• public void CreateYaBo()：这是 CreateYaBo 方法的实现。但是，这里并没有实现生产鸭脖的逻辑。相反，它使用 throw 关键字抛出了一个 NotImplementedException 异常。异常信息为“抱歉！！！南京工厂不生产鸭脖”，这表示南京工厂并不具备生产鸭脖的能力。如果调用这个方法，程序会抛出异常并停止执行。

• public void CreateYaChi()：这是 CreateYaChi 方法的实现。当调用这个方法时，它会使用 Console.WriteLine 方法在控制台上输出一条消息，表明是南京工厂生产的鸭翅。

     class NanJingFactory : IProductionFactory
    {
        public void CreateYaBo()//南京工厂制作鸭脖
        {
            throw new NotImplementedException("抱歉！！！南京工厂不生产鸭脖"); 
            //如果尝试调用它们不能生产的产品，将会抛出 NotImplementedException 异常。
        }
        public void CreateYaChi()//南京工厂制作鸭翅
        {
            Console.WriteLine("南京工厂生产的鸭翅");
        }
    }

4、定义类ChangshaFactory

    实现IProductionFactory，用于具体的生产工厂。

    注意：长沙工厂只生产鸭脖！！！

• class ChangShaFactory : IProductionFactory：这里声明了一个名为 ChangShaFactory 的类，并指定它实现了 IProductionFactory 接口。这意味着 ChangShaFactory 类必须提供 IProductionFactory 接口中声明的所有方法的具体实现。

• public void CreateYaBo()：这是 CreateYaBo 方法的实现。它使用了 Console.WriteLine 方法来在控制台上输出一条消息，表明是长沙工厂生产的鸭脖。

• public void CreateYaChi()：这是 CreateYaChi 方法的实现。但是，这个方法中并没有实现生产鸭翅的逻辑，而是使用 throw 关键字抛出了一个 NotImplementedException 异常。异常信息为“抱歉！！！长沙工厂不生产鸭翅”，这表示长沙工厂并不具备生产鸭翅的能力，如果调用这个方法，程序会抛出异常并停止执行。

     class ChangShaFactory : IProductionFactory
    {
        public void CreateYaBo()//长沙工厂制作鸭脖
        {
            Console.WriteLine("长沙工厂生产的鸭脖");
        }
        public void CreateYaChi()//长沙工厂制作鸭翅
        {
            throw new NotImplementedException("抱歉！！！长沙工厂不生产鸭翅"); 
            //如果尝试调用它们不能生产的产品，将会抛出 NotImplementedException 异常。
        }
    }

5、定义生产委托

定义了一个名为 ProductionDelegate 的公共委托。这个委托没有参数，并且不返回任何值（即返回类型为 void）。

  public delegate void ProductionDelegate();
  //定义生产委托

6、主函数

异常处理：

对于不能生产特定产品的工厂（例如 NanJingFactory 不能生产鸭脖，ChangShaFactory 不能生产鸭翅），如果尝试调用相应的方法，会抛出 NotImplementedException 异常。在代码中，这部分被注释掉了，以避免程序运行时出错。

    internal class Program
    {
       
        static void Main(string[] args)
        {
                // 创建工厂实例  
                IProductionFactory WuHanFactory = new WuHanFactory();
                IProductionFactory NanJingFactory = new NanJingFactory();
                IProductionFactory ChangShaFactory = new ChangShaFactory();

            // 武汉工厂可以生产鸭脖和鸭翅  
                ProductionDelegate wuhanyabo = WuHanFactory.CreateYaBo;
                wuhanyabo(); // 调用委托执行方法  
                ProductionDelegate wuhanyachi= WuHanFactory.CreateYaChi;
                wuhanyachi();

                // 南京工厂只能生产鸭翅  
                ProductionDelegate yachi2 = NanJingFactory.CreateYaChi;
                yachi2();

                // 尝试让南京工厂生产鸭脖，这里会抛出异常  
                //ProductionDelegate nanjingyabo = NanJingFactory.CreateYaBo;  
               // nanjingyabo();  

                // 长沙工厂只能生产鸭脖  
                ProductionDelegate changshayabo= ChangShaFactory.CreateYaBo;
                changshayabo();

                // 尝试让长沙工厂生产鸭翅，这里会抛出异常  
                // ProductionDelegate changshayachi= ChangShaFactory.CreateYaChi;  
                //changshayachi();  

                Console.ReadKey();
           
        }

    }

四、源码

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

namespace win实验3
{
    interface IProductionFactory//周黑鸭工厂中鸭脖和鸭翅的生产方法创建接口
    {
        void CreateYaBo();//生产鸭脖
        void CreateYaChi();//生产鸭翅
    }


     class WuHanFactory : IProductionFactory
    {
        public void CreateYaBo()//武汉工厂制作鸭脖
        {
            Console.WriteLine("武汉工厂生产的鸭脖");
        }
        public void CreateYaChi()//武汉工厂制作鸭翅
        {
            Console.WriteLine("武汉工厂生产的鸭翅");
        }
    }

     class NanJingFactory : IProductionFactory
    {
        public void CreateYaBo()//南京工厂制作鸭脖
        {
            throw new NotImplementedException("抱歉！！！南京工厂不生产鸭脖"); 
            //如果尝试调用它们不能生产的产品，将会抛出 NotImplementedException 异常。
        }
        public void CreateYaChi()//南京工厂制作鸭翅
        {
            Console.WriteLine("南京工厂生产的鸭翅");
        }
    }
     class ChangShaFactory : IProductionFactory
    {
        public void CreateYaBo()//长沙工厂制作鸭脖
        {
            Console.WriteLine("长沙工厂生产的鸭脖");
        }
        public void CreateYaChi()//长沙工厂制作鸭翅
        {
            throw new NotImplementedException("抱歉！！！长沙工厂不生产鸭翅"); 
            //如果尝试调用它们不能生产的产品，将会抛出 NotImplementedException 异常。
        }
    }
    public delegate void ProductionDelegate();
    //定义生产委托

    internal class Program
    {
       
        static void Main(string[] args)
        {
                // 创建工厂实例  
                IProductionFactory WuHanFactory = new WuHanFactory();
                IProductionFactory NanJingFactory = new NanJingFactory();
                IProductionFactory ChangShaFactory = new ChangShaFactory();

            // 武汉工厂可以生产鸭脖和鸭翅  
                ProductionDelegate wuhanyabo = WuHanFactory.CreateYaBo;
                wuhanyabo(); // 调用委托执行方法  
                ProductionDelegate wuhanyachi= WuHanFactory.CreateYaChi;
                wuhanyachi();

                // 南京工厂只能生产鸭翅  
                ProductionDelegate yachi2 = NanJingFactory.CreateYaChi;
                yachi2();

                // 尝试让南京工厂生产鸭脖，这里会抛出异常  
                //ProductionDelegate nanjingyabo = NanJingFactory.CreateYaBo;  
               // nanjingyabo();  

                // 长沙工厂只能生产鸭脖  
                ProductionDelegate changshayabo= ChangShaFactory.CreateYaBo;
                changshayabo();

                // 尝试让长沙工厂生产鸭翅，这里会抛出异常  
                // ProductionDelegate changshayachi= ChangShaFactory.CreateYaChi;  
                //changshayachi();  

                Console.ReadKey();
           
        }

    }

   

}

五、结果测试图片

六、难点

难点主要集中在对接口、委托和工厂模式的理解和应用上，以及如何在代码中恰当地处理异常和限制。通过理解这些概念并正确应用它们，可以成功地实现上述代码的功能。