/// <inheritdoc />
        public async Task Init(CancellationToken cancellationToken)
        {
            var timer = Stopwatch.StartNew();

            try
            {
                if (_logger.IsEnabled(LogLevel.Debug))
                {
                    var initMsg = string.Format("Init: Name={0} ServiceId={1} DatabaseNumber={2} UseJson={3} DeleteOnClear={4}",
                                                _name, _serviceId, _options.DatabaseNumber, _options.UseJson, _options.DeleteOnClear);
                    _logger.LogDebug($"RedisGrainStorage {_name} is initializing: {initMsg}");
                }

                _redisOptions = ConfigurationOptions.Parse(_options.ConnectionString);
                _connection   = await ConnectionMultiplexer.ConnectAsync(_redisOptions);

                if (_options.DatabaseNumber.HasValue)
                {
                    _db = _connection.GetDatabase(_options.DatabaseNumber.Value);
                }
                else
                {
                    _db = _connection.GetDatabase();
                }

                _preparedWriteScript = LuaScript.Prepare(_writeScript);

                var loadTasks = new Task[_redisOptions.EndPoints.Count];
                for (int i = 0; i < _redisOptions.EndPoints.Count; i++)
                {
                    var endpoint = _redisOptions.EndPoints.ElementAt(i);
                    var server   = _connection.GetServer(endpoint);

                    loadTasks[i] = _preparedWriteScript.LoadAsync(server);
                }
                await Task.WhenAll(loadTasks);

                if (_logger.IsEnabled(LogLevel.Debug))
                {
                    timer.Stop();
                    _logger.LogDebug("Init: Name={0} ServiceId={1}, initialized in {2} ms",
                                     _name, _serviceId, timer.Elapsed.TotalMilliseconds.ToString("0.00"));
                }
            }
            catch (Exception ex)
            {
                timer.Stop();
                _logger.LogError(ex, "Init: Name={0} ServiceId={1}, errored in {2} ms. Error message: {3}",
                                 _name, _serviceId, timer.Elapsed.TotalMilliseconds.ToString("0.00"), ex.Message);
                throw ex;
            }
        }
            public async Task EnsureLoaded(IConnectionMultiplexer redis)
            {
                if (LoadedLuaScript != null)
                {
                    return;
                }

                var servers = redis.GetEndPoints()
                              .Select(ep => redis.GetServer(ep));

                foreach (var server in servers)
                {
                    LoadedLuaScript = await LuaScript.LoadAsync(server, CommandFlags.HighPriority);
                }
            }
        private async Task <byte[]> LoadWriteScriptAsync()
        {
            Debug.Assert(_connection is not null);
            Debug.Assert(_preparedWriteScript is not null);
            Debug.Assert(_redisOptions.EndPoints.Count > 0);

            System.Net.EndPoint[] endPoints = _connection.GetEndPoints();
            var loadTasks = new Task <LoadedLuaScript> [endPoints.Length];

            for (int i = 0; i < endPoints.Length; i++)
            {
                var endpoint = endPoints.ElementAt(i);
                var server   = _connection.GetServer(endpoint);

                loadTasks[i] = _preparedWriteScript.LoadAsync(server);
            }
            await Task.WhenAll(loadTasks).ConfigureAwait(false);

            return(loadTasks[0].Result.Hash);
        }