C # как передать var как параметр функции [duplicate]

Вы можете сделать параметр a object:

public void DoSomething(object arg)
{
   //...

Или вы могли бы сделать то, что я предпочитаю, и сделать общий метод:

public void DoSomething<T>(T arg)
{
    //...

Общий подход два основных преимущества, и я приведу примеры того, почему они полезны:

1. Даже если вы явно не указали тип arg, у вас все еще есть доступ к нему.
2. Вы можете добавить ограничения на типы, которые хотите разрешить.

Напротив, подход object имеет некоторые важные недостатки:

1. Поскольку вы рассматриваете arg как object, вы будете только иметь возможность делать то, что вы можете сделать с любым объектом .
2. Если вы передадите тип значения в качестве параметра object, переменная будет в коробке , что означает удар производительности. Это не огромный удар, но если вы назовете DoSomething несколько тысяч раз подряд, вы можете почувствовать его.

Дженерики и ограничения типов

Добавление type для общего метода позволяет вам ограничить метод, чтобы он принимал только определенные типы. Почему это полезно? Потому что, хотя вы не знаете или не заботитесь о том, с каким конкретным типом вы работаете, вы теперь знаете что-то об этом, и вы можете использовать эту информацию.

Рассмотрим следующую настройку:

public interface IAnimal 
{ 
    void Move(); 
}
public class Duck : IAnimal
{
    public void Move() 
    { 
        Console.WriteLine("Flying"); 
    }
}
public class Fish : IAnimal
{
    public void Move()
    { 
        Console.WriteLine("Swimming"); 
    }
}
public class Ant : IAnimal
{
    public void Move()
    { 
        Console.WriteLine("Walking"); 
    }
}    

Поскольку у нас есть интерфейс IAnimal, мы можем написать общие методы, предназначенные для любой реализации IAnimal:

public class Program
{
    static void DoMove<T>(T animal) where T : IAnimal
    {
        animal.Move();
    }
    public static void Main(string[] args)
    {            
        Duck duck = new Duck(); 
        Fish fish = new Fish();
        Ant ant = new Ant(); 

        DoMove<Duck>(duck);
        DoMove<Fish>(fish);
        DoMove<Ant>(ant);
    }
}

Запустите его: http://rextester.com/GOF1761

Когда мы пишем метод DoMove, нам все равно, будет ли его параметр animal это Duck, a Fish, Ant или что-то еще. Все, о чем мы заботимся, вызывает animal.Move(). Поскольку мы использовали ограничение where T : IAnimal, компилятор знает все, что нам нужно, чтобы знать:

1. Переменная animal имеет тип T.
2. Независимо от того, f24], он реализует IAnimal.
3. Все, что реализует IAnimal, имеет метод Move().
4. Поэтому мы можем смело называть animal.Move().

(Кстати, да, мы могли бы просто написать DoMove как static void DoMove(IAnimal animal), но это еще одно обсуждение.)

Тип вывода (и некоторые его последствия)

Хорошо, но давайте сделаем еще один шаг. Во многих случаях вы можете вызывать общие методы, не указывая их параметры типа. Это называется выводом типа , и, кроме сохранения некоторого ввода, оно может быть полезно при выполнении той же операции на объектах разных типов.

public static void Main(string[] args)
{            
    IAnimal[] animals = new IAnimal[] 
    {
        new Duck(),
        new Fish(),
        new Ant()
    };

    foreach (IAnimal animal in animals)
    {
        DoMove(animal);
    }
}

Запустить его: http://rextester.com/OVKIA12317

Вам нужно только один раз написать метод DoMove<T>, и вы можете называть его любым типом IAnimal без необходимости давать более конкретный тип. Соответствующая версия Move будет вызываться каждый раз, потому что DoMove<T> может вывести, какой тип использовать для T. Когда вы вызываете DoMove(duck), .NET понимает, что вы действительно имеете в виду DoMove<Duck>(duck), который затем вызывает метод Move в классе Duck.