How to separate C# tuple values to match method arguments

Question

I am wondering is it possible to 'spread' tuple's values in a way to properly match method arguments.

For example:

public (int, object) GetTuple() {
   return (5, null);
}

public void ReceiveMultipleArguments(int a, object b) { ... }

The call of ReceiveMultipleArguments method like this:

ReceiveMultipleArguments(GetTuple());

will result in this error:

CS7036: There is no argument given that corresponds to the required formal parameter 'b' of 'Method1(int, object)'

The possible solution is to destructure tuple manually then provide each value as method argument, but is there a way to do it shorter, like spread operator that exists in javascript, for example?

A better idea in C# 9 and later is to use records instead of tuples and pass the record type to themethod — Panagiotis Kanavos
– Panagiotis Kanavos, Commented Sep 1, 2021 at 9:12
C# does not support any kind of spread operator - nor does it have any kind of built-in support for parameter vs. struct isomorphism, unfortunately. But you can hack-it with extension-methods on value-tuples - but it doesn't really solve any problems. — Dai
– Dai, Commented Sep 1, 2021 at 9:52

Amr Eladawy · Accepted Answer · 2022-11-12 20:35:56Z

3

C# is a strongly typed language, so you cannot pass tuple (which has its own class ValueTuple class).

So, you could just define overload for the method:

public void Test()
{
    ReceiveMultipleArguments(GetTuple());
}

public (int, object) GetTuple()
{
    return (5, null);
}

public void ReceiveMultipleArguments((int a, object b) @params) => ReceiveMultipleArguments(@params.a, @params.b);
public void ReceiveMultipleArguments(int a, object b) { ... }

edited Nov 12, 2022 at 20:35

Amr Eladawy

4,3797 gold badges36 silver badges52 bronze badges

answered Sep 1, 2021 at 9:12

Michał Turczyn

41.2k18 gold badges58 silver badges87 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Dai Over a year ago

When people say "tuple" today they're usually referring to struct ValueTuple<T1...> and C#'s special syntax for them - not the old-school class Tuple<T1...>.

Thomas Angeland · Accepted Answer · 2021-09-01 09:49:29Z

You could change the signature of the method to support params of object elements. Then you could unpack the tuple into individual elements and use that as parameter.

public void Main()
{
    var tuple = GetTuple();
    var items = UnpackTuple(tuple).ToArray();

    DoSomethingWith(items);
}

public void DoSomethingWith(params object[] data)
{
    foreach (var d in data)
    {
        Console.WriteLine(d);
    }
}

public IEnumerable<object> UnpackTuple(ITuple tuple)
{
    for (var index = 0; index < tuple.Length; index++)
    {
        yield return tuple[index];
    }
}

public ITuple GetTuple()
{
    return Tuple.Create(5, "second", 2.489, 'G');
}

However, I would strongly advice you to move away from tuples if you need to move them around in your program. From experience, I have seen that this will lead to a messy code base that is hard to understand and change.

Instead, define classes for your tuples. Lets say you need to pass an object, let's say an apple, and a count for how many apples into some method. The class could be a generic class such as:

public class CountOf<T>
{
    public CountOf(T value, int count)
    {
        this.Value = value;
        this.Count = count;
    }

    public T Value { get; }

    public int Count { get; set; }
}

Or non-generic, such as:

public class CountedObject
{
    public CountedObject(object obj, int count)
    {
        this.Object = obj;
        this.Count = count;
    }

    public object Object { get; }

    public int Count { get; set; }
}

Use case:

public void Main()
{
    var apple = new Apple();
    
    var countedApples = new CountOf<Apple>(apple, 10);
    DoSomethingWith(countedApples);
    
    var countedObject = new CountedObject(apple, 10);
    DoSomethingWith(countedObject);
}

public void DoSomethingWith(CountOf<Apple> countedApples)
{
    // do something here
}

public void DoSomethingWith(CountedObject countedObject)
{
    // do something here
}

public class Apple { }

public class CountOf<T>
{
    public CountOf(T value, int count)
    {
        this.Value = value;
        this.Count = count;
    }

    public T Value { get; }

    public int Count { get; set; }
}

public class CountedObject
{
    public CountedObject(object obj, int count)
    {
        this.Object = obj;
        this.Count = count;
    }

    public object Object { get; }

    public int Count { get; set; }
}

Akshay G · Accepted Answer · 2021-09-01 10:15:50Z

0

maybe this help you:

static void Main(string[] args)
{
    ReceiveMultipleArguments(GetTuple());
    Console.WriteLine();
}

public static (int, object) GetTuple()
{
    return (5, null);
}

public static void ReceiveMultipleArguments((int, object) p)
{
    Console.WriteLine(p.Item1);
    Console.WriteLine(p.Item2);
}

edited Sep 1, 2021 at 10:15

Akshay G

2,3601 gold badge19 silver badges35 bronze badges

answered Sep 1, 2021 at 9:06

Majid Ramezankhani

14811 bronze badges

2 Comments

Dušan Over a year ago

Thanks, but I'd prefer not to change method signature.

Panagiotis Kanavos Over a year ago

@Душан you have to. It's either that or manually deconstruct. A ValueTuple<T1,T2> isn't neither a T1 nor a T2.

Collectives™ on Stack Overflow

How to separate C# tuple values to match method arguments

3 Answers 3

1 Comment

Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related