private void GotEvent(EventStoreCatchUpSubscription sub, ResolvedEvent evt)
        {
            try
            {
                //create local copies of state variables
                var total = _total;
                var checkpoint = evt.Event.EventNumber;

                var amount = (string)JObject.Parse(Encoding.UTF8.GetString(evt.Event.Data))["amount"];
                switch (evt.Event.EventType.ToUpperInvariant())
                {
                    case "CREDIT":
                        total += int.Parse(amount);
                        break;
                    case "DEBIT":
                        total -= int.Parse(amount);
                        break;
                    default:
                        throw new Exception("Unknown Event Type");
                }
                File.WriteAllText(_localFile, checkpoint + "," + total);
                //Update the common state after commit to disk
                _total = total;
                Checkpoint = checkpoint;
            }
            catch (Exception ex)
            {
                _view.ErrorMsg = "Event Exception: " + ex.Message;
            }
            //repaint screen
            _view.Total = _total;
        }

        internal StreamEventsSlice(SliceReadStatus status, 
                                   string stream, 
                                   int fromEventNumber, 
                                   ReadDirection readDirection,
                                   ClientMessage.ResolvedIndexedEvent[] events,
                                   int nextEventNumber,
                                   int lastEventNumber,
                                   bool isEndOfStream)
        {
            Ensure.NotNullOrEmpty(stream, "stream");

            Status = status;
            Stream = stream;
            FromEventNumber = fromEventNumber;
            ReadDirection = readDirection;
            if (events == null || events.Length == 0)
                Events = Empty.ResolvedEvents;
            else
            {
                Events = new ResolvedEvent[events.Length];
                for (int i = 0; i < Events.Length; ++i)
                {
                    Events[i] = new ResolvedEvent(events[i]);
                }
            }
            NextEventNumber = nextEventNumber;
            LastEventNumber = lastEventNumber;
            IsEndOfStream = isEndOfStream;
        }

        void EventAppeared(EventStoreCatchUpSubscription sub, ResolvedEvent evnt)
        {
            if (evnt.OriginalStreamId.StartsWith("$"))
                return;
    
            dynamic ev = _adapter.TryGetDomainEvent(evnt);
            if (ev == null)
                return;

            try
            {
                lock (this)
                {
                    Dispatch(ev);
                    _succeded++;
                    _checkPoint = evnt.OriginalPosition.GetValueOrDefault();
                    _lastEventNumber = evnt.OriginalEventNumber;
                    if(ev.Timestamp > LastUpdate)
                        LastUpdate = ev.Timestamp;
                }
            }
            catch (Exception)
            {
                Debugger.Break();
            }
           
        }

 private static void EventAppeared(EventStorePersistentSubscriptionBase eventStorePersistentSubscriptionBase,
     ResolvedEvent resolvedEvent)
 {
    ;
     var data = Encoding.ASCII.GetString(resolvedEvent.Event.Data);
     Console.WriteLine("Received: " + resolvedEvent.Event.EventStreamId + ":" + resolvedEvent.Event.EventNumber);
     Console.WriteLine(data);
 }

        private void CommandResponseReceived(EventStoreSubscription subscription, ResolvedEvent resolvedEvent)
        {
            if (ResponseReceived == null) return;

            var response = resolvedEvent.ParseJson<CommandResponse>();

            ResponseReceived(this, new CommandResponseEventArgs(response));
        }

        private void ProcessEvent(EventStoreCatchUpSubscription subscribtion, ResolvedEvent resolvedEvent)
        {
            var alarm = resolvedEvent.ParseJson<IrresponsibleGamblerDetected>();

            Publish(alarm);

            StoreCheckpoint(resolvedEvent);
        }

        public static object DeserializeEventData(
            this ISerializer serializer,
            ResolvedEvent resolvedEvent)
        {
            IDictionary<string, object> _;

            return serializer.DeserializeEventData(resolvedEvent, out _);
        }

 dynamic GetDomainEvent(ResolvedEvent evnt)
 {
     var metadata = evnt.Event.Metadata;
     var data = evnt.Event.Data;
     var jmeta = JObject.Parse(Encoding.UTF8.GetString(metadata));
     var eventClrTypeName = jmeta.Property(EventClrTypeHeader).Value;
     dynamic ev = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(data), Type.GetType((string)eventClrTypeName));
     return ev;
 }

 private void EventAppeard(EventStoreSubscription subscription, ResolvedEvent @event)
 {
     var representation = _deserializer.GetRepresentation(_serializer, @event.OriginalEvent);
     var payload = representation.Payload;
     if (payload != null)
     {
         _self.Tell(payload);
     }
 }

 private void HandleNewEvent(EventStoreCatchUpSubscription subscription, ResolvedEvent @event)
 {
     // make sure the event fits the ones this handler cares about
     if (!_eventFilter(@event)) { return; }
     var _event = ProcessRawEvent(@event);
     // filter for null event ( didn't have metadata or data )
     if (_event == null) { return; }
     HandleEvent(_event);
 }

 public dynamic TryGetDomainEvent(ResolvedEvent evnt)
 {
     try
     {
         return GetDomainEvent(evnt);
     }
     catch
     {
         return null;
     }
 }

 public IEnumerable<object> Deserialize(ResolvedEvent resolvedEvent)
 {
     var type = Type.GetType(resolvedEvent.Event.EventType + ", UserService.DomainModel", true);
     using (var stream = new MemoryStream(resolvedEvent.Event.Data))
     {
         using (var reader = new StreamReader(stream))
         {
             yield return JsonSerializer.CreateDefault().Deserialize(reader, type);
         }
     }
 }

       private SyndicationItem MapToFeedItem(ResolvedEvent ev)
       {
           return new SyndicationItem(
               "BeganFollowingEvent",
               Encoding.UTF8.GetString(ev.Event.Data),
 new Uri(RequestContext.Url.Content("/beganfollowing/" +
   ev.Event.EventId)),
 ev.Event.EventId.ToString(),
               DateTime.Now // Event store client does not return timestamp yet
           );
       }

 protected override void OnEventReceived(ResolvedEvent resolvedEvent)
 {
     switch (resolvedEvent.OriginalEvent.EventType)
     {
         case UserEventType.UserCreated:
             AddAccount(resolvedEvent.OriginalEvent);
             break;
         case ContactEventType.AccountContactRefreshRequest:
             ProcessRefreshRequest(resolvedEvent.OriginalEvent);
             break;
     }
 }

        private static EventEnvelope Map(ResolvedEvent resolvedEvent)
        {
            var bytesAsString = Encoding.UTF8.GetString(resolvedEvent.Event.Data);
            var a = JsonConvert.DeserializeObject(bytesAsString) as IEvent;
            var jsonMetadata = Encoding.UTF8.GetString(resolvedEvent.Event.Metadata);
            var metadata = JsonConvert.DeserializeObject<EventMetadata>(jsonMetadata);
            var typeName = Type.GetType(metadata.Type);
            var @event = (IEvent)JsonConvert.DeserializeObject(bytesAsString, typeName);
            var envelope = new EventEnvelope(@event, metadata);

            return envelope;
        }

 private static void Appeared(EventStoreCatchUpSubscription subscription, ResolvedEvent resolvedEvent)
 {   
     if (resolvedEvent.Event.EventType.Contains("Question") || resolvedEvent.Event.EventType.Contains("Answer"))
     {
         Console.WriteLine("Read event {0} with data: {1}", 
             resolvedEvent.Event.EventType, 
             Encoding.UTF8.GetString(resolvedEvent.Event.Data));
         
         var @event = EventDeserializer.Deserialize(resolvedEvent.Event.EventType, Encoding.UTF8.GetString(resolvedEvent.Event.Data));
         _eventPublisher.Publish(@event);
     }
 }

 protected override void OnEventReceived(ResolvedEvent resolvedEvent)
 {
     switch (resolvedEvent.OriginalEvent.EventType)
     {
         case UserEventType.UserCreated:
             AddUserToCache(resolvedEvent.OriginalEvent);
             break;
         case UserEventType.AccountRegistered:
             AddAccountToCache(resolvedEvent.OriginalEvent);
             break;
     }
 }

 public async Task PublishAsync(EventStorePersistentSubscriptionBase subscription, ResolvedEvent resolvedEvent) {
   try {
     object eventObject = resolvedEvent.Event.ToEventObject();
     using (Container.BeginExecutionContextScope()) {
       dynamic publisher = Container.GetInstance<IPublishEvent>();
       await publisher.PublishAsync((dynamic)eventObject).ConfigureAwait(true);
     }
     subscription.Acknowledge(resolvedEvent);
   } catch (Exception ex) {
     subscription.Fail(resolvedEvent, PersistentSubscriptionNakEventAction.Unknown, ex.Message);
   }
 }

        private static void StoreCommandData(ResolvedEvent evt, EventContext deserializedEvent, IDocumentSession session)
        {
            var commandId = deserializedEvent.Headers["CommandId"] as string;

            var commandModel = session.Load<CommandStatusModel>(commandId);
            if (commandModel == null)
            {
                commandModel = new CommandStatusModel() { Id = commandId };
                commandModel.Events = new List<EventStatusModel>();
                session.Store(commandModel);
            }
            commandModel.Events.Add(new EventStatusModel() { StreamId = evt.Event.EventStreamId, EventNumber = evt.Event.EventNumber, Type = evt.Event.EventType});
        }

 public Snapshot Deserialize(ResolvedEvent resolvedEvent)
 {
     var type = Type.GetType(resolvedEvent.Event.EventType, true);
     var instance = Activator.CreateInstance(type);
     using (var stream = new MemoryStream(resolvedEvent.Event.Data))
     {
         using (var reader = new BinaryReader(stream))
         {
             ((IBinaryDeserializer) instance).Read(reader);
             return new Snapshot(BitConverter.ToInt32(resolvedEvent.Event.Metadata, 0), instance);
         }
     }
 }