windows程序设计课程作业周黑鸭工厂

0 作业内容

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

1代码实现

1.1定义接口

定义接口 IProductionFactory，分别是生产鸭脖和鸭翅的方法。 

public interface IProductionFactory
{
    void ProduceDuckNecks();
    void ProduceDuckWings();
}

1.2定义具体的类

1.2.1武汉工厂（鸭脖，鸭翅） 

public class WuhanFactory : IProductionFactory  
{  
    public void ProduceDuckNeck()  
    {  
        Console.WriteLine("Wuhan Factory is producing Duck Neck.");  
        //在此处可以对duckneck进行实例化并进行生产操作  
    }  
  
    public void ProduceDuckWing()  
    {  
        Console.WriteLine("Wuhan Factory is producing Duck Wing."); 
        //  在此处可以对duckwing进行实例化并进行生产操作}  
}  

 1.2.2南京工厂（鸭翅）

public class NanjingFactory : IProductionFactory  
{  
    public void ProduceDuckNeck()  
    {  
        throw new NotSupportedException("Nanjing Factory does not produce Duck Neck.");
        //对不能进行加工的鸭翅部分进行抛异常处理  
    }  
  
    public void ProduceDuckWing()  
    {  
        Console.WriteLine("Nanjing Factory is producing Duck Wing.");  
        // 这里可以实例化 DuckWing 并进行生产操作  
    }  
}  

1.2.3长沙工厂（鸭脖）

public class ChangshaFactory : IProductionFactory  
{  
    public void ProduceDuckNeck()  
    {  
        Console.WriteLine("Changsha Factory is producing Duck Neck.");  
        // 这里可以实例化 DuckNeck 并进行生产操作  
    }  
  
    public void ProduceDuckWing()  
    {  
        throw new NotSupportedException("Changsha Factory does not produce Duck Wing.");
        //对不能生产的鸭翅部分进行抛异常处理  
    }  
}  

1.3定义委托

public delegate void ProductionDelegate();

2 具体实现

internal class Program
    {
 
        static void Main(string[] args)
        {
 
            try
            {
                // 实例化工厂并测试生产    
                IProductionFactory wuhanFactory = new WuhanFactory();
                wuhanFactory.ProduceDuckNecks();
                wuhanFactory.ProduceDuckWings();
 
                IProductionFactory nanjingFactory = new NanjingFactory();
                nanjingFactory.ProduceDuckWings();
                try
                {
                    nanjingFactory.ProduceDuckNecks(); // 注意：尝试生产鸭脖将会抛出异常    
                }
                catch (NotSupportedException ex)
                {
                    Console.WriteLine("Nanjing Factory does not produce Duck Neck: " + ex.Message);
                }
 
                IProductionFactory changshaFactory = new ChangshaFactory();
                changshaFactory.ProduceDuckNecks();
                try
                {
                    changshaFactory.ProduceDuckWings(); // 注意：尝试生产鸭翅将会抛出异常    
                }
                catch (NotSupportedException ex)
                {
                    Console.WriteLine("Changsha Factory does not produce Duck Wing: " + ex.Message);
                }
 
                // 使用委托来封装生产动作    
                ProductionDelegate produceDuckNecksDelegate = new ProductionDelegate(wuhanFactory.ProduceDuckNecks);
                produceDuckNecksDelegate.Invoke();
 
                ProductionDelegate produceDuckWingsDelegate = new ProductionDelegate(nanjingFactory.ProduceDuckWings);
                produceDuckWingsDelegate.Invoke();
            }
            catch (Exception ex)
            {
                // 捕获其他未处理的异常  
                Console.WriteLine("An unhandled exception occurred: " + ex.Message);
            }
 
            Console.ReadLine();
        }
 
    }
    }
    

3 运行结果

3.1正常运行结果

3.2抛出异常运行结果

4小结

难点之一是委托的使用。委托是一种类型安全的函数指针，可以用来封装方法作为参数传递或赋值给变量。在本例中，我们使用委托来封装工厂的生产方法，并通过委托来调用这些方法。另一个难点是接口的实现。接口是一种规范，定义了类应该具有的方法或属性。在本例中，我们定义了一个生产接口，并要求所有工厂类都实现这个接口。这确保了每个工厂都具备生产鸭脖和鸭翅的能力（虽然有些工厂可能只实现了部分方法）。

5完整代码

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

public interface IProductionFactory
{
    void ProduceDuckNecks();
    void ProduceDuckWings();
}

namespace duckproduct
{

    public class WuhanFactory : IProductionFactory
    {
        public void ProduceDuckNecks()
        {
            Console.WriteLine("Wuhan Factory is producing Duck Neck.");
            //在此处可以对duckneck进行实例化并进行生产操作  
        }

        public void ProduceDuckWings()
        {
            Console.WriteLine("Wuhan Factory is producing Duck Wing.");
            //  在此处可以对duckwing进行实例化并进行生产操作}  
        }
    }
    public class NanjingFactory : IProductionFactory
    {
        public void ProduceDuckNecks()
        {
            throw new NotSupportedException("Nanjing Factory does not produce Duck Neck.");
            //对不能进行加工的鸭翅部分进行抛异常处理  
        }

        public void ProduceDuckWings()
        {
            Console.WriteLine("Nanjing Factory is producing Duck Wing.");
            // 这里可以实例化 DuckWing 并进行生产操作  
        }
    }
    public class ChangshaFactory : IProductionFactory
    {
        public void ProduceDuckNecks()
        {
            Console.WriteLine("Changsha Factory is producing Duck Neck.");
            // 这里可以实例化 DuckNeck 并进行生产操作  
        }

        public void ProduceDuckWings()
        {
            throw new NotSupportedException("Changsha Factory does not produce Duck Wing.");
            //对不能生产的鸭翅部分进行抛异常处理  
        }
    }
    public delegate void ProductionDelegate();

    internal class Program
    {

        static void Main(string[] args)
        {

            try
            {
                // 实例化工厂并测试生产    
                IProductionFactory wuhanFactory = new WuhanFactory();
                wuhanFactory.ProduceDuckNecks();
                wuhanFactory.ProduceDuckWings();

                IProductionFactory nanjingFactory = new NanjingFactory();
                nanjingFactory.ProduceDuckWings();
                try
                {
                   nanjingFactory.ProduceDuckNecks(); // 注意：尝试生产鸭脖将会抛出异常    
                }
                catch (NotSupportedException ex)
                {
                    Console.WriteLine("Nanjing Factory does not produce Duck Neck: " + ex.Message);
                }

                IProductionFactory changshaFactory = new ChangshaFactory();
                changshaFactory.ProduceDuckNecks();
                try
                {
                   changshaFactory.ProduceDuckWings(); // 注意：尝试生产鸭翅将会抛出异常    
                }
               catch (NotSupportedException ex)
                {
                    Console.WriteLine("Changsha Factory does not produce Duck Wing: " + ex.Message);
               }

                // 使用委托来封装生产动作    
                ProductionDelegate produceDuckNecksDelegate = new ProductionDelegate(wuhanFactory.ProduceDuckNecks);
                produceDuckNecksDelegate.Invoke();

               ProductionDelegate produceDuckWingsDelegate = new ProductionDelegate(nanjingFactory.ProduceDuckWings);
                produceDuckWingsDelegate.Invoke();
            }
            catch (Exception ex)
            {
                // 捕获其他未处理的异常  
                Console.WriteLine("An unhandled exception occurred: " + ex.Message);
            }

            Console.ReadLine();
        }

    }
}