【C#】实现对周黑鸭工厂的产品生产统一管理（windows程序设计课程作业一）

乌杨

已于 2024-04-09 15:03:31 修改

阅读量1k

点赞数 32

文章标签： c# 开发语言

于 2024-04-08 14:12:28 首次发布

本文链接：https://blog.csdn.net/a25106_/article/details/137481042

版权

本文详细介绍了如何使用C#通过接口IProductionFactory、工厂类WuhanFactory、NanjingFactory和ChangshaFactory以及委托ProductionDelegate，来统一管理周黑鸭工厂的鸭脖和鸭翅生产。重点讨论了接口设计、工厂角色和异常处理的运用。

摘要由CSDN通过智能技术生成

一、作业内容

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

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

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

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

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

二、基本思路

1. 定义了一个周黑鸭工厂生产产品的接口IProductionFactory，它包含两个方法ProduceDuckNeck和ProduceDuckWing，分别用于生产鸭脖和鸭翅。

2.定义了三个不同的工厂类：WuhanFactory、NanjingFactory和ChangshaFactory。每个工厂类都实现了IProductionFactory接口中的ProduceDuckNeck和ProduceDuckWing方法，分别用于生产该工厂能生产的鸭脖或鸭翅。

3. 定义了一个委托ProductionDelegate，用于生成不同的生产委托。

4. 在 Main 函数中，创建不同的工厂对象，通过不同的生产委托调用相应的方法，同时使用 try...catch 处理出现的NotSupportedException异常。

三、难点

1. 接口IProductionFactory的定义，接口定义了ProduceDuckNeck和ProduceDuckWing两个方法，这意味着所有实现该接口的工厂类都必须能够处理这两种产品的生产。然而，在我们定义的工厂类中，不同的工厂具有不同的生产能力，有些工厂只能生产鸭脖，有些只能生产鸭翅，有些工厂可能两者都能生产。因此。在工厂类调用接口时，使用了NotSupportedException异常，如果接口的使用者没有正确处理这些异常，可能会导致程序崩溃或产生不可预期的行为。

2. 委托的正确使用，使用委托可以动态地绑定到方法，这增加了代码的灵活性。

3. 使用委托调用方法时，需要特别注意错误处理。如果委托绑定的方法在执行过程中抛出异常，那么调用委托的代码需要能够捕获并处理这些异常。在下面的代码中，njN()和csW()的调用可能会抛出NotSupportedException，这需要调用者使用try-catch块来捕获并处理。

四、代码实现

1. 接口定义 IProductionFactory

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

说明：定义了一个名为IProductionFactory的接口，它包含两个方法ProduceDuckNeck和ProduceDuckWing，分别用于生产鸭脖和鸭翅。接口为不同的工厂类提供了一个统一的规范，使得客户端代码可以无差别地调用这些工厂的方法。

2. 定义工厂类

(1) 武汉工厂 WuhanFactory

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

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

说明：WuhanFactory类实现了IProductionFactory接口，提供了生产鸭脖和鸭翅的具体实现。

(2) 南京工厂 NanjingFactory

// 南京工厂只能生产鸭翅
public class NanjingFactory : IProductionFactory
{
    public void ProduceDuckNeck()
    {
        throw new NotSupportedException("南京工厂不能生产鸭脖");
    }

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

说明：NanjingFactory类也实现了IProductionFactory接口，但它不能生产鸭脖，因此在ProduceDuckNeck方法中抛出了NotSupportedException异常。NotSupportedException异常通常表示尝试执行的操作或使用的功能在当前上下文中不受支持。

（3）长沙工厂 ChangshaFactory

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

    public void ProduceDuckWing()
    {
        throw new NotSupportedException("长沙工厂不能生产鸭翅");
    }
}

说明：ChangshaFactory类实现了IProductionFactory接口，但它不能生产鸭翅，因此在ProduceDuckWing方法中抛出了NotSupportedException异常。

3. 委托定义

public delegate void ProductionDelegate();

说明：定义了一个名为ProductionDelegate的委托，它表示一个无参数、无返回值的方法。委托用于存储方法的引用，可以在不直接调用方法的情况下，通过委托来间接调用方法，增加了代码的灵活性和可维护性。

4. main函数

（1）创建不同的工厂实例

 IProductionFactory whF = new WuhanFactory();
 IProductionFactory njF = new NanjingFactory();
 IProductionFactory csF = new ChangshaFactory();

（2）创建不同的生产委托

ProductionDelegate whN = whF.ProduceDuckNeck;
ProductionDelegate njN = njF.ProduceDuckNeck;
ProductionDelegate csN = csF.ProduceDuckNeck;

ProductionDelegate whW = whF.ProduceDuckWing;
ProductionDelegate njW = njF.ProduceDuckWing;
ProductionDelegate csW = csF.ProduceDuckWing;

