Why did you use ITuple class instead of List<object[]>?

[mbtolou]

Hi.

Why did you use ITuple class instead of List or IEnumerator?

[DarkWanderer]

Because System.Tuple inherits from ITuple, but not from IEnumerable:

public class Tuple<T1, T2, T3, T4> : IStructuralComparable, IStructuralEquatable, IComparable, ITuple

[mbtolou]

Working with Tuple has almost no advantage over List.
But when we use List, it becomes very easy to access the index and convert the object.

We also lose benefits such as using linq and other benefits of using Enumrables.
`

[DarkWanderer]

We also get completely incorrect type, because Tuple is not a List<object>. If you need to convert ITuple to a List<object>, it's trivial to write an extension function which does so

[mbtolou]

I did this. It is also a very simple task, but the implementation with List can be much faster in variable conversion and navigation.

Even the driver level implementation will be much simpler and faster.

[mbtolou]

Another problem with Tuple is that when you work with Dapper, it is not possible to write a model to get a list from a query.
This causes you to use dynamic data, which slows down your speed a lot.

[DarkWanderer]

I don't quite understand why you are trying to put this as a flaw in the library. Do you have a particular issue in mind?

[mbtolou]

`csharp
internal class SimpleResultModel
{
internal string device_id = null;
internal int? phase = null;
internal int? protocol_version = null;
internal DateTime? last_resp_time = null;
internal DateTime? dev_create_time = null;
internal DateTime? dev_expire_time = null;
internal DateTime? first_resp_time = null;
public ITuple[] Steps = null;
}

connection.Query("select * from a ");
`

Pay attention to this class.

I have a property called "Steps" in this class that I have to convert every time I call it from the database side.

This affects my speed.

I will send you a link that will show you the difference between using the dynamic type and the object.

https://dev.to/mokenyon/benchmarking-and-exploring-c-s-dynamic-keyword-1l5i

[mbtolou]

I created a sample class to test the performance of both methods.
Apparently you are right, there is not much difference between these two methods(Array and Tuple).

The only difference is the clean code, which can be ignored.
I thought tuples should be much slower than arrays.

I will share my code and results with you.

thanks.

Tuple Time Length: 23430 ms Memory: 520001046 bytes
Array Time Length: 22465 ms Memory: 530000423 bytes

using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization.Formatters.Binary;

namespace Performance;
internal class PerformanceTester
{
	internal static bool Run()
	{
		using var connection = AppConfig.GetChConn();

		var sw = Stopwatch.StartNew();
		var tuple_obj = connection.Query<SimpleTuple>("select tuple(number,number,number) Tuples from numbers(10000000)");
		var tuple_int = ConvertTuple(tuple_obj.ToArray());
		sw.Stop();
		Console.WriteLine($"Tuple Time Length: {sw.ElapsedMilliseconds} ms Memory: {GetObjectSize(tuple_obj)} bytes");


		sw = Stopwatch.StartNew();
		var tuple_arr = connection.Query<SimpleArray>("select array(number ,number ,number) Nums from numbers(10000000)");
		sw.Stop();
		Console.WriteLine($"Array Time Length: {sw.ElapsedMilliseconds} ms Memory: {GetObjectSize(tuple_arr)} bytes");

		return true;
	}

	private static long GetObjectSize(object o)
	{
		long size = 0;
		using (Stream s = new MemoryStream())
		{
			BinaryFormatter formatter = new BinaryFormatter();
			formatter.Serialize(s, o);
			size = s.Length;
		}
		return size;
	}

	private static ulong[][] ConvertTuple(SimpleTuple[] tuple_list)
	{
		var result = new ulong[tuple_list.Length][];

		for (int i = 0; i < tuple_list.Length; i++)
		{
			result[i] = new ulong[tuple_list[i].Tuples.Length];
			for (int j = 0; j < tuple_list[i].Tuples.Length; j++)
			{
				result[i][j] = (ulong)tuple_list[i].Tuples[j];
			}
		}
		return result;
	}
}

[Serializable]
internal class SimpleArray
{
	public ulong[] Nums { get; set; }

}

[Serializable]
internal class SimpleTuple
{
	public ITuple Tuples { get; set; }
}

[DarkWanderer]

The only difference is the clean code, which can be ignored.

Using substitute types is not clean code, it's an exact opposite. The fact that Dapper does not support Tuple does not make a correct type system "unclean code"

---

You don't actually need an intermediate class SimpleTuple in your example, you just need a separate handler for SqlMapper

        private class ITupleHandler : SqlMapper.TypeHandler<ITuple>
        {
            public override void SetValue(IDbDataParameter parameter, ITuple value) => parameter.Value = value;

            public override ITuple Parse(object value)
            {
                if (value is ITuple it)
                    return it;
                throw new NotSupportedException();
            }
        }

Register it:

            SqlMapper.AddTypeHandler(new ITupleHandler());

And then you can get ITuple out of Dapper trivially:

        [Test]
        public async Task ShouldExecuteSelectReturningTuple()
        {
            string sql = "SELECT tuple(1,2,3)";
            var result = (await connection.QueryAsync<ITuple>(sql)).Single();
            Assert.IsInstanceOf<ITuple>(result);
            CollectionAssert.AreEqual(new[] { 1, 2, 3 }, result.AsEnumerable());
        }