private void InvokeHandlers(IEvent @event, IEnumerable<HandlerMethod> handlers)
        {
            foreach (var method in handlers)
            {
                object handler;

                try
                {
                    handler = HandlerActivator.CreateInstance(method.ReflectedType);
                }
                catch (Exception ex)
                {
                    throw new EventHandlerException("Fail to activate event handler: " + method.ReflectedType + ". See inner exception for details.", ex);
                }

                try
                {
                    method.Invoke(handler, @event);
                }
                catch (Exception ex)
                {
                    throw new EventHandlerException("Fail to execute event handler: " + method.ReflectedType + ". See inner exception for details.", ex);
                }
            }
        }

        public void FireEvent(
			IEvent @event)
        {
            string namespaceUri = @event.NamespaceUri;
            string eventType = @event.Type;
            for (int i = 0; i < count; i++)
            {
            // Check if the entry was added during this phase
            if (entries[i].Locked)
              continue;

                string entryNamespaceUri = entries[i].NamespaceUri;
                string entryEventType = entries[i].Type;

                if (entryNamespaceUri != null && namespaceUri != null)
                {
                    if (entryNamespaceUri != namespaceUri)
                    {
                        continue;
                    }
                }

                if (entryEventType != eventType)
                {
                    continue;
                }

                entries[i].Listener(@event);
            }
        }

 public void EmulatorQuit(IEvent e)
 {
     foreach (var a in _gameEndedActions)
     {
         a.Invoke();
     }
 }

        /// <summary>
        /// Tries to parse the given data to the target <see cref="IEvent"/>.
        /// </summary>
        /// <param name="eventParams">List of string-parameters to parse.</param>
        /// <param name="target">Target instance to parse the data to.</param>
        /// <returns><c>true</c> if the parsing was succesful, otherwise <c>false</c> is returned.</returns>
        public bool TryParse(List<string> eventParams, IEvent target)
        {
            if (eventParams.Count < 4)
            {
                return false;
            }

            if (string.IsNullOrEmpty(eventParams[0]))
            {
                return false;
            }

            float posX, posY, posZ;
            if( !float.TryParse(eventParams[1], out posX) ||
                !float.TryParse(eventParams[2], out posY) ||
                !float.TryParse(eventParams[3], out posZ) )
            {
                return false;
            }

            if (!target.HasProperty("EntityName") || !target.HasProperty("Target"))
            {
                return false;
            }

            UnityEngine.Vector3 targetPosition = new UnityEngine.Vector3();
            targetPosition.x = posX;
            targetPosition.y = posY;
            targetPosition.z = posZ;

            target.SetProperty("EntityName", eventParams[0]);
            target.SetProperty("Target", targetPosition);
            return true;
        }

		/// <summary>
		/// Copy constructor
		/// </summary>
		protected DefaultEvent(IEvent ev)
			: base(ev)
		{
			this.addAccessor = ev.AddAccessor;
			this.removeAccessor = ev.RemoveAccessor;
			this.invokeAccessor = ev.InvokeAccessor;
		}

 public void Publish(IEvent eventMessage)
 {
     foreach (var bus in _wrappedBuses)
     {
         bus.Publish(eventMessage);
     }
 }

    /// <summary>
    /// This method will handle sending an event to a client.
    /// </summary>
    public static void SendEventToClient(string ipAddress, int port, IEvent evnt)
    {
      try
      {
        var client = new TcpClient(ipAddress, port);

        // TODO: Serialize the event into json...
        string json = JsonConvert.SerializeObject(evnt);
        byte[] data = System.Text.Encoding.Unicode.GetBytes(json);

        // Get a client stream for reading and writing.
        var stream = client.GetStream();
        stream.Write(data, 0, data.Length);

        Console.WriteLine("Sent: {0}", json);

        // Close everything.
        stream.Close();
        client.Close();
      }
      catch (ArgumentNullException e)
      {
        Console.WriteLine("ArgumentNullException: {0}", e);
      }
      catch (SocketException e)
      {
        Console.WriteLine("SocketException: {0}", e);
      }
    }

 void IEventHelpers.RegisterSocketRead(IEvent e, BufferedSocket socket, IEventHandler protocol,
                                       ReadFunction callback)
 {
     //Contract.Requires(socket != null);
     Contract.Requires(protocol != null);
     Contract.Requires(callback != null);
 }

        public EventMessage(IEvent source)
        {
            if (source == null)
                throw new ArgumentNullException("source");

            sourceMeta = new Dictionary<string, object>();
            eventMeta = new Dictionary<string, object>();

            var eventSource = source.EventSource;
            while (eventSource != null) {
                foreach (var meta in source.EventSource.Metadata) {
                    sourceMeta[meta.Key] = meta.Value;
                }

                eventSource = eventSource.ParentSource;
            }

            if (source.EventData != null) {
                foreach (var pair in source.EventData) {
                    eventMeta[pair.Key] = pair.Value;
                }
            }

            TimeStamp = source.TimeStamp;
        }

 public void run(IEvent e)
 {
     BoardMovedNotify notify = new BoardMovedNotify();
     this.boardMachine.fireStateChangedNotification(notify);
     LOG.Info(NAME);
     this.boardMachine.consumeEvent(new BoardReadyEvent());
 }

        public static bool CreateEvent(IEvent thisEvent)
        {
            if (Connect())
            {
                try
                {
                    SqlCommand Command = Connection.CreateCommand();
                    Command.CommandType = CommandType.StoredProcedure;
                    Command.CommandText = "fif_event_create";

                    Command.Parameters.AddWithValue("name", thisEvent.Name);
                    Command.Parameters.AddWithValue("price", thisEvent.Price);
                    Command.Parameters.AddWithValue("description", thisEvent.Description);
                    Command.Parameters.AddWithValue("start_period", thisEvent.StartPeriod);
                    Command.Parameters.AddWithValue("end_period", thisEvent.EndPeriod);
                    Command.Parameters.AddWithValue("max_number_of_participants", thisEvent.MaxNumberOfParticipants);

                    Command.Parameters.Add("@activity_id", SqlDbType.Int, 0, "activity_id");
                    Command.Parameters["@activity_id"].Direction = ParameterDirection.Output;

                    Command.ExecuteNonQuery();

                    thisEvent.ActivityId = int.Parse(Command.Parameters["@activity_id"].Value.ToString());

                    Disconnect();
                    return true;
                }
                catch
                {
                    Disconnect();
                    return false;
                }
            }
            return false;
        }

        private void LoadIEvent()
        {
            if (_ievent == null)
            {
                if (this.ScheduleType == null)
                {
                    Logger.LogInfo("计划任务没有定义其 type 属性");
                    
                }

                Type type = Type.GetType(this.ScheduleType);
                if (type == null)
                {
                    Logger.LogInfo(string.Format("计划任务 {0} 无法被正确识别", this.ScheduleType));
                }
                else
                {
                    _ievent = (IEvent)Activator.CreateInstance(type);
                    if (_ievent == null)
                    {
                        Logger.LogInfo(string.Format("计划任务 {0} 未能正确加载", this.ScheduleType));
                    }
                }
            }
        }

        /// <summary>
        /// Converts event to <c>string</c> representation.
        /// </summary>
        /// <param name="Event">Event to be converted to <c>string</c></param>
        /// <returns>Returns resulting <c>string</c>.</returns>
        public static string EventToString( IEvent Event )
        {
            StringBuilder builder = new StringBuilder( 200 );
            builder.Append( "[Type=" );
            builder.Append( Event.Type.ToString() );

            if( Event.Description!=null )
            {
                builder.Append( "][Message=" );
                builder.Append( Event.Description );
            }

            if( Event.Sender != null )
            {
                builder.Append( "][ModelID=" );
                builder.Append( ((ILinkableComponent) Event.Sender).ModelID );
            }

            if( Event.SimulationTime != null )
            {
                builder.Append( "][SimTime=" );
                builder.Append( CalendarConverter.ModifiedJulian2Gregorian(Event.SimulationTime.ModifiedJulianDay).ToString() );
            }

            builder.Append( ']' );

            return( builder.ToString() );
        }

 /// <summary>
 /// Listen for VirtualBox events.
 /// </summary>
 /// <param name="aEvent">VirtualBox event</param>
 void IEventListener.HandleEvent(IEvent aEvent)
 {
     if (aEvent.Type == VBoxEventType.VBoxEventType_OnMachineStateChanged)
     {
         vboxServer.UpdateServersState();
     }
 }

        /// <summary>
        /// Gets a string of all data properties of the passed <see cref="IEvent"/>.
        /// Format-Example: Name0: Value0, ..., NameN: ValueN
        /// </summary>
        /// <param name="e"><see cref="IEvent"/> to create data string from.</param>
        /// <returns>String representing the <see cref="IEvent"/> data.</returns>
        public static string GetEventDataAsString(IEvent e)
        {
            string data = "";

            if (e != null)
            {
                int i = 0;
                foreach (PropertyInfo property in e.GetType().GetProperties())
                {
                    if (GetNamesOfProperties().Contains(property.Name))
                    {
                        continue;
                    }

                    if (i > 0)
                    {
                        data += ", ";
                    }
                    data += string.Format("{0}: {1}", property.Name, property.GetValue(e, null));
                    i++;
                }
            }

            return data;
        }

        /// <summary>
        /// Deconstructs the contexts request into a set of prameters for the context.
        /// </summary>
        /// <remarks>
        /// The deafult implementation uses the convention of `/area/concern/action.aspc/tail?querystring`
        /// </remarks>
        /// <param name="ev">The vent that was considered for this action.</param>
        /// <param name="context">The context to act upon.</param>
        public override void Action(IEvent ev, IWebContext context)
        {
            // eliminate the app directory from the path
            string path = _appDirectory.Length > 0 ? context.Request.UrlInfo.AppPath.Trim('/').Replace(_appDirectory, "") : context.Request.UrlInfo.AppPath;
            path = path.Trim('/');

            if (!String.IsNullOrEmpty(context.Request.UrlInfo.File)) {
                context.Params["action"] = context.Request.UrlInfo.File.Split('.')[0].ToLower();

                string[] parts = path.Split('/');
                if (parts.Length >= 2) {
                    context.Params["area"] = parts[parts.Length - 2].ToLower();
                    context.Params["concern"] = parts[parts.Length - 1].ToLower();
                } else if (parts.Length == 1) {
                    context.Params["area"] = parts[0];
                }
            }

            // import query string and form values
            context.Params.Import(context.Request.Params.Where(kv => !kv.Key.StartsWith("_")));
            // establish flags
            foreach (string flag in context.Request.Flags.Where(f => !f.StartsWith("_"))) {
                context.Flags.Add(flag);
            }
            context.Params.Import(context.Request.Headers);
            // note method and tail
            context.Params["method"] = context.Request.Method;
            context.Params["tail"] = context.Request.UrlInfo.Tail;
            string requestViews = String.Join(";", context.Request.UrlInfo.Tail.Split(new string[] {"/"}, StringSplitOptions.RemoveEmptyEntries));
            if (!String.IsNullOrEmpty(requestViews)) {
                context.Params["views"] = requestViews;
            }
        }

 public void ProcessEvent(IEvent Event)
 {
     lock (_milliSeconds)
     {
         //_milliSeconds.Enqueue(DateTime.Now.Subtract(((InboundConnectionClosedEvent)Event).StartTime).TotalMilliseconds);
     }
 }

 protected override IValidationResultCollection ValidateEvent(IEvent evt)
 {
     return ValidationResult.GetCompositeResults(
         ResourceManager,
         new PropertyCountValidation(ResourceManager, evt, "VEVENT", "LAST-MODIFIED")
     );
 }

 public void Execute(IEvent eEvent)
 {
     if (UserSettings.Instance.IsFirstRun())
     {
         Plugin.Instance.OpenInfoWindow();
     }
 }

    public bool HandleEvent(IEvent @event)
    {
        var sceneChangeEvent = @event as SceneChangeEvent;
        if (sceneChangeEvent == null)
        {
            return true;
        }

        var data = @event.GetData() as string;
        if (data == null)
        {
            return true;
        }

        try
        {
            this.currentScene = (SceneNames)Enum.Parse(typeof(SceneNames), data, ignoreCase: true);
        }
        catch
        {
            // do nothing
        }

        return true;
    }