C# EventData类代码示例

 /// <summary>
 /// Notifies peer about item exited area.
 /// </summary>
 public override void OnItemExit(Item item)
 {
     base.OnItemExit(item);
     var unsubscribeEvent = new ItemUnsubscribed { ItemId = item.Id, InterestAreaId = this.Id };
     var eventData = new EventData((byte)EventCode.ItemUnsubscribed, unsubscribeEvent);
     this.peer.SendEvent(eventData, new SendParameters { ChannelId = Settings.ItemEventChannel });
 }

        private void WriteJsonEntry(EventData e)
        {
            _writer.WriteStartObject();

            _writer.WritePropertyName("index");

            // Write the batch "index" operation header
            _writer.WriteStartObject();
            // ES index names must be lower case and cannot contain whitespace or any of the following characters \/*?"<>|,
            WriteValue("_index", this.GetIndexName(e.EnqueuedTimeUtc));
            WriteValue("_type", _entryType);

            _writer.WriteEndObject();
            _writer.WriteEndObject();
            _writer.WriteRaw("\n");  //ES requires this \n separator

            var payload = JObject.Parse(Encoding.UTF8.GetString(e.GetBytes()));

            foreach (var property in e.Properties)
            {
                payload.Add("Properties-" + property.Key, new JValue(property.Value));
            }

            _writer.WriteRaw(payload.ToString(Formatting.None));
            
            _writer.WriteRaw("\n");
        }

        //This method is used to handle the event when it's raised
        void MyEventHandler(Object sender, EventData e)
        {
            // Wait until safe to run
            mut.WaitOne();
            // Write to console
            Console.WriteLine(Name.PadRight(15) + e.stockName.PadRight(15) +
                              e.currentValue.ToString().PadRight(15) +
                              e.numOfChange.ToString());
            // This text is added only once to the file.
            if (!File.Exists(path))
            {
                // Create a file to write to.
                using (StreamWriter sw = File.CreateText(path))
                {
                    //Write the table header to the file
                    sw.WriteLine("Broker".PadRight(15) + "Stock".PadRight(15) +
                                 "Value".PadRight(15) + "Changes".PadRight(15) +
                                 "\r\n");
                }
            }

            // This text is always added, making the file longer over time
            // if it is not deleted.
            using (StreamWriter sw = File.AppendText(path))
            {
                //Write the event data to the file
                sw.WriteLine(Name.PadRight(15) + e.stockName.PadRight(15) +
                              e.currentValue.ToString().PadRight(15) +
                              e.numOfChange.ToString());
            }
            // Release mutex
            mut.ReleaseMutex();
        }

 public void OnEvent(EventData eData)
 {
     if (eData.eventType == "EQUIPPED_UPDATE") {
         // Update equipped items dictionary
         equippedItems = ClientAPI.ScriptObject.GetComponent<Inventory>().EquippedItems;
     }
 }

 /// <summary>
 /// 类型：方法
 /// 名称：EnterWorldEventArgs
 /// 作者：taixihuase
 /// 作用：用任意角色进入场景所感兴趣的数据构造事件数据
 /// 编写日期：2015/7/22
 /// </summary>
 /// <param name="eventData"></param>
 public WorldEnterEventArgs(EventData eventData)
 {
     Character character = (Character)
         Serialization.Deserialize(eventData.Parameters[(byte) ParameterCode.WorldEnter]);
     AnyCharacter = character;
     MyCharacterPosition = null;
 }

        IList<IEvent> IEventBuilder.Build(string xml)
        {
            IList<IEvent> events = new List<IEvent>();

            if (String.IsNullOrEmpty(xml))
            {
                return events;
            }

            xml = xml.EscapeWhiteSpace();

            //get out quick if no data
            if (REGEX.IsMatch(xml))
            {
                return events;
            }

            XmlDocument doc = new XmlDocument();
            doc.LoadXml(xml);

            XmlNodeList eventNodes = doc.SelectNodes(String.Format("//{0}", EVENT));

            if (eventNodes != null)
            {
                foreach (XmlNode eventNode in eventNodes)
                {
                    IEvent e = new EventData(eventNode);
                    events.Add(e);
                }
            }

            return events;
        }

 private void OnBroadcastMessage(ChatPeer peer, EventData @event, SendParameters sendParameters)
 {
     if (peer != this)
     {
         this.SendEvent(@event, sendParameters);
     }
 }

        public async Task SendBatch()
        {
            var msgs = new EventData[] { new EventData(Guid.NewGuid().ToByteArray()), new EventData(Guid.NewGuid().ToByteArray()), new EventData(Guid.NewGuid().ToByteArray()), new EventData(Guid.NewGuid().ToByteArray()) };

            var bq = new HubClient(EventHubClient.CreateFromConnectionString(connection, this.name));
            await bq.Send(msgs);
        }

 public override void OnEvent(EventData eventData) {
     SubCode subcode = ParameterTool.GetParameters<SubCode>(eventData.Parameters, ParameterCode.SubCode, false);
     switch(subcode)
     {
         case SubCode.GetTeam:
             List<Role> list = ParameterTool.GetParameters<List<Role>>(eventData.Parameters, ParameterCode.RoleList);
             int masterRoleID = ParameterTool.GetParameters<int>(eventData.Parameters, ParameterCode.MasterRoleID, false);       
              //组队成功
             if (OnGetTeam != null)
                 OnGetTeam(list, masterRoleID);
             break;
         case SubCode.AsyncPostionAndEularAngler:
             int roleid = ParameterTool.GetParameters<int>(eventData.Parameters, ParameterCode.RoleID,false);
             Vector3 pos = ParameterTool.GetParameters<Vector3Obj>(eventData.Parameters, ParameterCode.Postion).ToVector3();
             Vector3 eularAnglers = ParameterTool.GetParameters<Vector3Obj>(eventData.Parameters, ParameterCode.EulerAnglers).ToVector3();
             if (OnAsyncPostionAndRotation != null)
                 OnAsyncPostionAndRotation(roleid, pos, eularAnglers);
             break;
         case SubCode.AsyncPlayerMoveAnimation:
             int roleid2 = ParameterTool.GetParameters<int>(eventData.Parameters, ParameterCode.RoleID, false);
             PlayerMoveAnimationModel model = ParameterTool.GetParameters<PlayerMoveAnimationModel>(eventData.Parameters, ParameterCode.PlayerMoveAnimationModel);
             if (OnAsyncPlayerMoveAnimation != null)
                 OnAsyncPlayerMoveAnimation(roleid2, model);
             break;
         case SubCode.SyncPlayerAnimation:
             int roleid3 = ParameterTool.GetParameters<int>(eventData.Parameters, ParameterCode.RoleID, false);
             PlayerAnimationModel animationModel = ParameterTool.GetParameters<PlayerAnimationModel>(eventData.Parameters, ParameterCode.PlayerAnimationModel);
             if(OnSyncPlayerAnimation!=null)
             {
                 OnSyncPlayerAnimation(roleid3, animationModel);
             }
             break;
     }
 }

        public void EventDataEqualityTest()
        {
            var dateTimeOffset = DateTimeOffset.Now;

            var left = new EventData
            {
                Name = "name",
                Data = "somedata",
                Ttl = 50,
                PublishedAt = dateTimeOffset,
                DeviceId = "coreid"
            };

            var right = new EventData
            {
                Name = "name",
                Data = "somedata",
                Ttl = 50,
                PublishedAt = dateTimeOffset,
                DeviceId = "coreid"
            };

            Assert.AreEqual(left.GetHashCode(), right.GetHashCode());
            Assert.AreEqual(left, right);
        }

        public void Save(MainViewModel viewModel)
        {
            GestSpaceData space = new GestSpaceData();
            foreach(var tileVm in viewModel.Tiles.Where(t => !t.IsUnused))
            {
                var tile = new TileData();
                space.Tiles.Add(tile);
                if(!tileVm.TakeSuggestedName)
                {
                    tile.ForcedName = tileVm.Description;
                }
                tile.X = (int)tileVm.Position.X;
                tile.Y = (int)tileVm.Position.Y;
                if(tileVm.SelectedPresenterTemplate != null)
                    tile.PresenterTemplate = tileVm.SelectedPresenterTemplate.Description;
                if(tileVm.SelectedGestureTemplate != null)
                    tile.GestureTemplate = tileVm.SelectedGestureTemplate.Name;

                tile.Program = tileVm.FastContext;
                foreach(var evtVm in tileVm.Events)
                {
                    var evt = new EventData();
                    tile.Events.Add(evt);
                    evt.Name = evtVm.Name;
                    if(evtVm.Command != null)
                        evt.Command = evtVm.Command.Script;
                }
            }
            if(viewModel.CurrentTile != null)
            {
                space.LastX = (int)viewModel.CurrentTile.Position.X;
                space.LastY = (int)viewModel.CurrentTile.Position.Y;
            }
            Save(space);
        }

        static bool sendMessage(string deviceLocation, string dateTime)
        {
            // build a connection string
            string connectionString = String.Format("Endpoint=sb://stardemo.servicebus.windows.net/;SharedAccessKeyName=WebAppWrite;SharedAccessKey", Environment.GetEnvironmentVariable("EventHubKey"));
            string name = "stardemo";

            // set up the event-hub communicator
            EventHubClient myEventHub = EventHubClient.CreateFromConnectionString(connectionString, name);

            // build the message and encode for sending
            string message = String.Format("{location:{0},datetime:{1}}", deviceLocation,dateTime);
            EventData myEventData = new EventData(Encoding.UTF8.GetBytes(message));

            // try and send the message
            bool success = false;
            try
            {
                myEventHub.Send(myEventData);
                success = true; // hooray!
            }
            catch (Exception)
            {
                // that didn't work, now what?
                throw;
            }
            return success;
        }

    public void Run() {
      lock (this.m_instanceLock) {
        EventData data = new EventData();

        this.m_runningThread = Thread.CurrentThread;

        while (!this.m_isShuttingDown) {
          lock (this.m_events) {
            LinkedListNode<EventData> firstItem = this.m_events.First;
            if (firstItem != null) {
              data = firstItem.Value;
              this.m_events.RemoveFirst();
            } else {
              data.Function = null;
              data.Parameters = null;
            }
          }

          if (data.Function == null) {
            this.m_eventsWaiting.WaitOne();
          } else {
            data.Function.DynamicInvoke(data.Parameters);
            if (data.Executed != null) {
              data.Executed.Set();
            }
          }
        }

        this.m_shutdownCompleteEvent.Set();
      }
    }

    public override void OnEvent(EventData eventData)
    {
        SubCode subcode = ParameterTool.GetSubCode(eventData.Parameters);
        switch (subcode)
        {
            case SubCode.CreateEnemy:
                CreateEnemyModel model = ParameterTool.GetParameter<CreateEnemyModel>(eventData.Parameters,
                    ParameterCode.CreateEnemyModel);
                if (OnCreateEnemy != null)
                {
                    OnCreateEnemy(model);
                }
                break;
            case SubCode.SyncPositionAndRotation:
                EnemyPositionModel model1 = ParameterTool.GetParameter<EnemyPositionModel>(eventData.Parameters,
                    ParameterCode.EnemyPositionModel);
                if (OnSyncEnemyPositionAndRotation != null)
                {
                    OnSyncEnemyPositionAndRotation(model1);
                }
                break;

            case SubCode.SyncAnimation:
                EnemyAnimationModel model2 = ParameterTool.GetParameter<EnemyAnimationModel>(eventData.Parameters,ParameterCode.EnemyAnimationModel);
                if (OnSyncEnemyAnimation != null)
                {
                    OnSyncEnemyAnimation(model2);
                }
                break;
        }
    }

 private void SendDeviceEventStream(EventHubClient eventHubClient)
 {
     var allEvents = new List<EventData>();
     for (int i = 0; i < DeviceSendingDetails.NumberOfDevices; i++)
     {
         string deviceName = "device" + i;
         var rand = new Random();
         // set up the modifier to enable 
         float modifier = 1.0F;
         if (DeviceSendingDetails.FailureConditions.Any(device => device.FailedDeviceId == i))
         {
             var deviceDetails = DeviceSendingDetails.FailureConditions.First(device => device.FailedDeviceId == i);
             modifier = modifier += deviceDetails.FailedDeviceGradient;
         }
         var deviceValue = rand.Next((int) ((DeviceSendingDetails.TemperatureMin * modifier)*100),
             (int) ((DeviceSendingDetails.TemperatureMax * modifier)*100));
         var deviceData = new DeviceData()
         {
             deviceid = deviceName,
             temperature = (deviceValue/100F),
             timestamp = DateTime.UtcNow
         };
         var jsonDeviceDetail = JsonConvert.SerializeObject(deviceData);
         var encodedPayload = Encoding.UTF8.GetBytes(jsonDeviceDetail);
         var eventData = new EventData(encodedPayload)
         {
             PartitionKey = "devices"
         };
         allEvents.Add(eventData);
     }
     eventHubClient.SendBatch(allEvents);
 }