c#什么'；泛型方法和以对象为参数的方法有什么区别？ 静态无效交换（ref T var1，ref T var2） { 温度T=var1； var1=var2； var2=温度； } 静态无效Swap2（参考对象var1，参考对象var2） { 对象温度=var1； var1=var2； var2=温度； }

我认为Swap在某种程度上优于Swap2？

这已经被回答了很多次，所以如果这个get被投票关闭，不要感到惊讶

在您的示例中，由于这些方法是无效的，并且它们只是相互引用，所以没有区别。然而如果添加了一个

where T:{要筛选的基类型}

由于各种原因，泛型通常比使用对象好，但首要的可能是装箱/拆箱。（这在您的示例中没有发生。）

使用

对象时，必须将其强制转换为预期使用的类型。这会导致大量开销和潜在错误。当您使用泛型时，您有编译时类型，这样您可以在编译之前或编译期间捕获许多异常，您有更强的类型可以处理，最重要的是，您不应该有任何装箱/拆箱来处理（这会降低性能）

另一个要考虑的是，当你在例子中使用<代码>交换< /代码>时，你强迫这两个代码是相同的<代码>类型< /代码>，因为<代码> t <代码>不能同时是不同的类型。使用
Swap2
可以重新引用任意两个对象；但是，您必须手动将这些类型转换为object，并且它们不能返回到其原始类型，因为除非这两个类型一开始是相同的类型

请记住
ref
参数不会从多态性中受益。
T
参数是通用的，但由于我们只有一个
T
参数，因此类型将始终相同

static void Swap<T>(ref T var1, ref T var2)
{
    T temp = var1;
    var1 = var2;
    var2 = temp;
}

static void Swap2(ref object var1, ref object var2)
{
    object temp = var1;
    var1 = var2;
    var2 = temp;
}

使用系统；
命名空间问题\答案\控制台\应用程序
{
班级计划
{
静态void Main（字符串[]参数）
{
var text=“你好”；
var employer1=新雇主（）{Name=“Microsoft”}；
var employer2=新雇主（）{Name=“EA Games”}；
//通用交换
SwapGeneric（参考员工1、参考员工2）；
//Swap（ref text，ref employee2）；//
Swap
将确保两个参数具有相同的类型（或基类型）。因此Swap2实际上更灵活？如果您不重视类型安全性或性能-当然，它更灵活。要理解差异，请为两个方法（调用方）编写一些代码它尝试交换两个字符串的值，然后交换两个整数。您会注意到调用
swap
的代码编写起来要简单得多。对于值类型，例如
int
，在调用方法的
对象
版本时，该值必须先装箱，然后再解除装箱，但在调用泛型版本时则不能。对于reference当调用
对象
版本时，此代码中没有任何内容可以确保两个对象是相同的，甚至是兼容的类型。
using System;

namespace Question_Answer_Console_App
{
    class Program
    {

        static void Main(string[] args)
        {
            var text = "Hey There";
            var employer1 = new Employer() { Name = "Microsoft" };
            var employer2 = new Employer() { Name = "EA Games" };

            //Generic Swap
            SwapGeneric(ref employer1, ref employer2);
            //Swap(ref text, ref employee2); //<- compiler error. Cannot be inferred by the usage.

            Console.WriteLine("Types of the same swapped");
            Console.WriteLine(employer1.Name);
            Console.WriteLine(employer2.Name);
            Console.WriteLine();
            //object Swap
            //SwapObject(ref employee1, ref employee2); //- compiler error.  Cannot convert to ref object.

            //Reference string and employer as object.
            var textObject = text as object;
            var employerObject = employer1 as object;

            SwapObject(ref textObject, ref employerObject);

            //Existing types cannot be re-referenced.
            //text = (Employer)textObject; //<-compiler error.  Cannot implicitly convert...
            //employer1 = (string)employerObject; //<-compiler error. Cannot implicitly convert....

            //We can cast objects to swapped types succesfully but see how easily this can cause error and confusion.
            Console.WriteLine("Objects of different types swapped");
            Console.WriteLine(((Employer)textObject).Name);
            Console.WriteLine((string)employerObject);

            Console.ReadKey();
        }

        static void SwapGeneric<T>(ref T var1, ref T var2)
        {
            T temp = var1;
            var1 = var2;
            var2 = temp;
        }

        static void SwapObject(ref object var1, ref object var2)
        {
            object temp = var1;
            var1 = var2;
            var2 = temp;
        }
    }

    public class Employer
    {
        public object Name { get; set; }
    }
}
//OUTPUT
//Types Swapped
//EA Games
//Microsoft

//Objects Swapped
//EA Games
//Hey There