protected override uint GetResourceHandleFromEvent(Event ev)
 {
     if (ev is CreateEvent)
     {
         CreateEvent createEvent = ev as CreateEvent;
         return createEvent.Result;
     }
     else if (ev is CloseEvent)
     {
         CloseEvent closeEvent = ev as CloseEvent;
         return closeEvent.Socket;
     }
     else if (ev is ConnectEvent)
     {
         ConnectEvent connEvent = ev as ConnectEvent;
         return connEvent.Socket;
     }
     else if (ev is SendEvent)
     {
         SendEvent sendEvent = ev as SendEvent;
         return sendEvent.Socket;
     }
     else if (ev is ReceiveEvent)
     {
         ReceiveEvent recvEvent = ev as ReceiveEvent;
         return recvEvent.Socket;
     }
     else
     {
         throw new NotImplementedException("Should not get here");
     }
 }

        public ActionResult Save(Event updatedEvent, FormCollection formData)
        {
            var action = new DataAction(formData);

            try
            {
                switch (action.Type)
                {
                    case DataActionTypes.Insert: // your Insert logic
                        _db.Events.Add(updatedEvent);
                        break;
                    case DataActionTypes.Delete: // your Delete logic
                        updatedEvent = _db.Events.SingleOrDefault(ev => ev.id == updatedEvent.id);
                        _db.Events.Remove(updatedEvent);
                        break;
                    default:// "update" // your Update logic
                        updatedEvent = _db.Events.SingleOrDefault(
                        ev => ev.id == updatedEvent.id);
                        UpdateModel(updatedEvent);
                        break;
                }
                _db.SaveChanges();
                action.TargetId = updatedEvent.id;
            }
            catch (Exception e)
            {
                action.Type = DataActionTypes.Error;
            }
            return (new AjaxSaveResponse(action));
        }

 public async Task<IdentityResult> Create(Event item)
 {             
     item.Id = Guid.NewGuid().ToString();            
     context.Events.Add(item);
     var result = await SaveChangesAsync();
     return result;
 }

 public DelayedEvent(IEventable target, Event<IEventable> @event, int delay, object[] parameters)
 {
     Target = target;
     Event = @event;
     _delay = delay;
     Parameters = parameters;
 }

 public DragRezult(Event onDrag, Event onEndDrag, EventPaint onPaint)
 {
     mRezult = Rezult.Drag;
     mOnDrag = onDrag;
     mOnEndDrag = onEndDrag;
     mOnPaint = onPaint;
 }

        public ActionResult Create(CreateEventViewModel eventToRegister)
        {
            if(!this.ModelState.IsValid)
            {
                return this.View(eventToRegister);
            }

            var userId = this.User.Identity.GetUserId();

            var eventToCreate = new Event()
            {
                Name = eventToRegister.Name,
                Description = eventToRegister.Description,
                CreatedOn = DateTime.Now,
                StartDate = eventToRegister.StartDate,
                OrganiserId = userId,
                Coordinates = eventToRegister.Coordinates,
                LocationId = 1
            };

            var createdEvent = this.eventsServices.CreateEvent(eventToCreate);
            IIdentifierProvider provider = new IdentifierProvider();
            string encodedId = provider.EncodeId(createdEvent.Id);

            return this.Redirect("~/Events/" + encodedId);
        }

        public async Task<IEnumerable<Event>> ProcessAsync(Event evnt)
        {
            var shardKeyArrived = evnt.GetBody<ShardKeyArrived>();
            TheTrace.TraceInformation("Got {0} from {1}", shardKeyArrived.ShardKey, 
                shardKeyArrived.Source.TypeName);

            var account = CloudStorageAccount.Parse(shardKeyArrived.Source.ConnectionString);
            var client = account.CreateCloudTableClient();
            var table = client.GetTableReference(shardKeyArrived.Source.DynamicProperties["TableName"].ToString());

            var entities = table.ExecuteQuery(new TableQuery().Where(
                TableQuery.GenerateFilterCondition("PartitionKey", "eq", shardKeyArrived.ShardKey)));

            bool hasAnything = false;
            foreach (var entity in entities)
            {
                await _pusher.PushAsync(entity, shardKeyArrived.Source);
                hasAnything = true;
            }

            if (hasAnything)
            {
                await _pusher.FlushAsync();
            }

            return Enumerable.Empty<Event>();
        }

		public void WhenCreatingEvent_ThenCanCastToCovariantBase()
		{
			IEvent<FooArgs> args = new Event<object, FooArgs>(this, new FooArgs());
			var covariant = (IEvent<EventArgs>)args;

			Assert.NotNull(covariant);
		}

 public void AddEvent(DateTime date, string title, string location)
 {
     Event newEvent = new Event(date, title, location);
     this.dictByTitle.Add(title.ToLower(), newEvent);
     this.orderedByDate.Add(newEvent);
     Messages.EventAdded(this.Output);
 }

        public void Create_Event()
        {
            var ebEvent = new Event
            {
                Name = new MultipartTextField { Html = "Test event" },
                Description = new MultipartTextField { Html = "Test event description" },
                Start = new DateTimeTimezoneField { Timezone = "Europe/London" },
                End = new DateTimeTimezoneField { Timezone = "Europe/London" },
                OnlineEvent = true,
                Currency = "GBP",
                CategoryId = 108,
                SubcategoryId = 8001
            };

            ebEvent.TicketClasses.Add(new TicketClass
                {
                    Name = "General admission ticket",
                    Cost = new CurrencyField { Currency = "GBP", Value = 10, Display = "£10".UrlEncode() },
                    Free = false,
                    Fee = new CurrencyField { Currency = "GBP", Value = 10, Display = "£10".UrlEncode()  },
                    QuantityTotal = 1000,
                    MinimumQuantity = 1,
                    MaximumQuantity = 10
                });

            // post
            Assert.DoesNotThrow(() => Context.Create<Event>(ebEvent));
            Assert.That(ebEvent, Is.Not.Null);
            Assert.Greater(ebEvent.Id, 0);
        }

 /// <summary>
 /// Creates a new assetSchedule from and old assetSchedule and a new Event
 /// </summary>
 /// <param name="oldSchedule"></param>
 /// <param name="newEvent"></param>
 public StateHistory(StateHistory oldSchedule, Event newEvent)
 {
     Events = new Stack<Event>(oldSchedule.Events);
     InitialState = oldSchedule.InitialState;  //Should maybe be a deep copy -->not for this one
     Events.Push(newEvent);
 //    Asset = newAssetSched.Asset;
 }

        public static void AddOutlookID(ref Event ev, AppointmentItem ai)
        {
            //Add the Outlook appointment ID into Google event.
            //This will make comparison more efficient and set the scene for 2-way sync.

            addOGCSproperty(ref ev, oEntryID, OutlookCalendar.Instance.IOutlook.GetGlobalApptID(ai));
        }

 // sends an event to be processed immediately, warning: use with caution!
 public void SendImmediateEvent(Event ev)
 {
     for (int i = 0; i < m_lsUpdateStack.Count; i++)
     {
         m_lsUpdateStack[i].obj.ProcessEvent(ev);
     }
 }

 /// <summary>
 /// Returns an header from an InfoEvent.
 /// </summary>
 /// <param name="Event"></param>
 /// <returns></returns>
 public short GetHeader(Event Event)
 {
     using (DictionaryAdapter<string, short> DA = new DictionaryAdapter<string, short>(InfoEvents))
     {
         return DA.TryPopValue(Event.GetType().Name);
     }
 }

 public override void FireEvent(Event e)
 {
     if (e.Type == EventType.Render)
     {
         Console.WriteLine(e.Parameters["text"]);
     }
 }

        public override bool VisitEvent(Event @event)
        {
            if (!VisitDeclaration(@event))
                return false;

            string msg;
            if (HasInvalidDecl(@event, out msg))
            {
                @event.ExplicitlyIgnore();
                Log.Debug("Event '{0}' was ignored due to {1} decl",
                    @event.Name, msg);
                return false;
            }

            foreach (var param in @event.Parameters)
            {
                if (HasInvalidDecl(param, out msg))
                {
                    @event.ExplicitlyIgnore();
                    Log.Debug("Event '{0}' was ignored due to {1} param",
                        @event.Name, msg);
                    return false;
                }

                if (HasInvalidType(param.Type, out msg))
                {
                    @event.ExplicitlyIgnore();
                    Log.Debug("Event '{0}' was ignored due to {1} param",
                        @event.Name, msg);
                    return false;
                }
            }

            return true;
        }

        private static void OnAddBookBuff(Event e)
        {
            Sim actor = e.Actor as Sim;
            if (actor == null) return;

            BookWritten target = e.TargetObject as BookWritten;
            if (target == null) return;

            BookWrittenData data = target.Data as BookWrittenData;
            if (data == null) return;

            if (actor.SimDescription.ChildOrBelow) return;

            if (actor.SimDescription.Teen)
            {
                if (!Woohooer.Settings.AllowTeen(true)) return;
            }

            if (actor.BuffManager == null) return;

            switch (data.Genre)
            {
                case BookData.BookGenres.Romance:
                //case BookData.BookGenres.Poetry:
                case BookData.BookGenres.Trashy:
                    actor.BuffManager.AddElement(BuffNames.InTheMood, sBookOrigin);
                    break;
            }
        }

 public static void PrintEvent(Event eventToPrint)
 {
     if (eventToPrint != null)
     {
         output.AppendFormat("{0}{1}", eventToPrint, Environment.NewLine);
     }
 }

        private void ActiveRecord_Received(object sender, Event.DeliverCSAttendEventArgs e)
        {
            IEnumerable<UDT.CSAttend> CSAttends = e.ActiveRecords;
            if (CSAttends.Count() == 0)
                return;

            this.circularProgress.Visible = true;
            this.circularProgress.IsRunning = true;

            this.DisableButtons();

            try
            {
                this.InitCSAttend(CSAttends.ElementAt(0).CourseID.ToString());
                if (this.chkShowLog.Checked)
                    this.AppendCSAttendLog(CSAttends.ElementAt(0).CourseID.ToString());
                this.CheckedManualCSAttend(CSAttends.ElementAt(0));
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }

            this.EnableButtons();

            this.circularProgress.Visible = false;
            this.circularProgress.IsRunning = false;
        }

 public void HandleEvent(Event e)
 {
     switch (state)
     {
         case State.LOCKED:
             switch (e)
             {
                 case Event.COIN:
                     state = State.UNLOCKED;
                     turnstileController.Unlock();
                     break;
                 case Event.PASS:
                     turnstileController.Alarm();
                     break;
             }
             break;
         case State.UNLOCKED:
             switch (e)
             {
                 case Event.COIN:
                     turnstileController.Thankyou();
                     break;
                 case Event.PASS:
                     state = State.LOCKED;
                     turnstileController.Lock();
                     break;
             }
             break;
     }
 }