C＃方法可以定义可变数目的对象参数，以及可变数目的整数参数吗？

Question

Can a C# method define a variable number of object parameters, and a variable number on integer parameters, in this simple way, or some other simple way for the caller?

What does simple mean?
Simple as seen from the callers perspective. Prioritizing least amount typing/characters required, and easy to understand and use.

For what purpose?
The motivation is a basic wrapper for Console.WriteLine that makes it easier to output columned text. The existing notation is not intuitive (for ex, it requires negative numbers). It's also more verbose than needed for some basic scenarios.

One answer that seems ideal, if it's possible, would show how to define a method like this using two tuples, each tuple with n values (or hey, just up to say, 10 values). The thinking is it could reduce the caller code to this:

// Output items given column widths
Console.WriteCols(("Name", "Address", "Age"), (20, 10, 30))
Console.WriteCols(("John", "123 Street", 28), (20, 10, 30))
Console.WriteCols(("Mary", "456 Street"), (20, 10))

I know it's just a list of values, but that would fit most of our column use cases, and moreover, if the first example is possible, it seems string variables could be added later if needed, like:

Console.WriteCols(("{0} John", "123 Street", 28), (20, 10, 30), ("Dr."))

Fine go do it, what's the problem?
For the first basic example, I've tried a few approaches. One sticking point is I don't see a way to get a count of values for a Tuple. Maybe it's staring me in the face, or I'm over complicating this. The first idea was to just create method overloads with 2 Tuples that allow up to 10 values for each tuple. Then all overloads would call a primary method to do the work. However, if the primary method is receiving loosely typed tuples with varying numbers of items, it was not clear how to handle all the overload cases in a generalized way, if the count of tuple values can't be known.

Answer 1

public static class MyConsole
{
    public static void Test()
    {
        Console.Out
            .Columns(10, 40, 60)
            .WriteLine("foo", "bar", "baz")
            .WriteLine("LOL", "WUT", "BBQ")
            .WriteLine("HA", "ha", "ha");

        var cols = Console.Error.Columns(10, 40, 30);

        cols.WriteLine("Mary", "Had", "a");
        cols.WriteLine("Little", "lamb", "it's");
    }

    public static ColumnWriter Columns(params int[] widths) => new ColumnWriter(Console.Out, widths);
    public static ColumnWriter Columns(this TextWriter writer, params int[] widths) => new ColumnWriter(writer, widths);

    public class ColumnWriter
    {
        public ColumnWriter(TextWriter writer, int[] widths)
        {
            Debug.Assert(writer != null);
            Debug.Assert(widths != null);

            _writer = writer;
            _widths = widths;
        }
        private TextWriter _writer;
        private int[] _widths;

        public ColumnWriter Line()
        {
            _writer.WriteLine();
            return this;
        }

        public ColumnWriter Write(params object[] args)
        {
            Debug.Assert(args.Length == _widths.Length);

            var count = Math.Min(_widths.Length, args.Length);
            for (int idx = 0; idx < count; ++idx)
            {
                var fmt = "{0," + _widths[idx] + "}";
                _writer.Write(fmt, args[idx]);
            }

            return this;
        }
        public ColumnWriter WriteLine(params object[] args)
        {
            return Write(args).Line();
        }
    }
}

This could be improved by adding overloads for Columns(string formatString) and Columns(this TextWriter writer, string formatString) .

---

Bad ideas

Columns() can be made to return a delegate, for some odd looking syntax (thanks Evk for showing me the way -- and for not liking the syntax any better than I do). Worse yet, we can give it multiple indexer overloads.

I don't like the novel syntax in either case. This works, but anybody who'd use either one in production code would steal sheep:

public static class MyConsole
{
    public static void Test()
    {
        //  Not a great idea.
        MyConsole.WriteLines(10, 10)("foo", "bar")("baz", "planxty");

        //  Truly awful idea.
        MyConsole.Columns(10, 10)["foo", "bar"]["baz", "planxty"].End();
    }

    public static ColumnWriter Columns(params int[] widths) => new ColumnWriter(widths);

    #region Not a great idea
    //  Evk showed me how to make this work. 
    public delegate Params Params(params object[] values);
    public static Params WriteLines(params int[] widths)
    {
        var writer = new ColumnWriter(widths);

        return new Params(writer.WriteLineParams);
    }
    #endregion Not a great idea

    public class ColumnWriter
    {
        public ColumnWriter(int[] widths)
        {
            _widths = widths;
        }
        private int[] _widths;

        #region Truly awful idea.
        public ColumnWriter this[object o] => WriteLine(o);
        public ColumnWriter this[object o1, object o2] => WriteLine(o1, o2);
        public ColumnWriter this[object o1, object o2, object o3] => WriteLine(o1, o2, o3);

        //  ...moar overloards...

        //  In C# x[0]; is an expression, not a statement. 
        //  x[0].End(); is a statement. Horrible, most horrible. 
        //  Maybe I should name it FireMe() instead of End()
        public void End() { }
        #endregion Truly awful idea.

        public ColumnWriter Line()
        {
            Console.WriteLine();
            return this;
        }

        public ColumnWriter Write(params object[] args)
        {
            var count = Math.Min(_widths.Length, args.Length);
            for (int idx = 0; idx < count; ++idx)
            {
                var fmt = "{0," + _widths[idx] + "}";
                Console.Write(fmt, args[idx]);
            }

            return this;
        }
        public ColumnWriter WriteLine(params object[] args) 
            => Write(args).Line();

        #region Not a great idea
        public Params WriteLineParams(params object[] args)
        {
            WriteLine(args);

            return WriteLineParams;
        }
        #endregion Not a great idea
    }
}

Answer 2

Just use two lists, one of type string and a second of type int . For further parameters (eg formatters) you can then add the params keyword:

WriteCols(List<string> cols, List<int> width, params string[] formatters)
{
    if(cols.Count != widths.Count) throw new ArgumentException("Paramater-counts not matching");

    foreach(var e in cols)
        Console.Write(/* add some padding so that every column has the desired width */ String.Format(e, formatters));
}