如何处理C＃中事件委托的返回值？

Question

因此，我感到很好奇，因为我开发的越多，就越有从事件中获取数据的用途，因此，我四处张望，并指出，处理事件响应的信息方式不多代表。

拥有一个具有返回值的委托，执行所述委托的方法，并获取其返回值是一回事，但是当事件触发众多委托时，您会怎么做？ 您如何确定每个代表的情况？

Answer 1

public delegate object GetObject();
public event GetObject MyEvent;

public IList<object> RaiseMyEvent()
{
    var myList = new List<object>();
    if (MyEvent != null)
        foreach (var handler in MyEvent.GetInvocationList())
            myList.Add(handler.DynamicInvoke());
    return myList;
}

Answer 2

• 问答风格-

因为该主题上的可用信息很少，并且因为它是如此多样化，所以我选择提出一些带有一点风格的东西-我认为这是一个相当彻底的“事件响应处理程序”。

在下面的代码示例中（我刚刚用最新的演示文稿进行了更新（更多内容，很有可能）），您将找到支持事件触发以及最终从随后执行的任何方法返回数据的代码。 用于将数据传递给事件委托的'Event'类最终将包含一组EventResults，可以在以后进行评估。 这使开发人员能够在触发事件后响应失败的委托。

第一类是“事件”，其中包含一些变量，可以为您的委托人提供一些有价值的反馈-诸如事件来自哪个对象，简单的字符串消息，关联的堆栈等。

事件类还包含“ EventResponses”的集合； 这使我们进入了第二堂课……EventResponse。 此类有两种“类型”。 可以立即为子执行提供反馈。

这是通过EventResponse构造函数中对'SourceEvent'的要求实现的； 并通过执行'EventResponse.FinalizeResponse'方法-将事件响应添加到关联的事件。 我刚刚将EventResponse修改为Disposable，然后在Disposal中，检查了EventResponse的SourceEvent，如果SourceEvent不包含我要处置的EventResponse的条目，请创建新的EventResponse副本，然后运行对新副本的FinalizeResponse。

所有这些功能的最终价值是广泛的-如果您注意到一个事件在Event类中称为“ OnResponseFailure”，并且类似地在该事件上使用“ AddResponse”方法，则您会注意到，当事件遇到被认为是“失败”的响应； 它本身会引发一个事件，以潜在地通知初始调用方法。

Event类还包含几个字段，可用于分析响应中的失败或成功。 我会留给你走一走。

同样，EventResponse类包含一些字段，可用于在需要时将更多数据返回到发起事件的方法中，例如响应的源对象和消息。

我希望这是一个有用的问答-因为我认为这将极大地帮助我创建健壮的响应式代码。 狩猎愉快。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;

namespace MyNamespace.Events
{
    public class EventDriver : IDisposable
    {
        #region Supporting Events
        public List<EventResponse> FireEvent(String EventName, Event Event)
        {
            List<EventResponse> ResponseList = new List<EventResponse>();

            Type LocalType = this.GetType();

            Type TargetType = null;

            if ((TargetType = this.FindEventType(LocalType, EventName)) == null)
            {
                return ResponseList;
            }
            else
            {
                FieldInfo TargetField = TargetType.GetField(EventName, BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);

                MulticastDelegate EventDelegates = (MulticastDelegate) TargetField.GetValue(this);

                if (EventDelegates == null)
                {
                    return ResponseList;
                }
                else
                {
                    foreach (Delegate TargetDelegate in EventDelegates.GetInvocationList())
                    {
                        try
                        {
                            Object DelegateResponse = TargetDelegate.DynamicInvoke(new Object[] { Event });
                            EventResponse Response = (EventResponse)DelegateResponse;
                            ResponseList.Add(Response);
                        }
                        catch (Exception e)
                        {
                        }
                    }

                    return ResponseList;
                }
            }
        }

        private Type FindEventType(Type RootType, String EventName)
        {
            if (RootType == null)
            {
                return null;
            }
            else if (String.IsNullOrEmpty(EventName))
            {
                return null;
            }
            else
            {
                FieldInfo EventField = null;

                foreach (FieldInfo Method in RootType.GetFields(BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public))
                    if (Method.Name == EventName)
                    {
                        EventField = Method;
                        break;
                    }

                if (EventField == null)
                {
                    if (RootType.BaseType == null)
                        return null;
                    else
                        return this.FindEventType(RootType.BaseType, EventName);
                }
                else
                {
                    return RootType;
                }
            }
        }
        #endregion

        #region Dispoability
        public virtual void Dispose()
        {
            this.FireEvent("OnDispose", new Event(this, "Object is being disposed."));
        }
        #endregion
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Reflection;

namespace MyNamespace.Events
{
    #region Delegates
    public delegate EventResponse EventHandler(Event Event);
    #endregion

    #region Enumerations
    public enum EventResponseType
    {
        Success, Failure
    }
    #endregion

