public Task Init(string name, Orleans.Providers.IProviderRuntime providerRuntime, Orleans.Providers.IProviderConfiguration config)
 {
     //// prepare provider
     this.Name = name;
     this.directory = config.Properties["directory"];
     return TaskDone.Done;
 }

        public Task ClearStateAsync(string grainType, Orleans.GrainReference grainReference, Orleans.GrainState grainState)
        {
            if (!(grainState is IAggregateState))
                throw new NotAggregateStateException(grainState.GetType());

            var state = grainState as IAggregateState;
            var stream = this.GetStreamName(grainType, grainReference);

            return this.Connection.DeleteStreamAsync(stream, state.Version);
        }

 public Task WriteStateAsync(string grainType, Orleans.Runtime.GrainReference grainReference, Orleans.IGrainState grainState)
 {
     var json = JsonConvert.SerializeObject(grainState.AsDictionary());
     var fileInfo = this.GetFileInfo(grainType, grainReference);
     using (var stream = fileInfo.OpenWrite())
     {
         using (var writer = new StreamWriter(stream))
         {
             return writer.WriteAsync(json);
         }
     }
 }

        public async Task ReadStateAsync(string grainType, Orleans.Runtime.GrainReference grainReference, Orleans.IGrainState grainState)
        {
            var fileInfo = this.GetFileInfo(grainType, grainReference);
            if (!fileInfo.Exists)
            {
                return;
            }

            using (var stream = fileInfo.OpenText())
            {
                var json = await stream.ReadToEndAsync();
                var data = JsonConvert.DeserializeObject<Dictionary<string, object>>(json);
                grainState.SetAll(data);
            }
        }

        public Task Init(string name, Orleans.Providers.IProviderRuntime providerRuntime, Orleans.Providers.IProviderConfiguration config)
        {
            this.Name = name;
            this.Log = providerRuntime.GetLogger(this.GetType().FullName, Logger.LoggerType.Application);

            // Create EventStore connection
            var username = config.Properties.ContainsKey("Username") ? config.Properties["Username"] : "admin";
            var password = config.Properties.ContainsKey("Password") ? config.Properties["Password"] : "changeit";

            var settings = ConnectionSettings.Create()
                .KeepReconnecting().KeepRetrying()
                .SetDefaultUserCredentials(new UserCredentials(username, password));

            // Connection string format: <hostName>:<port>
            var connectionStringParts = config.Properties["ConnectionString"].Split(':'); 
            var hostName = connectionStringParts[0];
            var hostPort = int.Parse(connectionStringParts[1]);
            var hostAddress = Dns.GetHostAddresses(hostName).First(a => a.AddressFamily == AddressFamily.InterNetwork);

            this.Connection = EventStoreConnection.Create(settings, new IPEndPoint(hostAddress, hostPort));

            // Connect to EventStore
            return this.Connection.ConnectAsync();
        }

 public static object Deserializer(System.Type expected, Orleans.Serialization.BinaryTokenStreamReader stream)
 {
     Orleans.PingPong.Message result = new Orleans.PingPong.Message();
     return result;
 }

            public System.Threading.Tasks.Task Ping(Orleans.PingPong.IClient from, Orleans.PingPong.Message message)
            {

                return base.InvokeMethodAsync<object>(1491328371, new object[] {from is GrainBase ? Orleans.PingPong.ClientFactory.Cast(from.AsReference()) : from, message}, TimeSpan.Zero );
            }

            public System.Threading.Tasks.Task Subscribe(Orleans.PingPong.IClientObserver subscriber)
            {
GrainFactoryBase.CheckGrainObserverParamInternal(subscriber);

                return base.InvokeMethodAsync<object>(-1238941369, new object[] {subscriber is GrainBase ? Orleans.PingPong.ClientObserverFactory.Cast(subscriber.AsReference()) : subscriber}, TimeSpan.Zero );
            }

            public System.Threading.Tasks.Task Pong(Orleans.PingPong.IDestination from, Orleans.PingPong.Message message)
            {

                return base.InvokeMethodAsync<object>(-2060440583, new object[] {from is GrainBase ? Orleans.PingPong.DestinationFactory.Cast(from.AsReference()) : from, message}, TimeSpan.Zero );
            }

 public static void Serializer(object untypedInput, Orleans.Serialization.BinaryTokenStreamWriter stream, System.Type expected)
 {
     Example.InventoryItemDeactivated input = ((Example.InventoryItemDeactivated)(untypedInput));
 }

            System.Threading.Tasks.Task Orleans.Samples.Chirper.GrainInterfaces.IChirperPublisher.RemoveFollower(string @userAlias, Orleans.Samples.Chirper.GrainInterfaces.IChirperSubscriber @follower)
            {

                return base.InvokeMethodAsync<object>(-370855882, new object[] {@userAlias, @follower is global::Orleans.Grain ? @follower.AsReference<Orleans.Samples.Chirper.GrainInterfaces.IChirperSubscriber>() : @follower} );
            }

 public static void Serializer(object untypedInput, Orleans.Serialization.BinaryTokenStreamWriter stream, System.Type expected)
 {
     JASN.Core.Customer input = ((JASN.Core.Customer)(untypedInput));
     Orleans.Serialization.SerializationManager.SerializeInner(input.Id, stream, typeof(int));
     Orleans.Serialization.SerializationManager.SerializeInner(input.Name, stream, typeof(string));
     Orleans.Serialization.SerializationManager.SerializeInner(input.Total, stream, typeof(decimal));
 }

 public static void Serializer(object untypedInput, Orleans.Serialization.BinaryTokenStreamWriter stream, System.Type expected)
 {
     Test.Interfaces.PersonalAttributes input = ((Test.Interfaces.PersonalAttributes)(untypedInput));
     Orleans.Serialization.SerializationManager.SerializeInner(input.FirstName, stream, typeof(string));
     Orleans.Serialization.SerializationManager.SerializeInner(input.LastName, stream, typeof(string));
 }

 public static void Serializer(object untypedInput, Orleans.Serialization.BinaryTokenStreamWriter stream, System.Type expected)
 {
     Microsoft.AspNet.SignalR.Messaging.Message input = ((Microsoft.AspNet.SignalR.Messaging.Message)(untypedInput));
     Orleans.Serialization.SerializationManager.SerializeInner(input.CommandId, stream, typeof(String));
     Orleans.Serialization.SerializationManager.SerializeInner(input.Encoding, stream, typeof(Encoding));
     Orleans.Serialization.SerializationManager.SerializeInner(input.Filter, stream, typeof(String));
     Orleans.Serialization.SerializationManager.SerializeInner(input.IsAck, stream, typeof(Boolean));
     Orleans.Serialization.SerializationManager.SerializeInner(input.Key, stream, typeof(String));
     Orleans.Serialization.SerializationManager.SerializeInner(input.MappingId, stream, typeof(UInt64));
     Orleans.Serialization.SerializationManager.SerializeInner(input.Source, stream, typeof(String));
     Orleans.Serialization.SerializationManager.SerializeInner(input.StreamIndex, stream, typeof(Int32));
     Orleans.Serialization.SerializationManager.SerializeInner(input.Value, stream, typeof(ArraySegment<Byte>));
     Orleans.Serialization.SerializationManager.SerializeInner(input.WaitForAck, stream, typeof(Boolean));
 }

            public System.Threading.Tasks.Task Initialize(Orleans.PingPong.IDestination actor, long repeats)
            {

                return base.InvokeMethodAsync<object>(1682027821, new object[] {actor is GrainBase ? Orleans.PingPong.DestinationFactory.Cast(actor.AsReference()) : actor, repeats}, TimeSpan.Zero );
            }

 public static object _Deserializer(System.Type expected, Orleans.Serialization.BinaryTokenStreamReader stream)
 {
     return DestinationReference.Cast(((Orleans.GrainReference)(GrainReference.DeserializeGrainReference(expected, stream))));
 }

 public static void Serializer(object untypedInput, Orleans.Serialization.BinaryTokenStreamWriter stream, System.Type expected)
 {
     Orleans.PingPong.Message input = ((Orleans.PingPong.Message)(untypedInput));
 }

 public static void Serializer(object untypedInput, Orleans.Serialization.BinaryTokenStreamWriter stream, System.Type expected)
 {
     EventJournal.Event input = ((EventJournal.Event)(untypedInput));
     Orleans.Serialization.SerializationManager.SerializeInner(input.AdditionalData, stream, typeof(System.Collections.Generic.IDictionary<System.String,Newtonsoft.Json.Linq.JToken>));
     Orleans.Serialization.SerializationManager.SerializeInner(input.Arguments, stream, typeof(object[]));
     Orleans.Serialization.SerializationManager.SerializeInner(input.CorrelationId, stream, typeof(System.Guid));
     Orleans.Serialization.SerializationManager.SerializeInner(input.Extras, stream, typeof(System.Collections.Generic.Dictionary<System.String,System.Object>));
     Orleans.Serialization.SerializationManager.SerializeInner(input.Id, stream, typeof(long));
     Orleans.Serialization.SerializationManager.SerializeInner(input.Time, stream, typeof(System.DateTime));
     Orleans.Serialization.SerializationManager.SerializeInner(input.To, stream, typeof(EventJournal.Address));
     Orleans.Serialization.SerializationManager.SerializeInner(input.Type, stream, typeof(string));
     Orleans.Serialization.SerializationManager.SerializeInner(input.UserId, stream, typeof(System.Nullable<System.Guid>));
 }

 public static void _Serializer(object original, Orleans.Serialization.BinaryTokenStreamWriter stream, System.Type expected)
 {
     ClientReference input = ((ClientReference)(original));
     GrainReference.SerializeGrainReference(input, stream, expected);
 }