Improve performance and reduce allocations when parsing RedisResults about nredistimeseries HOT 6 OPEN

using System;
using System.Collections;
using System.Collections.Generic;

namespace NRedisTimeSeries.DataTypes
{
    public class TimeSeriesCollection : IReadOnlyList<(long, double)>
    {
        public TimeSeriesCollection()
        {
        }

        public (long, double) this[int index] => throw new NotImplementedException();

        public int Count => throw new NotImplementedException();

        public IEnumerator<(long, double)> GetEnumerator()
        {
            throw new NotImplementedException();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            throw new NotImplementedException();
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using StackExchange.Redis;

namespace NRedisTimeSeries.DataTypes
{

    public class TsCollection : IReadOnlyList<(long TimeStamp, double Value)>
    {

        private static (long, double) ResultAsTuple(RedisResult result)
        {
            var item = (RedisResult[])result;
            return ((long)item[0], (double)item[1]);
        }

        private class TsCollectionEnumerator : IEnumerator<(long TimeStamp, double Value)>
        {
            private int _index = -1;
            RedisResult[] _results;
            public TsCollectionEnumerator(TsCollection collection)
            {
                _results = collection._redisResults;
            }

            public (long TimeStamp, double Value) Current => (_index > -1 && _index <= _results.Length) ? ResultAsTuple(_results[_index]) : throw new IndexOutOfRangeException();

            object IEnumerator.Current => Current;

            public bool MoveNext() => ++_index < _results.Length;

            public void Reset() => _index = -1;

            public void Dispose() => Reset();

        }

        private RedisResult[] _redisResults;

        public TsCollection(RedisResult redisResult)
        {
            _redisResults = (RedisResult[])redisResult;
        }

        public (long, double) this[int index]
        {
            get => ResultAsTuple(_redisResults[index]);
 
        }

        public int Count => _redisResults.Length;

        public IEnumerator<(long, double)> GetEnumerator() => new TsCollectionEnumerator(this);

        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    }
}

public class TsMRangeResults : IReadOnlyList<TsMRangeResult>
{
	private class TsMRangeEnumerator : IEnumerator<TsMRangeResult>
	{
		private int _index = -1;

		private IReadOnlyList<TsMRangeResult> _tsMRangeResults;

		public TsMRangeEnumerator(TsMRangeResults collection) => _tsMRangeResults = collection._tsMRangeResults;

		public TsMRangeResult Current => (_index > -1 && _index <= _tsMRangeResults.Count) ? _tsMRangeResults[_index] : throw new IndexOutOfRangeException();

		object IEnumerator.Current => Current;

		public bool MoveNext() => ++_index < _tsMRangeResults.Count;

		public void Reset() => _index = -1;

		public void Dispose() => Reset();
	}
	
	private IReadOnlyList<TsMRangeResult> _tsMRangeResults;

	public int Count { get; }

	public TsMRangeResults(RedisResult redisResult)
	{
		var redisResults = (RedisResult[])redisResult;

		Count = redisResults.Length;

		if (redisResults.Length > 0)
		{
			var list = new List<UserQuery.TsMRangeResult>(redisResults.Length);
			for (int i = 0; i < redisResults.Length; i++)
			{
				list.Add(new TsMRangeResult(redisResults[i]));
			}
			_tsMRangeResults = list;
		}
	}

	public TsMRangeResult this[int index] => _tsMRangeResults[index];

	public IEnumerator<TsMRangeResult> GetEnumerator() => new TsMRangeEnumerator(this);

	IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

public class TsMRangeResult : TsRangeResult
{
	public string Name { get; }

	public IList<(string, string)> Labels { get; }

	public TsMRangeResult(RedisResult redisResult) : base((RedisResult[])redisResult)
	{
		var redisResults = (RedisResult[])redisResult;

		Name = (string)redisResults[0];

		var labels = (RedisResult[])redisResults[1];

		if (labels.Length > 0)
		{
			Labels = new List<(string, string)>(labels.Length);

			for (int i = 0; i < labels.Length; i++)
			{
				var labelValue = (RedisResult[])labels[i];
				Labels.Add(((string)labelValue[0], (string)labelValue[1]));
			}
		}
	}
}

public class TsRangeResult : IReadOnlyList<(long TimeStamp, double Value)>
{
	private static (long TimeStamp, double Value) ResultAsTuple(RedisResult result)
	{
		var item = (RedisResult[])result;
		return ((long)item[0], (double)item[1]);
	}

	private class TsRangeResultEnumerator : IEnumerator<(long TimeStamp, double Value)>
	{
		private int _index = -1;

		RedisResult[] _redisResults;

		public TsRangeResultEnumerator(TsRangeResult collection) => _redisResults = collection._redisResults;

		public (long TimeStamp, double Value) Current => (_index > -1 && _index <= _redisResults.Length) ? ResultAsTuple(_redisResults[_index]) : throw new IndexOutOfRangeException();

		object IEnumerator.Current => Current;

		public bool MoveNext() => ++_index < _redisResults.Length;

		public void Reset() => _index = -1;

		public void Dispose() => Reset();
	}

	private RedisResult[] _redisResults;

	public int Count { get; }

	public TsRangeResult(RedisResult redisResult)
	{
		// TODO: Add some data shape checks
		_redisResults = (RedisResult[])redisResult;
		
		Count = _redisResults.Length;
	}

	protected TsRangeResult(RedisResult[] redisResults)
	{
		_redisResults = (RedisResult[])redisResults[2];
	}

	public (long TimeStamp, double Value) this[int index] => ResultAsTuple(_redisResults[index]);

	public IEnumerator<(long TimeStamp, double Value)> GetEnumerator() => new TsRangeResultEnumerator(this);

	IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

var tsMRangeResults = new TsMRangeResults(db.Execute("TS.MRANGE", new[] { "-", "+", "WITHLABELS", "FILTER", "lbl=abc" }));

foreach (var mRange in tsMRangeResults)
{
	foreach (var item in mRange)
	{
		$"{mRange.Name} {item.TimeStamp}:{item.Value} {mRange.Labels.Count}".Dump();
	}
}

var tsRange = new TsRangeResult(db.Execute("TS.RANGE", new[] { key, "-", "+" }));

foreach (var item in tsRange)
{
	$"{item.TimeStamp}:{item.Value}".Dump();
}