C#event实现fail-fast

最新推荐文章于 2024-01-04 10:22:26 发布
最新推荐文章于 2024-01-04 10:22:26 发布
阅读量248 收藏
点赞数
分类专栏： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asd0356/article/details/103910301
版权

fail-fast
俗称快速失败策略，具体来说就是指用迭代器在遍历一个集合时对被遍历的元素进行增删改一类的set操作会导致系统抛出InvalidOperationException（Java里面是抛出ConcurrentModificationException）。
有关快速失败的原理这里就不多做解释，有兴趣的老铁可以浏览下面的链接博客。
https://www.jianshu.com/p/1c2d31b1f69e
C#event
在上篇文章讲述了C#中委托，匿名方法，Lambda表达式之间的关系并且知道后两者都是基于委托而实现的，事件event也是基于委托而实现。而在真正的实现上，可以把C#的event近似的看成js中的event，都是通过函数作为参数进行传递，同时也都有“接事件与发事件”的过程。
实现思路
明白了fail-fast和event的原理概念后，实现的思路其实也就不难了：
定义一个内部类，实现IEnumerator<T>接口，定义一个私有指针用于记录迭代器的遍历位置，然后在原生类里定义一个事件，并把事件绑定于每一个能修改元素的方法上，最后在此内部类里定义一个私有的判断指针和一个接收事件，接收事件改变判断指针的属性并且在迭代方法上通过判断指针进行fail-fast判断。
第一步：构建一个内部类并实现IEnumerator<T>接口

class NodeEnumerator : IEnumerator<T>
        {
            private int _actualIndex = -1;
            public T Current => throw new NotImplementedException();

            object IEnumerator.Current => throw new NotImplementedException();

            public void Dispose()
            {
                throw new NotImplementedException();
            }

            public bool MoveNext()
            {
                throw new NotImplementedException();
            }

            public void Reset()
            {
                throw new NotImplementedException();
            }
        }

其中有两个属性三个方法是需要被实现（_actualIndex 是我们自己添加的属性），具体是什么我不详细讲述，有兴趣的老铁可以自行去百度研究这里，我挑重点进行叙述。
MoveNext()：在这个方法里面判断迭代器是否终止，同时也是在这个方法里面判断是否执行fail-fast。
Reset()： 这个方法用于重置迭代器（_actualIndex = -1）。
Current ： 这个属性返回当前迭代器正在被遍历的元素（这个属性只能对外提供get方法）。
第二步：插入事件
原生类：

        private void OnChanged() =>
        Changed?.Invoke(this, EventArgs.Empty);
        private event EventHandler Changed;

内部类：

        private bool _changed = false;
        private void OnChanged(object sender, EventArgs e)
            {
                _changed = true;
            }

最后一步： 绑定事件
原生类：

public void Add(T item)
        {
            OnChanged();
            var itemNode = new Node(item);
            if (_head == null)
            {
                _head = itemNode;
            }
            else
            {
                var iNode = _head;
                for (; iNode.next != null; iNode = iNode.next)
                {

                }
                iNode.next = itemNode;
            }
            Count++;
        }

内部类：

            public NodeEnumerator(MyLinkedList<T> linkedList)
            {
                _mylinkedList = linkedList;
                _mylinkedList.Changed += OnChanged;
                Reset();
            }
            public bool MoveNext()
            {
                if (_changed)
                {
                    throw new InvalidOperationException();
                }
                _actualIndex++;
                return (_mylinkedList.Count > _actualIndex);
            }

完整代码
最后我附上以单链表为环境的全部源码，希望能对大家有所帮助。

