how do I send two parameters as one in c#?

Question

My problem lies in that I have a method that takes a variable amount of parameters.

Each of those parameters are an object, the real problem lies in that it gets horribly verbose to write new ClassName(p1, p2) for every single parameter in that method.

is there a way to send p1 and p2 as a single parameter in the form of either {p1, p2} or (p1, p2)?

so that I can write Insert(("John", "Doe"), ("Sherlock", "Holmes"), ... etc) and then pass those into news in the method itself rather than writing Insert(new Person("John", "Doe"), new Person("Sherlock", "Holmes"), ... etc)

I know tuples in F# and scala can do it this way, but using tuples in C# just makes for even longer code

so is there a way to make it less verbose?

Edit: I'm not looking to create new arrays or new lists instead I want to avoid the new keyword as much as possible

Edit2: some people requested to see what my Insert method looks like; currently it looks like this:

public void Insert(params Person[] arr)
{
    //inserts the person in a hash table
    Action<Person> insert = (person) => _table[hasher(person.Name)].Add(person);

    // calls the insert function/action for each person in the parameter array
    Array.ForEach(arr, insert);
}

Answer 1

You could make a collection that supports initializer syntax and provide that as a parameter for your methods. This would allow the following:

void Main()
{
    SomeMethod(new PersonCollection{{1, 2}, {3, 4}, {5, 6}});
}
void SomeMethod(PersonCollection pc)
{
}

//...
class Person
{
    public Person(int a, int b)
    {
    }
}
class PersonCollection:IEnumerable
{
    IList<Person> personList = new List<Person>();
    public void Add(int a, int b)
    {
        personList.Add(new Person(a,b));
    }

    public IEnumerator GetEnumerator()
    {
        return personList.GetEnumerator();
    }
}

All that's required to support such construct is a suitable void Add method and implementing of IEnumerable.

Answer 2

In C# there's no way of grouping other than classes and structs. If your demand of laconic code exceeds common sense, you can use "logical" methods. Call method like this:

Insert("John", "Doe", "Sherlock", "Holmes")

and handle it like this:

    void Insert(params string[] names)
    {
        if (names.Length % 2 != 0) throw new ArgumentException();

        for (int i = 0; i < names.Length; i += 2)
        {
            string name = names[i];

            string surname = names[i + 1];

            // use it
        }
    }

Answer 3

You could write a helper method to deal with boilerplate code. So, supposing that want to pass several ClassName instances initialized with 2 arguments, you could write something like this:

public ClassName[] CreateClassNames(string[,] list)
{
     List<ClassName> result = new List<ClassName>()
     for ( int i = 0 ; i < list.GetLength(0); i++ )
     {
        result.Add(new ClassName(list[i][0], list[i][1]));
     }
     return result.ToArray();
}

And then call your Insert method:

Insert(CreateClassNames(new string[]{{"John", "Doe"}, {"Sherlock", "Holmes"}}))

Edit: Changed the argument to a 2 dimensional array in order to group the strings. Still not perfect, but better.

Answer 4

Behold! I have created a monster!

It will let you write code like this:

Insert(new People()["John", "Doe"]["Sherlock", "Holmes"]["Fred", "Flintsone"]);

But really, it's an abomination isn't it?

using System;
using System.Collections.Generic;

namespace Demo
{
    class Program
    {
        static void Main()
        {
            new Program().test();
        }

        void test()
        {
            Insert(new People()["John", "Doe"]["Sherlock", "Holmes"]["Fred", "Flintsone"]);
        }

        public void Insert(params Person[] persons)
        {
            foreach (var person in persons)
            {
                Console.WriteLine(person);
            }
        }
    }

    public class People
    {
        public static implicit operator Person[](People people)
        {
            return people.people.ToArray();
        }

        public People this[string firstName, string lastName]
        {
            get
            {
                people.Add(new Person(firstName, lastName));
                return this;
            }
        }

        private readonly List<Person> people = new List<Person>();
    }

    public class Person
    {
        public Person(string firstName, string lastName)
        {
            FirstName = firstName;
            LastName = lastName;
        }

        public override string ToString()
        {
            return FirstName + " " + LastName;
        }

        public readonly string FirstName, LastName;
    }
}

Answer 5

Please use dictionary as params.