【设计模式】之状态模式

最新推荐文章于 2024-11-09 22:28:28 发布
最新推荐文章于 2024-11-09 22:28:28 发布
阅读量171 收藏
点赞数
分类专栏： 《大话设计模式》学习笔记 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39582960/article/details/103202831
版权

  • UML

  • 原型

//状态抽象类
abstract class State
    {
        public abstract void Handle(Context context);
    }
    

//状态A
 class ConcreteStateA : State
    {
        public override void Handle(Context context)
        {
            context.State = new ConcreteStateB();
        }
    }

//状态B
class ConcreteStateB : State
    {
        public override void Handle(Context context)
        {
            context.State = new ConcreteStateA();
        }
    }

//上下文
class Context
    {
        private State state;
        public Context(State state)
        {
            this.state = state;
        }
        public void Request()
        {
            state.Handle(this);
        }
        public State State { get => state; set => state = value; }
    }

 class Program
    {
        static void Main(string[] args)
        {
            Context c = new Context(new ConcreteStateA());
            c.Request();
            c.Request();
            c.Request();
            c.Request();
        }
    }

  • 举例

一个简单的停等协议：

 //分组
    class Packet
    {
        private string data;            //数据
        private string checksum;        //数据校验和
        private int num;                //序号

        public string Data { get => data; set => data = value; }
        public string Checksum { get => checksum; set => checksum = value; }
        public int Num { get => num; set => num = value; }
    }

 //状态抽象类
    abstract class State
    {
        public abstract void Change(Context context);
    }