public class MyLinkedList<T> : Object, IList<T>
    {
        class Node
        {
            public T data;
            public Node next;
            public Node(T data)
            {
                this.data = data;
            }
        }



        private Node _head;


        public MyLinkedList()
        {
            _head = null;
        }

        //获取和设置指定处的元素
        public T this[int index]
        {
            get
            {
                return SearchIndex(index).data;
            }
            set
            {
                OnChanged();
                SearchIndex(index).data = value;
            }
        }

        //获取当前链表中元素的个数
        public int Count { get; set; }

        public bool IsReadOnly { get { return false; } }
        //发事件，接事件，类比js的event
        private void OnChanged() =>
        Changed?.Invoke(this, EventArgs.Empty);
        private event EventHandler Changed;
        class NodeEnumerator : IEnumerator<T>
        {
            private int _actualIndex = -1;
            private bool _changed = false;
            private MyLinkedList<T> _mylinkedList;
            private void OnChanged(object sender, EventArgs e)
            {
                _changed = true;
            }
            public NodeEnumerator(MyLinkedList<T> linkedList)
            {
                _mylinkedList = linkedList;
                _mylinkedList.Changed += OnChanged;
                Reset();
            }
            public T Current
            {
                get
                {
                    try
                    {
                        T element = _mylinkedList[_actualIndex];
                        return element;
                    }
                    catch (IndexOutOfRangeException e)
                    {
                        throw new InvalidOperationException();
                    }
                }
            }

            object IEnumerator.Current => throw new NotImplementedException();

            public void Dispose()
            {
                GC.SuppressFinalize(this);
            }

            public bool MoveNext()
            {
                if (_changed)
                {
                    throw new InvalidOperationException();
                }
                _actualIndex++;
                return (_mylinkedList.Count > _actualIndex);
            }

            public void Reset()
            {
                _actualIndex = -1;
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }

        //UnitTest
        public IEnumerator<T> GetEnumerator()
        {
            return new NodeEnumerator(this);
        }
        //UnitTest
        public void Add(T item)
        {
            OnChanged();
            var itemNode = new Node(item);
            if (_head == null)
            {
                _head = itemNode;
            }
            else
            {
                var iNode = _head;
                for (; iNode.next != null; iNode = iNode.next)
                {

                }
                iNode.next = itemNode;
            }
            Count++;
        }


        public void Clear()
        {
            OnChanged();
            while (_head.next != null)
            {
                var nextNode = _head.next;
                _head.next = nextNode.next;
            }
            _head = null;
            Count = 0;
        }

        public bool Contains(T item)
        {
            return IndexOf(item) != -1;
        }

        public void CopyTo(T[] array, int arrayIndex)
        {
            if (array == null)
            {
                throw new ArgumentNullException();
            }
            for (int i = 0; i < Count; i++)
            {
                try
                {
                    array[arrayIndex + i] = this[i];
                }
                catch (Exception)
                {
                    throw new ArgumentNullException();
                }
            }
        }

        //UnitTest
        public int IndexOf(T item)
        {
            var index = 0;
            for (var iNode = _head; iNode != null; iNode = iNode.next, index++)
            {
                if (TEquals(item, iNode))
                {
                    return index;
                }
            }
            return -1;
        }
        //UnitTest
        public void Insert(int index, T item)
        {
            OnChanged();
            var itemNode = new Node(item);
            if (index == 0)
            {
                itemNode.next = _head;
                _head = itemNode;
                Count++;
                return;
            }
            CheckIndex(index - 1);
            var indexNode = SearchIndex(index - 1);
            itemNode.next = indexNode.next;
            indexNode.next = itemNode;
            Count++;
        }

        private Node SearchIndex(int index)
        {
            CheckIndex(index);
            var result = _head == null ? throw new ArgumentNullException() : _head;
            for (int i = 0; i < index; i++)
            {
                result = result.next;
            }
            return result;
        }

        private void CheckIndex(int index)
        {
            if (index < 0 || index >= Count)
            {
                throw new ArgumentNullException();
            }
        }

        //UnitTest
        public bool Remove(T item)
        {
            OnChanged();
            T oldData;
            var precursor = SearchPrecursor(item);
            if (precursor == null)
            {
                return false;
            }
            if (precursor == _head && TEquals(item, precursor))
            {
                oldData = _head.data;
                _head = _head.next;
                Count--;
                return true;
            }
            oldData = precursor.next.data;
            precursor.next = precursor.next.next;
            Count--;
            return true;
        }

        private bool TEquals(T item, Node node)
        {
            return ((node.data != null && node.data.Equals(item)) || (node.data == null && item == null));
        }

        private Node SearchPrecursor(T item)
        {
            var precursor = _head;
            if (TEquals(item, precursor))
            {
                return _head;
            }
            while (precursor.next != null)
            {
                if (TEquals(item, precursor.next))
                {
                    return precursor;
                }
                precursor = precursor.next;
            }
            return null;
        }

        public void RemoveAt(int index)
        {
            OnChanged();
            T oldData;
            var removeTarget = this[index];
            var precursor = SearchPrecursor(removeTarget);
            if (precursor == null)
            {
                return;
            }
            if (precursor == _head && TEquals(removeTarget, precursor))
            {
                oldData = _head.data;
                _head = _head.next;
            }
            oldData = precursor.next.data;
            precursor.next = precursor.next.next;
            Count--;
        }

        private void Foreach(Action<Node> ac)
        {
            for (var iNode = _head; iNode != null; iNode = iNode.next)
            {
                ac(iNode);
            }
        }
        public void Display()
        {
            Foreach((Node iNode) => { Console.Write("{0} ", iNode.data); });
        }

    }

另外我这里这给出一个用yield return思路实现的代码：

public class MyLinkedList<T> : IList<T>
    {
        class Node
        {
            public T data;
            public Node next;
            public Node(T data)
            {
                this.data = data;
            }
        }

        private Node _head;

        public MyLinkedList()
        {
            _head = null;
        }

        //获取和设置指定处的元素
        public T this[int index]
        {
            get
            {
                return SearchIndex(index).data;
            }
            set
            {
                SearchIndex(index).data = value;
                OnChanged();
            }
        }

        //获取当前链表中元素的个数
        public int Count { get; set; }

        public bool IsReadOnly { get { return false; } }

        private bool _changed = false;
        private void OnChanged() =>
        Changed?.Invoke(this, EventArgs.Empty);
        private event EventHandler Changed;

        private void OnChanged(object sender, EventArgs e)
        {
            _changed = true;
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        //UnitTest
        public IEnumerator<T> GetEnumerator()
        {
            Changed += OnChanged;
            for (int i = 0; i < Count; i++)
            {
                if (_changed)
                {
                    _changed = false;
                    throw new InvalidOperationException();
                }
                yield return this[i];
            }
            Changed -= OnChanged;
        }
        //UnitTest
        public void Add(T item)
        {
            var itemNode = new Node(item);
            if (_head == null)
            {
                _head = itemNode;
            }
            else
            {
                var iNode = _head;
                for (; iNode.next != null; iNode = iNode.next)
                {

                }
                iNode.next = itemNode;
            }
            Count++;
            OnChanged();
        }

        public void Clear()
        {
            _head = null;
            Count = 0;
            OnChanged();
        }

        public bool Contains(T item)
        {
            return IndexOf(item) != -1;
        }

        public void CopyTo(T[] array, int arrayIndex)
        {
            if (array == null)
            {
                throw new ArgumentNullException();
            }
            try
            {
                for (int i = 0; i < Count; i++)
                {
                    array[arrayIndex + i] = this[i];
                }
            }
            catch (Exception)
            {
                throw new IndexOutOfRangeException();
            }

        }

        //UnitTest
        public int IndexOf(T item)
        {
            var index = 0;
            for (var iNode = _head; iNode != null; iNode = iNode.next, index++)
            {
                if (TEquals(item, iNode))
                {
                    return index;
                }
            }
            return -1;
        }
        //UnitTest
        public void Insert(int index, T item)
        {
            var itemNode = new Node(item);
            if (index == 0)
            {
                itemNode.next = _head;
                _head = itemNode;
                Count++;
                return;
            }
            CheckIndex(index - 1);
            var indexNode = SearchIndex(index - 1);
            itemNode.next = indexNode.next;
            indexNode.next = itemNode;
            Count++;
            OnChanged();
        }

        private Node SearchIndex(int index)
        {
            CheckIndex(index);
            var result = _head == null ? throw new ArgumentNullException() : _head;
            for (int i = 0; i < index; i++)
            {
                result = result.next;
            }
            return result;
        }

        private void CheckIndex(int index)
        {
            if (index < 0 || index >= Count)
            {
                throw new IndexOutOfRangeException();
            }
        }

        //UnitTest
        public bool Remove(T item)
        {
            T oldData;
            var precursor = SearchPrecursor(item);
            if (precursor == null)
            {
                OnChanged();
                return false;
            }
            if (precursor == _head && TEquals(item, precursor))
            {
                oldData = _head.data;
                _head = _head.next;
                Count--;
                OnChanged();
                return true;
            }
            oldData = precursor.next.data;
            precursor.next = precursor.next.next;
            Count--;
            OnChanged();
            return true;
        }

        private bool TEquals(T item, Node node)
        {
            return ((node.data != null && node.data.Equals(item)) || (node.data == null && item == null));
        }

        private Node SearchPrecursor(T item)
        {
            var precursor = _head;
            if (TEquals(item, precursor))
            {
                return _head;
            }
            while (precursor.next != null)
            {
                if (TEquals(item, precursor.next))
                {
                    return precursor;
                }
                precursor = precursor.next;
            }
            return null;
        }

        public void RemoveAt(int index)
        {
            T oldData;
            var removeTarget = this[index];
            var precursor = SearchPrecursor(removeTarget);
            if (precursor == null)
            {
                OnChanged();
                return;
            }
            if (precursor == _head && TEquals(removeTarget, precursor))
            {
                oldData = _head.data;
                _head = _head.next;
            }
            oldData = precursor.next.data;
            precursor.next = precursor.next.next;
            Count--;
            OnChanged();
        }

        private void Foreach(Action<Node> ac)
        {
            for (var iNode = _head; iNode != null; iNode = iNode.next)
            {
                ac(iNode);
            }
        }
        public void Display()
        {
            Foreach((Node iNode) => { Console.Write("{0} ", iNode.data); });
        }

    }
奇喑
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#事件：Event
New_BoKe的博客
06-19 151
无论是企业中使用的大型应用程序还是手机中安装的一个 App 都与事件密不可分。 例如在登录 QQ 软件时需要输入用户名和密码，然后单击“登录”按钮来登录 QQ，此时单击按钮的动 作会触发一个按钮的单击事件来完成执行相应的代码实现登录的功能。 在 C# 语言中，Windows 应用程序、 ASP.NET 网站程序等类型的程序都离不开事件的应用。 事件是一种引用类型，实际上也是一种特殊的委托。 通常，每一个事件的发生都会产生发送方和接收方，发送方是指引发事件的对象，接收方则是指获 取、处理事件。事件要与委托一起
C#event线程安全
01-27
在C#编程中，`event`关键字用于实现发布/订阅模式，它确保了代码的封装性和安全性。在多线程环境中，线程安全是至关重要的，尤其是涉及到共享数据时。在C#中，`event`的实现考虑了线程安全问题，尤其是在C#3.0和4.0...
C#事件(Event)Demo
07-26
写了一个简单的事件的例子，实现的功能就是热水器开始烧水，当水温达到一定温度后，警报器开始报警，屏幕也开始提示当前温度。
C#下的Event
weixin_34199405的博客
01-08 517
Event其实就是简化的Delegate，被用于Event的delegate只能进行 += （注册）和 -= (反注册)操作，其他的操作被限制了。Event其实是Observer模式在C#的built-in实现。
C# Event
DanielChen的博客
09-19 1774
Key Point  Demo  using System; namespace EventDemo { public class Program { static void Main(string[] args) { Friend f1 = new Friend("Alen"); Frie...
c# 事件（Event）机制
热门推荐
一颗偏执的心
10-24 1万+
重新熟悉一下委托和事件。 通过事件使用委托 事件在类中声明且生成，且通过使用同一个类或其他类中的委托与事件处理程序关联。包含事件的类用于发布事件。这被称为 发布器（publisher） 类。其他接受该事件的类被称为 订阅器（subscriber） 类。事件使用 发布-订阅（publisher-subscriber） 模型。 发布器（publisher） 是一个包含事件和委托定义的对象。事件和...
C# Onnx Ultra-Fast-Lane-Detection-v2 车道线检测 源码
11-01
C# Onnx Ultra-Fast-Lane-Detection-v2 车道线检测 源码 博客地址： https://blog.csdn.net/lw112190/article/details/134159886
c#实现HttpClient拼接multipart/form-data形式参数post提交数据
01-09
使用c#实现的HttpClient拼接multipart/form-data形式参数post提交数据，包含图片内容，有需要的可以下载，希望能帮到有需要的人，
C#事件(event)解析
01-27
事件(event)，这个词儿对于初学者来说，往往总是显得有些神秘，不易弄懂。而这些东西却往往又是编程中常用且非常重要的东西。大家都知道windows消息处理机制的重要，其实C#事件就是基于windows消息处理机制的，只是...
c#读取DLT645-2007电力协议，项目源码
10-04
这个项目源码是使用C#编程语言实现的，旨在帮助开发者实现对多块电表的数据读取、解析以及统计功能。下面我们将详细探讨这个项目涉及的关键知识点。 1. C#编程语言：C#是由微软开发的一种面向对象的编程语言，广泛...
c# 学习笔记之九 事件(event)的使用，一个简单例子揭示机理
CGGUANG的博客
11-22 3488
什么是事件？我们可否看做是一个或者若干个动作？是可以的，比如柚子表白事件，包含几个动作：1.摆柚子2.暖场舞蹈3.拿话筒表白。 一个事件包含几个动作，而每个动作都是一个函数，因为在C#中，函数就是做()，因此一个事件由几个函数组成。这么多函数，是用函数代表表示的。那么，什么是函数代表呢？可以这样认为，函数代表就是函数名。你说，函数的代表是不是函数名呢？当然是了。
快速失败(fail-fast)和安全失败(fail-safe)
潘建南的博客
12-05 301
1. 快速失败（fail—fast）      在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的内容进行了修改（增加、删除、修改），则会抛出Concurrent Modification Exception。       原理：迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使用一个 modCount 变量。集合在被遍历期间如果内容发生变化，就会改变modCount的值。每当迭代器...
关于快速报错fail-fast想说的之fail-fast的避免方法（二）
程序员
04-07 3141
上篇博文关于快速报错fail-fast想说的之fail-fast的实现原理（一） 讨论了fail-fast的基本知识及实现原理，了解了ArrayList的fail-fast在多线程工作下的缺陷，这篇博文说下解决办法，主要是讨论CopyOnWriteArrayList的用法。 注意，本文讨论的内容基于JDK 1.8 示例代码（一）1. 代码 public static void main(
C# 事件（Event）用法
weixin_41883890的博客
08-05 3662
任何现有的事件订阅者都是遵循经典模式的事件的订阅者。第二个参数：e是EventArgs类型 EventArgs类表示包含事件数据的类的基类，并提供用于不包含事件数据的事件的值。一个对象要想被作为事件监听器，需要将该对象中的事件处理程序 注册(或挂载)到另一个能够产生事件的对象（即事件源）上，这样会导致事件源必须保持一个到事件侦听器对象的引用，以便在事件发生时调用此侦听器的处理方法。这很合理，但如果这个引用是一个 强引用，则监听器会作为事件源的一个依赖 从而不能作为垃圾回收，即使引用它的对象是事件源。...
C#写一个检测软件崩溃的小工具，如果检测到软件的主线程崩溃或者退出则自动重启软件
最新发布
qq_64948696的博客
01-04 622
C#实现启动一个监控线程，定期检查目标软件是否崩溃或者已退出。 如果目标软件崩溃活已退出，则自动重新启动它。
C#中的事件（event）
Ivan_47的博客
10-13 1万+
事件模型（event model） 事件模型的5个组成部分 事件拥有者（event source）（类对象）（有些书将其称为事件发布者） 事件成员（event）（事件拥有者的成员）（事件成员就是事件本身，事件不会主动发生，其只会在事件拥有者的内部逻辑的触发下发生。） 事件响应者（event subscriber）（类对象）（有些书将其称为事件订阅者） 事件处理器（event handler）（事件的响应者的成员）（根据拿到的事件参数/信息对事件进行处理） 事件订阅（委托类型） 举个栗子：“裁判员开枪，运
C#---VS平台运行程序弹出Scriptedbox64.exe--Fail Fast Exception异常
weixin_41883890的博客
09-29 675
vs调试cordova app时 scriptedsandbox64.exe已停止工作的错误处理方法。有时候调试会启动失败，提示版本过低，再一次点击调试就可以了。2.去掉 选项-》调试-》调试时启动诊断工具。1.把ie更新到版本11。
C#中Delegate和Event的实现原理以及用法。
a395277988的专栏
09-28 2018
最近做项目，发现一些线程方法异常，查半天没有发现什么的地方能引发这些异常。具体看下面列子。 public class A A a = new A(); A b =a; object.ReferenceEquals(a, b)是返回true。 如果把a =null; 那么b是不是也是 null？ 其实不然，a赋值为null，只是a指向了一个null，b还是指向的 newA（）；如
C#中事件（event）
给永远比拿愉快
03-29 2702
事件基于委托，为委托提供了一种发布/订阅机制。在Windows应用程序中Button类提供了Click事件。触发Click事件时调用的处理程序方法需要定义，其参数由委托类型定义。 MSDN中对事件（event）的解释如下：类或对象可以通过事件向其它类或对象通知发生的相关事情。发送（或引发）事件的类称为“发行者”，接收（或处理）事件的类称为“订户”。 C#中使用事件需要如下步骤： （1）创建一

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值