C# 中工厂设计模式的实时示例

2025年03月17日 | 阅读 9 分钟

C# 工厂设计模式实时示例：支付网关集成

using System;
namespace FactoryDesignPattern
{
    //Define the Product Interface
    public interface IPaymentGateway
    {
        void ProcessPayment(decimal amount);
    }

    //Concrete Implementations for the Products
    public class PayPalGateway : IPaymentGateway
    {
        public void ProcessPayment(decimal amount)
        {
            Console.WriteLine($"Processing ${amount} payment through PayPal...");
            // Actual integration and logic for PayPal
        }
    }

    public class StripeGateway : IPaymentGateway
    {
        public void ProcessPayment(decimal amount)
        {
            Console.WriteLine($"Processing ${amount} payment through Stripe...");
            // Actual integration and logic for Stripe
        }
    }
    //Factory Class to Produce the Products
    
            switch (gatewayName.ToLower())
            {
                case "paypal":
                    return new PayPalGateway();
                case "stripe":
                    return new StripeGateway();
                case "creditcard":
                    return new CreditCardGateway();
                default:
                    throw new ArgumentException("Invalid payment gateway specified");
            }
        }
    }
    
    // Testing the Factory Design Pattern
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("Select the payment gateway (PayPal, Stripe, CreditCard): ");
            string gatewayName = Console.ReadLine();
            catch (ArgumentException ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.ReadKey();
        }
    }
}

通过这种架构，为电子商务系统添加新的支付方式非常简单。假设稍后会发布一种新的支付系统，例如比特币。如果是这样，您可以修改 PaymentGatewayFactory 并创建一个新的 BitcoinGateway 类，而无需更改现有的客户端代码。在这种情况下，工厂设计模式通过封装创建过程来确保可伸缩性和可维护性。运行上述代码将产生以下输出。

输出

Real-Time Examples of Factory Design Patterns in C#

C# 工厂设计模式的实时示例：文档转换系统

设想一个程序，允许用户在多种文件类型（如 TXT、PDF 和 DOCX）之间转换文档。该设备将使用用户请求的特定转换器。

using System;
namespace FactoryDesignPattern
{
    //Define the Product Interface
    public interface IDocumentConverter
    {
        string Convert(string content);
        string TargetExtension { get; }
    }

    //Concrete Implementations for the Products
    public class DocxConverter : IDocumentConverter
    {
        public string Convert(string content)
        {
            Console.WriteLine("Converting content to DOCX format...");
            // Logic for DOCX conversion, simplified for this example
            return content + " [Converted to DOCX]";
        }

        public string TargetExtension => ".docx";
    }

    public class PdfConverter : IDocumentConverter
    {
        public string Convert(string content)
        {
            Console.WriteLine("Converting content to PDF format...");
            // Logic for PDF conversion, simplified for this example
            return content + " [Converted to PDF]";
        }

        public string TargetExtension => ".pdf";
    }

    // Testing the Factory Design Pattern
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("Enter the content to convert:");
            string content = Console.ReadLine();

            Console.WriteLine("Select the target format (DOCX, PDF, TXT):");
            string format = Console.ReadLine();

            try
            {
                IDocumentConverter converter = DocumentConverterFactory.CreateDocumentConverter(format);
                string convertedContent = converter.Convert(content);
                Console.WriteLine($"Converted content ({converter.TargetExtension}): {convertedContent}");
            }
            catch (ArgumentException ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.ReadKey();
        }
    }
}

得益于其设计，该系统可以轻松支持新的文档格式。如果稍后发布新格式，例如 RTF，核心逻辑将保持不变；所有需要做的就是实现一个新的 RtfConverter 类并更新 DocumentConverterFactory。工厂设计模式通过确保模块化和关注点分离来促进功能的扩展或修改。运行上述代码将产生以下输出。

输出

C# 工厂设计模式的实时示例：日志记录系统

让我们来看一个实时日志记录系统的示例。许多应用程序需要将消息记录到文件、控制台或远程服务器。通过利用工厂设计模式，我们可以快速切换不同的日志记录方案，并将客户端代码与特定的日志记录器实现分离开来。

using System;