//终端抽象类
    abstract class Context
    {
        private State state;            //状态
        private string data;            //数据
        private string checksum;        //校验和
        private Packet packet;          //分组
        private Context other;          //对等方
        //初始化状态
        public Context(State state)
        {
            this.state = state;
        }
        //运行
        public void Run()
        {
            state.Change(this);
        }
        //rdt发送
        public bool rdt_send(string data)
        {
            return true;
        }
        //rdt接收
        public bool rdt_rcv(Packet packet)
        {
            return true;
        }
        //装包
        public Packet make_pkt(int num,string data,string checksum)
        {
            Console.WriteLine($"初始化分组[{num},{data},{checksum}]...");
            Packet packet = new Packet();
            packet.Num = num;
            packet.Data = data;
            packet.Checksum = checksum;
            return packet;
        }
        //udt发送
        public void udt_send(Packet packet)
        {
            Console.WriteLine("发送...");
            //%50的出错概率
            if (Program.random.Next(0,100)<=50)
            {
                packet.Data = "error";
                Console.WriteLine("出现bit差错！");
            }
            Other.Packet = packet;
        }
        //解包
        public void extract(Packet packet, out string data)
        {
            Console.WriteLine($"解析分组...");
            data = packet.Data;
        }
        //上传给高层
        public void deliver_data(string data)
        {
            Console.WriteLine($"{data}");
        }
        //校验和
        public bool corrupt(Packet rcvpkt)
        {
            if(!rcvpkt.Data.Equals(rcvpkt.Checksum))
            {
                Console.WriteLine("分组出错!");
                return true;
            }
            else
            {
                return false;
            }
        }
        public bool notcorrupt(Packet rcvpkt)
        {
            if (rcvpkt.Data.Equals(rcvpkt.Checksum))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        //肯定确认
        public bool isACK(Packet rcvpkt,int num)
        {
            if (rcvpkt.Data.Equals("ACK")&&rcvpkt.Num==num)
            {
                Console.WriteLine($"收到一个{num}号肯定确认！");
                return true;
            }
            else
            {
                return false;
            }
        }
        //是0号分组还是1号分组
        public bool has_seq0(Packet packet)
        {
            if(packet.Num==0)
            {
                Console.WriteLine("收到了0号分组");
                return true;
            }else
            {
                return false;

            }
        }
        public bool has_seq1(Packet packet)
        {
            if (packet.Num == 1)
            {
                Console.WriteLine("收到了1号分组");
                return true;
            }
            else
            {
                return false;

            }
        }

        public State State { get => state; set => state = value; }
        public string Data { get => data; set => data = value; }
        public Context Other { get => other; set => other = value; }
        public Packet Packet { get => packet; set => packet = value; }
        public string Checksum { get => checksum; set => checksum = value; }
    }

 //发送端
    class Sender : Context
    {
        public Sender(State state) : base(state)
        {
        }
    }

// 发送端状态A
    class SenderStateA : State
    {
        public override void Change(Context context)
        {
            Console.WriteLine("Sender:=>A");
            Console.WriteLine("---------------------");
            if (context.rdt_send(context.Data))
            {
                Packet packet = context.make_pkt(0,context.Data, context.Checksum);
                context.udt_send(packet);
                context.State = new SenderStateB();

                //接收端处理
                context.Other.Run();
            } 
        }
    }

// 发送端状态B
class SenderStateB : State
    {
        public override void Change(Context context)
        {
            Console.WriteLine("Sender:=>B");
            Console.WriteLine("---------------------");
            Console.WriteLine("接收...");

            if (context.rdt_rcv(context.Packet) && (context.corrupt(context.Packet) || context.isACK(context.Packet,1)))
            {
                Packet packet = context.make_pkt(0, context.Data, context.Checksum);
                context.udt_send(packet);

                context.Other.Run();
            }else if (context.rdt_rcv(context.Packet)&& context.notcorrupt(context.Packet) && context.isACK(context.Packet,0))
            {
                context.State = new SenderStateC();
            }
        }
    }

//发送端状态C
class SenderStateC : State
    {
        public override void Change(Context context)
        {
            Console.WriteLine("Sender:=>C");
            Console.WriteLine("---------------------");
            if (context.rdt_send(context.Data))
            {
                Packet packet = context.make_pkt(1, context.Data, context.Checksum);
                context.udt_send(packet);
                context.State = new SenderStateD();
                //接收端处理
                context.Other.Run();
            }
        }
    }

// 发送端状态D
class SenderStateD : State
    {
        public override void Change(Context context)
        {
            Console.WriteLine("Sender:=>D");
            Console.WriteLine("---------------------");
            Console.WriteLine("接收...");

            if (context.rdt_rcv(context.Packet) && (context.corrupt(context.Packet) || context.isACK(context.Packet,0)))
            {
                Packet packet = context.make_pkt(1, context.Data, context.Checksum);
                context.udt_send(packet);

                context.Other.Run();
            }else if (context.rdt_rcv(context.Packet) && context.notcorrupt(context.Packet) && context.isACK(context.Packet,1))
            {
                context.State = new SenderStateA();
            }
        }
    }

//接收端
    class Receiver:Context
    {
        public Receiver(State state):base(state)
        {
        }
    }

//接收端状态A
    class RcvStateA : State
    {
        public override void Change(Context context)
        {
            Console.WriteLine("Receiver:=>A");
            Console.WriteLine("------------------------");
            Console.WriteLine("接收...");

            if (context.rdt_rcv(context.Packet) && (context.corrupt(context.Packet) || context.has_seq1(context.Packet)))
            {
                Packet packet = context.make_pkt(1,"ACK", "ACK");
                context.udt_send(packet);

                context.Other.Run();
            }
            else if(context.rdt_rcv(context.Packet) && context.notcorrupt(context.Packet) && context.has_seq0(context.Packet))
            {
                string data = "";
                context.extract(context.Packet,out data);
                context.deliver_data(data);
                Packet packet = context.make_pkt(0,"ACK","ACK");
                context.udt_send(packet);

                context.State = new RcvStateB();

                context.Other.Run();
            }
        }
    }

// 接收端状态B
class RcvStateB : State
    {
        public override void Change(Context context)
        {
            Console.WriteLine("Receiver:=>B");
            Console.WriteLine("------------------------");
            Console.WriteLine("接收...");

            if (context.rdt_rcv(context.Packet) && (context.corrupt(context.Packet) || context.has_seq0(context.Packet)))
            {
                Packet packet = context.make_pkt(0,"ACK", "ACK");
                context.udt_send(packet);

                context.Other.Run();
            }
            else if (context.rdt_rcv(context.Packet) && context.notcorrupt(context.Packet) && context.has_seq1(context.Packet))
            {
                string data = "";
                context.extract(context.Packet, out data);
                context.deliver_data(data);
                Packet packet = context.make_pkt(1,"ACK", "ACK");
                context.udt_send(packet);

                context.State = new RcvStateA();

                context.Other.Run();
            }
        }
    }

class Program
    {
        //产生随机数用于模仿出错概率
        public static readonly Random random = new Random();

        static void Main(string[] args)
        {
            Sender sender = new Sender(new SenderStateA());
            Receiver receiver = new Receiver(new RcvStateA());
            //建立连接
            sender.Other = receiver;
            receiver.Other = sender;

            sender.Data = "hello ";
            sender.Checksum = "hello ";
            sender.Run();
            sender.Data = "world!";
            sender.Checksum = "world!";
            sender.Run();
            Console.WriteLine("-----------SUCCESS-----------");
        }
    }
轩i丶
关注
专栏目录
java 设计模式之状态模式
07-03
状态模式是一种行为设计模式，它允许对象在内部状态改变时改变其行为，看起来好像对象改变了它的类。在Java中，状态模式通常通过定义不同的状态类和一个上下文类来实现，其中上下文类持有状态对象并调用其方法来响应...
P4 Tutorial 快速上手 (2) Basic IPv4 Forwarding
jixie3948的博客
05-04 3436
P4 Tutorial 快速上手 (2) Basic IPv4 Forwar 提示：本系列仅适用于软件交换机BMv2 代码库链接：https://github.com/p4lang/tutorials/tree/master/exercises/basic 在对P4 Tutorial库的粗略介绍后，便正式开始上手之旅。 本文将对最基础的练习进行讲解：basic练习的目标是编写一个具备基于ipv4地址的转发程序，需要用P4实现基于此的完整转发逻辑。 内容包括IPv4转发原理介绍、代码分析以及实验结果说明。
P4实验之防火墙
a1164520408的博客
12-06 1343
基于mininet和p4设计了防火墙的小实验，实现了外网的tcp连接的隔离
计算机网络 自顶向下（3）传输层——学习笔记
DO_do_H的博客
10-02 2381
· 概述和传输层服务： · · 传输服务： · · 传输层在两个远程进程之间进行报文段的逻辑通信。 · · · 传输层协议运行在端系统： · · · 发送方：将应用层的报文分为报文段，然后传给网络层。 · · · 接收方：将报文段重组成报文，然后传递给应用层。 · · · 可选协议： · · · Internet：TCP和UDP · · 传输层与网络层的工作对比： · · 网络层服务：主机之间的逻辑通信。 · · 传输层服务：进程之间的逻辑通信。 · · · 传输层依赖于网络层提供的服务： · · · 由于
P4 Tutorial 快速上手 (3) Basic_tunnel
jixie3948的博客
05-09 1487
P4 Tutorial 快速上手 (3) Basic_tunnel 提示：本系列仅适用于软件交换机BMv2 P4 Tutorial 快速上手 (2) 文章目录P4 Tutorial 快速上手 (3) Basic_tunnel简介一、转发原理二、代码解析1.包头部解析2.按目的主机ID转发3.包头填充三、运行结果1.连通实验总结附录 简介 代码库链接：https://github.com/p4lang/tutorials/tree/master/exercises/basic_tunnel Basic
C++设计模式之状态模式
09-04
状态模式是一种行为设计模式，它使你能在运行时改变对象的行为，这主要通过将状态相关的行为委托给代表不同状态的对象来实现。在C++中，状态模式能够有效地消除复杂的条件分支语句，使得代码更易于理解和维护。 在...
设计模式之状态模式
03-14
这份文件讲诉了设计模式之状态模式，是以例子的形式进行讲诉的，希望可以帮助学习的人！
学习JavaScript设计模式之状态模式
10-23
状态模式是软件设计中的一种行为设计模式，主要用于处理具有不同状态的对象在不同状态下行为的改变。它允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。状态模式是有限状态机的一种实现，...
P4官方实验1. Implementing Basic Forwarding
辣鸡的博客
03-05 1676
P4官方实验1 实现基础转发 介绍 交换机要实现接下来的功能 更新元和目的mac 减少IP头的TTL 将包转发到合适的端口 我们的P4程序使用V1Model结构写成，该结构被P4.org上的bmv2软件交换机实现。作者建议我们阅读v1model.p4文件。 我们需要使用mininet，这是斯坦福大学的一个开源项目，用于生成一个虚拟网络，包括虚拟链路、主机、交换机、路由器等，用于实验测试。 第一步：运行不完全的起始代码 在basic目录下make源代码 make run 之后使用h1 ping h2，肯
extract_package 函数 解析
佛系程序员
04-30 766
struct acpi_battery { struct mutex lock; struct mutex sysfs_lock; struct power_supply *bat; struct power_supply_desc bat_desc; struct acpi_device *device; struct notifier_block pm_nb; struct li...
C++ 连包分包处理
wu_jing_sheng0的专栏
05-13 3682
<br />所谓连包, 分包问题. 比如说. 根据通讯协议, 发送了两条命令. 第一条命令 80 字节. 第二条命令 120 字节. 但接受方收到数据的时候, 可能第一次收到 150 个字节. 第二次收到 50 个字节. 要正确理解发送方的命令包. 接受方必须根据协议正确的从第一包数据中取出前 80 个字节. 作为一条命令, 再把剩下的 70 个字节和第二包的数据组合成第二条命令. 这个问题如此常见. 以致于实现一个可以复用的, 轻量级的解析器就变得很有必要. 于是就有了这个 PacketE
android局域网中嗅探,c# - 在本地网络上嗅探Android设备的TCP数据包 - 堆栈内存溢出...
weixin_42511990的博客
06-04 272
我终于可以通过应用ARP缓存中毒使它正常工作，而下面的代码能够将任何设备的数据包重定向到目的地，这样您就可以捕获网络上任何设备的数据包，而不会丢失该设备的互联网访问权限。码：private void StartSniffer(){RawCapture rawCapture;do{if ((rawCapture = capturedevice.GetNextPacket()) != null){Et...
本科课程：计算机网络（三）
weixin_39589033的博客
03-12 1741
传输层 多路复用 多路分用 传输层的目标： provide logical communication between app processes running on different hosts 传输层和网络层的关系 network layer： logical communication between hosts 主机之间的传输 transport layer： logical...
可靠数据传输原理（上）
不应有的淡定的博客
08-11 9145
可靠数据传输原理
计算机网络：可靠的传输协议
qq_33690566的博客
04-19 3223
文章目录计算机网络：可靠的传输协议1、网络中不可靠的情况2、解决网络不可靠的基本方法3、可靠的传输协议3.1、比特交换协议(alternating-bit protocol)3.2、回退N步(Go-Back-N)3.3、选择重传(SR)4、协议实现 计算机网络：可靠的传输协议 1、网络中不可靠的情况 数据损伤：二进制数据发生翻转，及0->1或1->0 数据丢失：发送的数据包在拥塞或故...
我tcp可是铁齿金不换,诚实可靠小郎君——谈谈可靠数据传输服务
xianyudx的博客
10-05 557
一篇关于可靠数据传输服务的文章。内含从特殊到一般地构建可靠数据传输协议，和利用GBN、SR方法优化协议的效率。许多内容参考了《计算机网络 从顶而下方法》原书第七版这本书。
接口类和抽象类在设计模式中的一些应用
最新发布
Joshua的专栏
11-09 868
需要接口类：职责链模式通过定义处理请求的接口，将多个处理者链接在一起，使得请求可以沿着链进行传递，直到被处理为止。需要接口类：状态模式通过定义状态的接口，使得对象的行为可以根据其内部状态的改变而改变。原因：组合模式需要定义一个通用的组件接口，使得叶子节点和组合节点可以被统一处理。原因：职责链模式需要定义一个通用的处理者接口，使得不同的处理者可以被统一处理。原因：命令模式需要定义一个通用的命令接口，使得不同的命令对象可以被统一处理。原因：状态模式需要定义一个通用的状态接口，使得不同的状态对象可以被统一处理。
【设计模式】结构型模式（四）：组合模式、享元模式
书山有路，学海无涯。记录成长，追逐梦想
11-09 610
组合模式（Composite Pattern）是一种设计模式，用于处理树形结构的数据。它的主要目的是将对象组合成树形结构来表示 “部分 - 整体” 的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
JavaScript设计模式：状态模式实例详解
"深入理解JavaScript系列（43）：设计模式之状态模式详解"这一篇文章详细探讨了JavaScript中的状态模式，这是一种行为设计模式，主要用于解决对象在不同状态下表现出不同行为的问题。状态模式的核心理念是将对象的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值