C#设计模式:解释器模式(Interpreter Pattern)

一,C#设计模式:解释器模式(Interpreter Pattern)

1,解释器模式的应用场合是Interpreter模式应用中的难点,只有满足“业务规则频繁变化,且类似的模式不断重复出现,并且容易抽象为语法规则的问题”才适合使用解释器模式
2,解释器设计模式每个解释的类有自己的规则,并且与其他业务规则不冲突

二,如下代码

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

namespace _23.解释器模式
{
    /// <summary>
    /// Interpreter模式的应用场合是Interpreter模式应用中的难点,只有满足“业务规则频繁变化,且类似的模式不断重复出现,并且容易抽象为语法规则的问题”才适合使用Interpreter模式。
    ///  1、当一个语言需要解释执行,并可以将该语言中的句子表示为一个抽象语法树的时候,可以考虑使用解释器模式(如XML文档解释、正则表达式等领域)
    ///  2、一些重复出现的问题可以用一种简单的语言来进行表达。
    ///  3、一个语言的文法较为简单.
    ///  4、当执行效率不是关键和主要关心的问题时可考虑解释器模式(注:高效的解释器通常不是通过直接解释抽象语法树来实现的,而是需要将它们转换成其他形式,使用解释器模式的执行效率并不高。)
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Context context = new Context("usachi");
            List<PeopleInterpreter> interpreterList = new List<PeopleInterpreter>()
                    {
                        new Chinese(),
                        new Usa(),
                    };
            foreach (var item in interpreterList)
            {
                item.Conversion(context);
            }
            Console.WriteLine(context.Get());
        }
    }

    /// <summary>
    /// 上下文
    /// </summary>
    public class Context
    {
        private string _Word = null;
        public Context(string word)
        {
            this._Word = word;
        }

        public void Set(string newWord)
        {
            this._Word = newWord;
        }

        public string Get()
        {
            return this._Word;
        }
    }

    /// <summary>
    /// 抽象解释器
    /// </summary>
    public abstract class PeopleInterpreter
    {
        public abstract void Conversion(Context context);
    }
    /// <summary>
    /// 中国人业务
    /// </summary>
    public class Chinese : PeopleInterpreter
    {
        private static Dictionary<char, string> _Dictionary = new Dictionary<char, string>();
        /// <summary>
        /// 中国人自己解释规则
        /// </summary>
        static Chinese()
        {
            _Dictionary.Add(‘u‘, "美国人");
            _Dictionary.Add(‘s‘, "用刀叉");
            _Dictionary.Add(‘a‘, "吃饭,");
        }

        public override void Conversion(Context context)
        {
            Console.WriteLine(this.GetType().ToString() + "业务");
            string text = context.Get();
            if (string.IsNullOrEmpty(text))
                return;
            List<string> numberList = new List<string>();
            foreach (var item in text.ToLower().ToArray())
            {
                if (_Dictionary.ContainsKey(item))
                {
                    numberList.Add(_Dictionary[item]);
                }
                else
                {
                    numberList.Add(item.ToString());
                }
            }
            context.Set(string.Concat(numberList));
        }
    }
    /// <summary>
    /// 美国人业务
    /// </summary>
    public class Usa : PeopleInterpreter
    {
        private static Dictionary<char, string> _Dictionary = new Dictionary<char, string>();
        /// <summary>
        /// 美国人自己解释规则
        /// </summary>
        static Usa()
        {
            _Dictionary.Add(‘c‘, "中国人");
            _Dictionary.Add(‘h‘, "用");
            _Dictionary.Add(‘i‘, "筷子吃饭");
        }

        public override void Conversion(Context context)
        {
            Console.WriteLine(this.GetType().ToString() + "业务");
            string text = context.Get();
            if (string.IsNullOrEmpty(text))
                return;
            List<string> numberList = new List<string>();
            foreach (var item in text.ToLower().ToArray())
            {
                if (_Dictionary.ContainsKey(item))
                {
                    numberList.Add(_Dictionary[item]);
                }
                else
                {
                    numberList.Add(item.ToString());
                }
            }
            context.Set(string.Concat(numberList));
        }
    }
}

原文地址:https://www.cnblogs.com/May-day/p/11718888.html

时间: 2024-12-16 09:20:26

C#设计模式:解释器模式(Interpreter Pattern)的相关文章

二十四种设计模式:解释器模式(Interpreter Pattern)