namespace FactoryDesignPattern
{
    //Define the Product Interface
    public interface ILogger
    {
        void Log(string message);
    }

    //Concrete Implementations for the Products
    public class ConsoleLogger : ILogger
    {
        public void Log(string message)
        {
            Console.WriteLine("Console: " + message);
        }
    }

    public class FileLogger : ILogger
    {
        private string _filePath;

        public FileLogger(string filePath)
        {
            _filePath = filePath;
        }

        public void Log(string message)
        {
            File.AppendAllText(_filePath, "File: " + message + Environment.NewLine);
        }
    }

    // You can also add other loggers like DatabaseLogger, CloudLogger, etc.

    //Factory Class to Produce the Products
    public static class LoggerFactory
    {
        public static ILogger CreateLogger(string type)
        {
            switch (type.ToLower())
            {
                case "console":
                    return new ConsoleLogger();
                case "file":
                    return new FileLogger("log.txt"); 
                // For simplicity, file path is hardcoded
                // You can extend here with other logger types
                default:
                    throw new ArgumentException("Invalid logger type");
            }
        }
    }
    
    // Testing the Factory Design Pattern
    public class Program
    {
        public static void Main()
        {
            ILogger logger;

            logger = LoggerFactory.CreateLogger("console");
            logger.Log("This is a console log!");

            logger = LoggerFactory.CreateLogger("file");
            logger.Log("This message is written to a file.");

            // The beauty of this approach is that the client code remains unchanged
            // even if we introduce new logger types in the future.

            Console.ReadKey();
        }
    }
}

在这里，我们通过利用工厂设计模式演示了如何在不修改客户端代码的情况下快速切换日志记录方案。假设稍后会出现一项新需求，例如记录到数据库。然后，我们可以扩展我们的 LoggerFactory 以适应新的日志记录器类型，同时保持客户端代码和现有的日志记录器实现不变。

C# 工厂设计模式的实时示例：一个简单的通知处理系统

让我们研究一个替代的实时场景：一个基本的通知系统。在这种情况下，应用程序可能需要通过推送、短信或电子邮件通知等格式通知用户。

using System;
namespace FactoryDesignPattern
{
    //Define the Product Interface
    public interface INotificationSender
    {
        void SendNotification(string message);
    }

    //Concrete Implementations for the Products
    public class EmailNotification : INotificationSender
    {
        public void SendNotification(string message)
        {
            Console.WriteLine($"Sending EMAIL notification: {message}");
            // Logic to send email here...
        }
    }

    public class PushNotification : INotificationSender
    {
        public void SendNotification(string message)
        {
            Console.WriteLine($"Sending PUSH notification: {message}");
            // Logic to send push notification here...
        }
    }

    //Factory Class to Produce the Products
    public static class NotificationFactory
    {
        public static INotificationSender CreateNotificationSender(string type)
        {
            switch (type.ToLower())
            {
                case "email":
                    return new EmailNotification();
                case "sms":
                    return new SMSNotification();
                case "push":
                    return new PushNotification();
                default:
                    throw new ArgumentException("Invalid notification type");
            }
        }
    }
    
    // Testing the Factory Design Pattern
    public class Program
    {
        public static void Main()
        {
            INotificationSender notificationSender;

            notificationSender = NotificationFactory.CreateNotificationSender("email");
            notificationSender.SendNotification("This is an email notification!");

            notificationSender = NotificationFactory.CreateNotificationSender("sms");
            notificationSender.SendNotification("This is an SMS notification!");

            notificationSender = NotificationFactory.CreateNotificationSender("push");
            notificationSender.SendNotification("This is a push notification!");

            // As with other factory examples, adding new notification methods 
            // would only require extending the factory, without altering the client code.

            Console.ReadKey();
        }
    }
}

在这种实时示例中，工厂设计模式允许我们抽象出创建各种通知发送者的具体细节。因此，如果我们将来需要添加更多通知类型，我们可以轻松地扩展我们的工厂，同时保持客户端代码的原始和一致。运行上述代码将产生以下输出。

输出

C# 工厂设计模式的实时示例：电子商务应用程序中的折扣

让我们再看一个工厂设计模式在实际中全局运行的例子。想象一个在线企业，其中根据不同的情况，各种折扣应用于产品。

