title: Why is Akka.Persistance not replaying my Journal entries
body: <p>I am writing an implementation of the Akka.Persistence for Service Fabric, and I don't seem to be able to get the snapshotting working. When it attempts to recover state it gets the latest snapshot but it does not replay the events since the latest snapshot. Its not clear to me If I have simply not wired up the components correctly or if my Implementation of the persistence library is incorrect. 
  My actor is a simple counter, my state is just the current count. 
  I expect that the Recover should get called first and then the Recover would get called for each journal entry between the last snapshot and the highest sequence number. There is a function ReplayMessagesAsync(...) in the journal that looks like it should do this but it does not get called.
  The code for my counter is below, the rest of my code is: <a href="https://github.com/nanderto/akka.net/tree/ServiceFabric" rel="nofollow" title="code">Code</a></p>
  
  <pre><code>using Akka.Actor;
  using Akka.Persistence;
  using Akka.Persistence.ServiceFabric.Journal;
  using Akka.Persistence.ServiceFabric.Snapshot;
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  
  namespace AkkaPersistence.Actors
  {
      public class Counter : ReceivePersistentActor
      {
          public class GetCount { }
  
          private int counter;
  
          private CounterState State = new CounterState();
  
          private int _msgsSinceLastSnapshot = 0;
  
          public Counter()
          {
              Recover&lt;Evt&gt;(evt =&gt;
              {
                  State.Update(evt);
              });
  
              Recover&lt;SnapshotOffer&gt;(offer =&gt; {
                  var snapshotEntry = offer.Snapshot as SnapshotEntry;
                  if (snapshotEntry != null)
                  {
                      State = (CounterState)snapshotEntry.Snapshot;
                  }
              });
  
              Command&lt;string&gt;(str =&gt; Persist(str, s =&gt;
              {
                  ++counter;
                  var evt = new Evt(s);
                  State.Update(evt);
  
                  if (++_msgsSinceLastSnapshot % 10 == 0)
                  {
                      //time to save a snapshot
                      SaveSnapshot(State.Copy());
                  }
              }));
  
              Command&lt;GetCount&gt;(get =&gt; Sender.Tell(State.Count));
  
              Command&lt;SaveSnapshotSuccess&gt;(success =&gt;
              {
                  ServiceEventSource.Current.Message($"Saved snapshot");
                  DeleteMessages(success.Metadata.SequenceNr);
              });
  
              Command&lt;SaveSnapshotFailure&gt;(failure =&gt; {
                  // handle snapshot save failure...
                  ServiceEventSource.Current.Message($"Snapshot failure");
              });
  
          }
  
          public override string PersistenceId
          {
              get
              {
                  return "counter";
              }
          }
      }
  
      internal class CounterState
      {
          private long count = 0L;
  
          public long Count
          {
              get { return count; }
              set { count = value; }
          }
  
          public CounterState(long count)
          {
              this.Count = count;
          }
  
          public CounterState() : this(0)
          {
          }
  
          public CounterState Copy()
          {
              return new CounterState(count);
          }
  
          public void Update(Evt evt)
          {
              ++Count;
          }
      }
  
      public class Evt
      {
          public Evt(string data)
          {
              Data = data;
          }
  
          public string Data { get; }
  
      }
  
      public class Cmd
      {
          public Cmd(string data)
          {
              Data = data;
          }
  
          public string Data { get; }
      }
  
  }
  </code></pre>