（3）调用工厂方法的委托，处理可能出现的异常

try
{
    whN(); // 武汉工厂生产鸭脖  
    njN(); // 南京工厂尝试生产鸭脖，会抛出异常  
}
catch (NotSupportedException ex)
{
    Console.WriteLine(ex.Message); // 输出不支持操作的消息  
}

try
{
    csN(); // 长沙工厂生产鸭脖  
}
catch (NotSupportedException ex)
{
    // 这个catch块实际上不会被执行，因为长沙工厂能生产鸭脖  
    Console.WriteLine(ex.Message);
}

whW(); // 武汉工厂生产鸭翅  
njW(); // 南京工厂生产鸭翅  

try
{
    csW(); // 长沙工厂尝试生产鸭翅，会抛出异常  
}
catch (NotSupportedException ex)
{
    Console.WriteLine(ex.Message); // 输出不支持操作的消息  
}
Console.WriteLine("生产操作完成。");

说明：展示了如何使用委托来间接调用不同工厂的方法，并在调用过程中处理可能发生的异常。调用whN()方法：这代表武汉工厂生产鸭脖。由于武汉工厂具备生产鸭脖的能力，这个调用将成功执行，不会抛出任何异常。调用njN()方法：这代表南京工厂尝试生产鸭脖。由于南京工厂不支持生产鸭脖，这个调用会抛出NotSupportedException异常。这个异常被try-catch块捕获，并输出异常消息。调用csN()方法：这代表长沙工厂生产鸭脖。长沙工厂具备生产鸭脖的能力，因此这个调用将成功执行，不会抛出异常。由于不会抛出异常，第二个try-catch块中的代码实际上不会被执行。调用whW()方法：这代表武汉工厂生产鸭翅。同样，武汉工厂具备生产鸭翅的能力，这个调用将成功执行。调用njW()方法：这代表南京工厂生产鸭翅。南京工厂支持生产鸭翅，因此这个调用也会成功执行。调用csW()方法：这代表长沙工厂尝试生产鸭翅。长沙工厂不支持生产鸭翅，因此这个调用会抛出NotSupportedException异常。这个异常同样被try-catch块捕获，并输出异常消息。

五、运行结果

六、小结

通过本次的作业，我主要学习了C#语言中接口、工厂类和委托的使用，以及如何通过委托来间接调用工厂类的方法，并在调用过程中处理可能发生的异常。通过这段代码，我们可以看到接口和委托在面向对象编程中的重要作用。接口定义了工厂类应该具备的方法，使得我们可以编写与具体工厂类无关的代码。委托则提供了一种灵活的方式来间接调用方法，使得我们可以在运行时动态地改变方法的调用行为。同时，异常处理机制确保了程序在发生错误时能够优雅地处理并继续执行。

七、完整代码

using System;

namespace ZhouheiyaFactory
{
    // 定义生产接口  
    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()
        {
            throw new NotSupportedException("南京工厂不能生产鸭脖");
        }

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

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

        public void ProduceDuckWing()
        {
            throw new NotSupportedException("长沙工厂不能生产鸭翅");
        }
    }

    public delegate void ProductionDelegate();
    internal class Program
    {
        static void Main(string[] args)
        {
            IProductionFactory whF = new WuhanFactory();
            IProductionFactory njF = new NanjingFactory();
            IProductionFactory csF = new ChangshaFactory();

            ProductionDelegate whN = whF.ProduceDuckNeck;
            ProductionDelegate njN = njF.ProduceDuckNeck;
            ProductionDelegate csN = csF.ProduceDuckNeck;

            ProductionDelegate whW = whF.ProduceDuckWing;
            ProductionDelegate njW = njF.ProduceDuckWing;
            ProductionDelegate csW = csF.ProduceDuckWing;

            try
            {
                whN(); // 武汉工厂生产鸭脖  
                njN(); // 南京工厂尝试生产鸭脖，会抛出异常  
            }
            catch (NotSupportedException ex)
            {
                Console.WriteLine(ex.Message); // 输出不支持操作的消息  
            }

            try
            {
                csN(); // 长沙工厂生产鸭脖  
            }
            catch (NotSupportedException ex)
            {
                // 这个catch块实际上不会被执行，因为长沙工厂能生产鸭脖  
                Console.WriteLine(ex.Message);
            }

            whW(); // 武汉工厂生产鸭翅  
            njW(); // 南京工厂生产鸭翅  

            try
            {
                csW(); // 长沙工厂尝试生产鸭翅，会抛出异常  
            }
            catch (NotSupportedException ex)
            {
                Console.WriteLine(ex.Message); // 输出不支持操作的消息  
            }
            Console.WriteLine("生产操作完成。");
            Console.ReadLine();
        }
    }
}