using System;
namespace FactoryDesignPattern
{
    //Define the Product Interface
    public interface IDiscountStrategy
    {
        decimal ApplyDiscount(decimal price);
    }

    //Concrete Implementations for the Products
    public class SeasonalDiscount: IDiscountStrategy
    {
        public decimal ApplyDiscount(decimal price)
        {
            return price * 0.90m; // 10% seasonal discount
        }
    }

    public class ClearanceDiscount : IDiscountStrategy
    {
        public decimal ApplyDiscount(decimal price)
        {
            return price * 0.70m; // 30% clearance discount
        }
    }

    public class MemberDiscount : IDiscountStrategy
    {
        public decimal ApplyDiscount(decimal price)
        {
            return price * 0.95m; // 5% member discount
        }
    }

    //Factory Class to Produce the Products
    public static class DiscountFactory
    {
        public static IDiscountStrategy CreateDiscountStrategy(string type)
        {
            switch (type.ToLower())
            {
                case "seasonal":
                    return new SeasonalDiscount();
                case "clearance":
                    return new ClearanceDiscount();
                case "member":
                    return new MemberDiscount();
                default:
                    throw new ArgumentException("Invalid discount type");
            }
        }
    }
    
    // Testing the Factory Design Pattern
    public class Program
    {
        public static void Main()
        {
            IDiscountStrategy discountStrategy;

            decimal originalPrice = 100.0m;

            discountStrategy = DiscountFactory.CreateDiscountStrategy("seasonal");
            Console.WriteLine($"Seasonal Discounted Price: {discountStrategy.ApplyDiscount(originalPrice)}");

            discountStrategy = DiscountFactory.CreateDiscountStrategy("clearance");
            Console.WriteLine($"Clearance Discounted Price: {discountStrategy.ApplyDiscount(originalPrice)}");

            discountStrategy = DiscountFactory.CreateDiscountStrategy("member");
            Console.WriteLine($"Member Discounted Price: {discountStrategy.ApplyDiscount(originalPrice)}");

            Console.ReadKey();
        }
    }
}

有了这个配置，每次添加一种新类型的折扣时，我们都需要扩展 DiscountFactory 并构建一个新的折扣策略类。客户端代码保持不变，无需了解每个折扣的应用方式。这说明了工厂设计模式如何在对象生成方面提供灵活性，并实现清晰的关注点分离。运行上述代码将产生以下输出。

输出

工厂设计模式：C# 中的实时应用

以下是工厂设计模式的一些情况或实际应用：

用户界面控件创建：在具有复杂用户界面的应用程序（如 Windows 窗体或 WPF 应用程序）中，工厂模式可用于根据用户操作或设置动态创建控件（如按钮、文本框或自定义组件）。
数据库访问：在与多个数据库（如 SQL Server、Oracle 或 MySQL）通信的应用程序中，可以使用工厂来实例化正确的数据库连接和命令对象，而不是在业务逻辑中硬编码数据库类型。
日志记录框架：根据应用程序设置或环境，工厂可以为需要日志记录功能的应用程序提供合适的日志记录对象（如文件日志记录器、数据库日志记录器或基于云的日志记录器）。
配置管理：在管理多种配置（如开发、暂存和生产）时，工厂可以构建特定于当前环境的配置对象，并从应用程序的其余部分抽象出这些详细信息。
支付处理系统：在必须通过多个网关（如 PayPal、Stripe 或信用卡）处理付款的系统中，工厂可以根据选择的付款方式实例化适当的付款处理类。
游戏开发：可以根据游戏的当前状态或用户决定，使用工厂模式动态创建角色、武器和其他游戏元素。
插件或模块系统：对于支持插件或模块的程序，工厂模式可以根据用户输入或配置文件实例化相关的插件。
API 集成：在与不同的外部 API（如社交媒体、天气或地理位置服务）集成时，工厂可以根据所需的服务提供适当的 API 客户端。
当对象（如线程或数据库连接）的创建成本很高时，对象池允许工厂有效地管理和重用这些对象。

C# 中工厂设计模式的优势