    public class Event
    {
        #region Events
        public event EventHandler OnResponseFailure = null;
        #endregion

        #region Fields
        public Object EventSource = null;

        public DateTime EventTime = DateTime.Now;

        public String EventMessage = String.Empty;

        protected StackTrace _EventStackTrace = null;

        public StackTrace EventStackTrace
        {
            get
            {
                return this._EventStackTrace;
            }
        }

        protected List<EventResponse> _EventResponses = null;

        public List<EventResponse> EventResponses
        {
            get
            {
                List<EventResponse> EventResponses = new List<EventResponse>();

                lock (this._EventResponses)
                {
                    foreach (EventResponse Response in this._EventResponses)
                        EventResponses.Add(Response);
                }

                return EventResponses;
            }
        }

        public Boolean HasFailedResponses
        {
            get
            {
                if (this.FailedResponses.Count > 0)
                    return true;
                return false;
            }
        }

        public Boolean HasSuccessfulResponses
        {
            get
            {
                if (this.SucceessfulResponses.Count > 0)
                    return true;
                return false;
            }
        }

        public List<EventResponse> FailedResponses
        {
            get
            {
                List<EventResponse> FailedResponses = new List<EventResponse>();

                foreach (EventResponse Response in this.EventResponses)
                    if (Response.ResponseType == EventResponseType.Failure)
                        FailedResponses.Add(Response);
                return FailedResponses;
            }
        }

        public List<EventResponse> SucceessfulResponses
        {
            get
            {
                List<EventResponse> SucceededResponses = new List<EventResponse>();

                foreach (EventResponse Response in this.EventResponses)
                    if (Response.ResponseType == EventResponseType.Success)
                        SucceededResponses.Add(Response);
                return SucceededResponses;
            }
        }

        protected List<Event> _ForwardedEvents = null;

        public List<Event> ForwardedEvents
        {
            get
            {
                List<Event> FowardedEvents = new List<Event>();

                lock (this._ForwardedEvents)
                    foreach (Event ForwardedEvent in this.ForwardedEvents)
                        ForwardedEvents.Add(ForwardedEvent);

                return ForwardedEvents;
            }
        }
        #endregion

        #region Constructors
        protected Event()
        {
            this._EventResponses = new List<EventResponse>();
            this._EventStackTrace = new StackTrace();
            this._ForwardedEvents = new List<Event>();
        }

        public Event(Object EventSource, String EventMessage, DateTime EventTime)
            : this()
        {
            this.EventSource = EventSource;
            this.EventTime = EventTime;
            this.EventMessage = EventMessage;

            return;
        }

        public Event(Object EventSource, String EventMessage)
            : this(EventSource, EventMessage, DateTime.Now)
        {
        }
        #endregion

        #region Supporting Methods
        public void AddResponse(EventResponse Response)
        {
            lock (this._EventResponses)
            {
                this._EventResponses.Add(Response);
            }

            if (Response.ResponseType == EventResponseType.Failure)
                this.TriggerResponseFailure(Response);

            return;
        }

        public EventResponse CreateResponse()
        {
            return new EventResponse(this);
        }

        public EventResponse CreateResponse(Object ResponseSource, Object ResponseObject, DateTime ResponseTime, String ResponseMessage, EventResponseType ResponseType)
        {
            return new EventResponse(this, ResponseSource, ResponseObject, ResponseTime, ResponseMessage, ResponseType);
        }

        public EventResponse CreateResponse(Object ResponseSource, Object ResponseObject, DateTime ResponseTime, EventResponseType ResponseType)
        {
            return this.CreateResponse(ResponseSource, ResponseObject, ResponseTime, String.Empty, ResponseType);
        }

        public EventResponse CreateResponse(Object ResponseSource, Object ResponseObject, DateTime ResponseTime)
        {
            return this.CreateResponse(ResponseSource, ResponseObject, ResponseTime, EventResponseType.Success);
        }

        public EventResponse CreateResponse(Object ResponseSource, Object ResponseObject, EventResponseType ResponseType)
        {
            return this.CreateResponse(ResponseSource, ResponseObject, DateTime.Now, ResponseType);
        }

        public EventResponse CreateResponse(Object ResponseSource, Object ResponseObject)
        {
            return this.CreateResponse(ResponseSource, ResponseObject, EventResponseType.Success);
        }

        public EventResponse CreateResponse(Object ResponseSource, String ResponseMessage)
        {
            return this.CreateResponse(ResponseSource, null, DateTime.Now, ResponseMessage, EventResponseType.Success);
        }

        public EventResponse CreateResponse(String ResponseMessage)
        {
            return this.CreateResponse(null, ResponseMessage);
        }

        public EventResponse CreateResponse(Object ResponseSource)
        {
            return this.CreateResponse(ResponseSource, String.Empty);
        }

        public Event Forward(Object ForwardFrom)
        {
            Event ForwardedEvent = new Event(ForwardFrom, this.EventMessage, this.EventTime);

            lock (this._ForwardedEvents)
                this._ForwardedEvents.Add(ForwardedEvent);

            return ForwardedEvent;
        }
        #endregion

