Why can't out and params be used together?

[The-Futurist]

I have a situation where I'm generating C# code from SQL stored procedure metadata.

Id like to be able to define a method as:

Invoke(out params (string Name, object Value)[] Arglist)

But this is not supported (removing the 'out' of course makes it fine).

Is there a deep reason? is this something that could be added to the language?

The root of this is that SQL stored procedures can themselves have 'out' parameters.

[CyrusNajmabadi]

What would this mean? How would it work? If you wrote code that called this, what would it compile down to?

[jnm2]

Maybe he wants the ability for the caller to do M(out var a, out var b, ...) to any arity without having to define an overload per arity?

[The-Futurist]

Maybe he wants the ability for the caller to do M(out var a, out var b, ...) to any arity without having to define an overload per arity?

Exactly, that was the ultimate motive. Here's an example of a generated method:

        public List<dt_getpropertiesbyid_vcs_u> Invoke(int @id, string @property, out string @value)
        {
            @value = default;
            var arguments = new List<Argument>
            {
                new Argument(nameof(@id),@id,false),
                new Argument(nameof(@property),@property,false),
                new Argument(nameof(@value),@value,true),
            };
            var results = base.Invoke(arguments);
            @value = (string)arguments.Where(a => a.Name == "@value").First().Value;
            return results;
        }

This and every other generated method calls the base:

        protected List<T> Invoke(List<Argument> Arguments)

I became a little fixated on the "out" as I was thinking about all that, of course there was no need, nor a need for tuples.

(Actually these signatures really should be using ref not out because I discovered yesterday that an OUT in SQL Server actually always really means IN/OUT).

[DavidArno]

What are you trying to achieve with params there? If you remove it, it'll work the way I think you want it to work:

void Invoke(out (string Name, object Value)[] Arglist)
{
    Arglist = new (string, object)[]
    {
        ("One", 1),
        ("Two", 2)
    };
}

Invoke(out var results);
foreach (var (name, value) in results)
{
    Console.WriteLine($"{name} = {value}");
}

[The-Futurist]

@DavidArno - I was a little hasty, ultimately I am building a code generator and I wanted to be able to call into a common base method that is wholly general purpose.

Basically we might have generated this:

public IEnumerable<T> Invoke (int Arg1, double Arg2, out DateTime Arg3) 
{ 
// code... 
}

and this

public IEnumerable<T> Invoke (string Arg1, out double Arg2, out long Arg3)
{ 
// code... 
}

and in each case, in each of these generated method bodies, make a call to a more general method - so I was looking for a method in which every single arg was an 'out' arg and I could then support any signature.

Of course you are correct, there's absolutely no need to support what I was thinking of, values can be passed back without problems and there's no need for "out" here at all.

[The-Futurist]

Incidentally, I stumbled upon this unexpected behavior yesterday:

using System;
using System.Collections.Generic;

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            var objects = new List<Argument>() 
            { 
                new ("A", 123, true),
                new ("B", 234, false),
                new ("C", 456, true),
                new ("D", 678, false)
            };

            var tuples = new List<(string Name, object Value, bool Out)>()
            {
                ("A", 123, true),
                ("B", 234, false),
                ("C", 456, true),
                ("D", 678, false)
            };

            foreach (var o in objects)
            {
                if (o.Name == "B")
                    o.Value = 100;
            }

            foreach (var t in tuples)
            {
                if (t.Name == "B")
                    t.Value = 100;
            }
        }
    }

    public class Argument
    {
        public Argument(string Name, object Value, bool Out)
        {
            this.Name = Name;
            this.Value = Value;
            this.Out = Out;
        }
        public string Name { get; private set; }
        public object Value { get; internal set; }
        public bool Out { get; private set; }
    }
}

The assignment to Value inside the second loop generates CS1654.

[jnm2]

That's because ValueTuple is a struct. t has already been copied and is not a reference back into the list. You'd see the same thing if you changed Argument to a struct.