松耦合：工厂模式将产品的用法和实现分离开来。这意味着客户端代码无需了解如何创建产品的具体细节。
可伸缩性和灵活性：在不修改客户端代码的情况下轻松添加新的具体产品，使应用程序更具可伸缩性和多功能性。
单一职责原则：根据单一职责原则，工厂类包含创建产品的逻辑。代码因此变得更整洁、更有条理。
开放/封闭原则：工厂模式允许您添加新的产品类别，而无需更改现有的工厂或客户端代码，这与开放/封闭原则一致。
处理复杂性：此功能对于开发需要简单实例化以外的功能的对象非常有用，因为它允许您管理和集中复杂的创建逻辑。
实例化控制：工厂可以控制对象创建的过程和时间。例如，在工厂中，您可以使用原型、池和单例模式。

C# 中工厂设计模式的缺点

复杂性：将工厂模式添加到代码中可能会使其更加复杂，特别是当仅对象生成函数已足够时。
间接性：额外的抽象层有时会使代码更难理解和调试，尤其是对于不熟悉该模式的人员。
开销：对于效率是首要考虑因素的应用程序，额外的函数调用和对象创建开销可能是一个缺点。
对工厂的依赖：在创建对象时，客户端代码仍然依赖于工厂，这可能会导致问题，例如在复杂系统中工厂类过多。
重构现有代码：将工厂模式集成到未考虑该模式而创建的现有代码中可能很困难，并且需要大量返工。
需要正确的设计：不正确地使用或应用工厂模式（例如，使用过多的工厂或不正确的抽象）可能会导致维护问题，并使将来的更改更具挑战性。

结论

总之，工厂设计模式是在 C# 编程中实现灵活、可维护对象创建的有效工具。该模式通过将对象创建过程封装在工厂类中，实现了客户端代码和具体类的分离，从而促进了代码的可重用性和可伸缩性。在实际场景中，当需要根据特定情况设计各种形式、形状或其他对象时，工厂设计模式非常有用。开发人员可以通过利用此模式来设计更具模块化和可扩展性的代码，并提高其软件项目的整体质量和可维护性。

下一主题C# 中的 Exception.StackTrace()

C# 中工厂设计模式的实时示例

C# 工厂设计模式实时示例：支付网关集成

C# 工厂设计模式的实时示例：文档转换系统

C# 工厂设计模式的实时示例：日志记录系统

C# 工厂设计模式的实时示例：一个简单的通知处理系统

C# 工厂设计模式的实时示例：电子商务应用程序中的折扣

工厂设计模式：C# 中的实时应用

C# 中工厂设计模式的优势

C# 中工厂设计模式的缺点

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

.Net Framework

C# 教程

C# 控制语句

C# 函数

C# 数组

C# Object 类

C# 属性

C# 继承

C# 多态

C# 抽象

C# 命名空间

C# 字符串

C# 异常处理

C# 文件 IO

C# 集合

C# 泛型

C# 委托

C# 反射

匿名函数

C# 多线程

C# 同步

C# 高级主题

C# 2.0

C# 3.0

C# 4.0

C# 5.0

C# 6.0

C# 7.0

C# 7.1

C# 程序

C# 面试问题

C# 杂项

ASP.NET 教程

ADO.NET 教程

C# Web 服务

C# 字符串函数

C# 新特性

C# 中工厂设计模式的实时示例

C# 工厂设计模式实时示例：支付网关集成

C# 工厂设计模式的实时示例：文档转换系统

C# 工厂设计模式的实时示例：日志记录系统

C# 工厂设计模式的实时示例：一个简单的通知处理系统

C# 工厂设计模式的实时示例：电子商务应用程序中的折扣

工厂设计模式：C# 中的实时应用

C# 中工厂设计模式的优势

C# 中工厂设计模式的缺点

结论

相关帖子

C# 中如何获取对 ListDictionary 的同步访问

C# 中的 DateTime

C# 中 Is 和 As 运算符关键字的区别

C# 中如何编写重试逻辑

Python 和 C# 的区别

C# 中的 Double.IsFinite() 方法

C# 和 JavaScript 的区别

C# 中的抽象工厂设计模式

C# 中的 SByte 结构体字段

C# 中的 Uri.EscapeDataString(String) 方法

订阅 Tpoint Tech

联系信息