解释器模式(Interpreter Pattern) 介绍给定一个语言, 定义它的文法的一种表示,并定义一个解释器,该解释器使用该表示来解释语言中的句子. 示例有一个Message实体类,某个类对它的操作有Get()方法.现在要求用具有某一规则的中文语法来执行这个操作. MessageModel using System; using System.Collections.Generic; using System.Text; namespace Pattern.Interpreter { //

设计模式(行为型)之解释器模式(Interpreter Pattern)

PS一句:最终还是选择CSDN来整理发表这几年的知识点,该文章平行迁移到CSDN.因为CSDN也支持MarkDown语法了,牛逼啊! [工匠若水 http://blog.csdn.net/yanbober] 阅读前一篇<设计模式(行为型)之访问者模式(Visitor Pattern)>http://blog.csdn.net/yanbober/article/details/45536787 概述 解释器模式是类的行为模式.给定一个语言之后,解释器模式可以定义出其文法的一种表示,并同时提供一个

[设计模式] 解释器模式 Interpreter

在GOF的<设计模式:可复用面向对象软件的基础>一书中对解释器模式是这样说的:给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子.如果一种特定类型的问题发生的频率足够高,那么可能就值得将该问题的各个实例表述为一个简单语言中的句子.这样就可以构建一个解释器,该解释器通过解释这些句子来解决该问题. 就如上面说的那个游戏,我输入up walk 5,我必须按照:移动方向+移动方式+移动距离这种格式输入我的指令,而这种格式的指令就是一种文法,只有按照了我定义的

原始的解释器模式(Interpreter Pattern)

解释器模式的定义(现实项目中很少遇到,因此直接理论先...) 解释器模式是一种按照规定语法进行解析的方案,在现在项目中使用较少,其定义为:给定一门语言,定义它的方法的一种表示,并定义一个解释器,该解释器使用该表示来解释语言中的句子.其构成如下: 1.AbstractExpression--抽象解释器 具体的解释任务由各个实现类完成,具体的解释器分别由TerminalExpression和NonterminalExpression完成 2.TerminalExpression--终结符表达式 实现

深入浅出设计模式——解释器模式(Interpreter Pattern)

模式动机 如果在系统中某一特定类型的问题发生的频率很高,此时可以考虑将这些问题的实例表述为一个语言中的句子,因此可以构建一个解释器,该解释器通过解释这些句子来解决这些问题.解释器模式描述了如何构成一个简单的语言解释器,主要应用在使用面向对象语言开发的编译器中. 模式定义解释器模式(Interpreter Pattern) :定义语言的文法,并且建立一个解释器来解释该语言中的句子,这里的“语言”意思是使用规定格式和语法的代码,它是一种类行为型模式.Interpreter Pattern: Give

设计模式之解释器模式(Interpreter)摘录

23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于如何创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而一个对象创建型模式将实例化委托给另一个对象.创建型模式有两个不断出现的主旋律.第一,它们都将关于该系统使用哪些具体的类的信息封装起来.第二,它们隐藏了这些类的实例是如何被创建和放在一起的.整个系统关于这些对象所知道的是由抽象类所定义的接口.因此,创建型模式在什么被创建,谁创建它,它是怎样被创建的,以

解释器模式 Interpreter 行为型 设计模式(十九)

解释器模式(Interpreter) 考虑上图中计算器的例子 设计可以用于计算加减运算(简单起见,省略乘除),你会怎么做? 你可能会定义一个工具类,工具类中有N多静态方法 比如定义了两个方法用于计算a+b 和 a+b-c public static int add(int a,int b){ return a+b; } public static int add(int a,int b,int c){ return a+b-c; } 但是很明显,如果形式有限,那么可以针对对应的形式进行编程 如果

设计模式 - 代理模式(proxy pattern) 未使用代理模式 详解

代理模式(proxy pattern) 未使用代理模式 详解 本文地址: http://blog.csdn.net/caroline_wendy 部分代码参考: http://blog.csdn.net/caroline_wendy/article/details/37698747 如果需要监控(monitor)类的某些状态, 则需要编写一个监控类, 并同过监控类进行监控. 但仅仅局限于本地, 如果需要远程监控, 则需要使用代理模式(proxy pattern). 具体方法: 1. 类中需要提供

设计模式 - 迭代器模式(iterator pattern) Java 迭代器(Iterator) 详解

迭代器模式(iterator pattern) Java 迭代器(Iterator) 详解 本文地址: http://blog.csdn.net/caroline_wendy 参考迭代器模式(iterator pattern): http://blog.csdn.net/caroline_wendy/article/details/35254643 Java的标准库(util)中包含迭代器接口(iterator interface), import java.util.Iterator; 继承(