        #region Event Triggers
        protected void TriggerResponseFailure(EventResponse Response)
        {
            if (this.OnResponseFailure != null)
                this.OnResponseFailure(new Event(Response, "A failure was encountered while executing this event."));
            return;
        }
        #endregion
    }

    public class EventResponse : IDisposable
    {
        #region Fields
        protected Event _SourceEvent = null;

        public Event SourceEvent
        {
            get
            {
                return this._SourceEvent;
            }
        }

        public Object ResponseSource = null;

        public Type ResponseSourceType
        {
            get
            {
                return this.ResponseSource.GetType();
            }
        }

        public Object ResponseObject = null;

        public Type ResponseObjectType
        {
            get
            {
                return this.ResponseObject.GetType();
            }
        }

        public DateTime ResponseTime = DateTime.Now;

        public String ResponseMessage = String.Empty;

        protected StackTrace _ResponseStackTrace = null;

        public StackTrace ResponseStackTrace
        {
            get
            {
                return this._ResponseStackTrace;
            }
        }

        public EventResponseType ResponseType = EventResponseType.Success;
        #endregion

        #region Constructors
        public EventResponse(Event SourceEvent)
        {
            this._SourceEvent = SourceEvent;

            this._ResponseStackTrace = new StackTrace();
        }

        public EventResponse(Event SourceEvent, Object ResponseSource, Object ResponseObject, DateTime ResponseTime, String ResponseMessage, EventResponseType ResponseType)
            : this(SourceEvent)
        {
            this.ResponseSource = ResponseSource;
            this.ResponseObject = ResponseObject;
            this.ResponseTime = ResponseTime;
            this.ResponseMessage = ResponseMessage;
            this.ResponseType = ResponseType;

            return;
        }

        public EventResponse(Event SourceEvent, Object ResponseSource, Object ResponseObject, DateTime ResponseTime, EventResponseType ResponseType)
            : this(SourceEvent,ResponseSource,ResponseObject,ResponseTime,String.Empty,ResponseType)
        {
        }

        public EventResponse(Event SourceEvent, Object ResponseSource, Object ResponseObject, DateTime ResponseTime)
            : this(SourceEvent, ResponseSource, ResponseObject, ResponseTime, EventResponseType.Success)
        {
        }

        public EventResponse(Event SourceEvent, Object ResponseSource, Object ResponseObject, EventResponseType ResponseType)
            : this(SourceEvent, ResponseSource, ResponseObject, DateTime.Now, ResponseType)
        {
        }

        public EventResponse(Event SourceEvent, Object ResponseSource, Object ResponseObject)
            : this(SourceEvent, ResponseSource, ResponseObject, EventResponseType.Success)
        {
        }

        public EventResponse(Event SourceEvent, Object ResponseSource, EventResponseType ResponseType)
            : this(SourceEvent, ResponseSource, null, DateTime.Now, String.Empty, ResponseType)
        {

        }

        public EventResponse(Event SourceEvent, Object ResponseSource, String ResponseMessage)
            : this(SourceEvent, ResponseSource, null, DateTime.Now, ResponseMessage, EventResponseType.Success)
        {

        }

        public EventResponse(Event SourceEvent, String ResponseMessage)
            : this( SourceEvent, null, ResponseMessage )
        {
        }
        #endregion

        #region Supporting Methods
        public void FinalizeResponse()
        {
            this.SourceEvent.AddResponse(this);
            return;
        }
        #endregion

        #region Overrides
        public void Dispose()
        {
            if (this.SourceEvent == null)
                return;
            else if (this.SourceEvent.EventResponses.Contains(this))
                return;
            else
            {
                EventResponse NewResponse = new EventResponse(this.SourceEvent, this.ResponseSource, this.ResponseObject, this.ResponseTime, this.ResponseMessage, this.ResponseType);
                NewResponse.FinalizeResponse();
                return;
            }
        }
        #endregion
    }
}

我很有可能会对所有这些进行更多更改，添加更多的构造函数，并重写方法-但这是我当前正在使用的代码的版本，它对我来说是出色的。

这里的建议是用'EventDriver'类扩展'base'类-这将使您能够使用'EventDriver.FireEvent'方法-将返回由特定事件生成的所有EventResponses。

所有这些都是相当“ beta”的，就像我说的那样，我仍然会进行更改，但是随着我进行进一步的操作，此更改将相应地进行更新。 请享用 ：）

Answer 3

通常，将引发一个事件的代码，该事件的订户应返回其订户应返回信息，该代码将向其订户传递一个事件对象，该事件对象具有订户可以在其中放置信息的字段或订户可以向其提供信息的对象。 在只有第一个有话要说的用户感兴趣的情况下，首选使用前一种用法。 在许多订户都可能要添加一些内容的情况下，最好使用后一种用法。