泛型类类型参数不清楚

我刚刚开始在dotnet泛型。当我感到困惑时，我试图学习泛型类和泛型方法。下面我粘贴一个代码。

class Program
{
    static void Main(string[] args)
    {
        Helper<int> helper = new Helper<int>();
        helper.helperMethod<string>("hello Ram !");
        Console.Read();
    }       
}
public class Helper<T>
{
    public void helperMethod<T>(T input)
    {
        Console.WriteLine(input);
    }
}

创建类的实例时，在Helper类中使用类型参数。

Helper<int> helper = new Helper<int>();

如果我可以自己创建泛型方法，那么在类中使用"int"或任何其他类型参数的目的是什么?而且如果类型参数是在创建泛型类时使用的，为什么与泛型方法相比，在类型参数中使用不同的数据类型?

根据预期的效果，Helper类有两个有用的变体，这将更清楚:

只在类
上有类型参数
```
public class Helper<T>
{
    public void helperMethod(T input)
    {
        Console.WriteLine(input);
    }
}
```
在这种情况下，由于Helper<int>.helperMethod只接受int而不接受input，因此Main方法会导致编译错误。

只在方法

上有类型参数

public class Helper
{
    public void helperMethod<T>(T input)
    {
        Console.WriteLine(input);
    }
}

在这种情况下，Helper.helperMethod可以接受任何类型

如果我可以自己创建泛型方法，那么在类中使用"int"或任何其他类型参数的目的是什么

要理解这一点，您当然需要深入了解generics。generic class or method背后的想法只是为了避免任何类型的code bloating。因为相同的实现可以用于多个类型，而无需为每个类型单独实现/重载。让我们使用一些代码示例来理解:

这段代码可以工作，因为T与HelperMethod没有关联，Console.WriteLine接受object基类作为输入，这是所有T
的基类。

public class Helper<T>
{
   public void helperMethod<T>(T input)
   {            
      Console.WriteLine(input);
   }
}

让我们看看可能的修改:
在这种情况下，将method或class设置为泛型，因为将两者都设置为泛型，增加的值很少，例如:

public class Helper<T>
{
   public void HelperMethod(T input)
   {            
      Console.WriteLine(input);
   }
}

或

public class Helper
{
   public void HelperMethod<T>(T input)
   {            
      Console.WriteLine(input);
   }
}

更重要的一点是引入Constraints，这使得泛型有价值，因为这是使它们真正有用的唯一方法

public class Helper<T> where T:ICustom
{
   public void HelperMethod(T input)
   {            
      A a = input.Method1();
      B b = input.Method2();
   }
}
interface ICustom
{
   A Method1();
   B Method2();     
}
Class A
{
  // Fields and Properties of Class A
}   
Class B
{
  // Fields and Properties of Class B
}

这样做的重要性在于，泛型类型可以用来调用相关的方法并在泛型方法中使用输出，就像上面例子中的A and B类型可以导致真正的Generic implementation。

约束非常有用的另一个领域是Func<T,A>，它可以提供给用户来实现，如:

public class Helper<T>
{
   public void HelperMethod(Func<T,A> input,Func<T,B> input1,T t1)
   {            
      A a = input(t1);
      B b = input1(t1);
   }
}

这里Func的实现将由调用者完成，但将确保结果为Type A and B

如果我可以自己创建泛型方法，那么在类中使用"int"或任何其他类型参数的目的是什么

没有目的。您可以很容易地创建一个静态方法，它接受一个泛型参数:

class Program
{
    static void helperMethod<T>(T input)
    {
        Console.WriteLine(input);
    }

    static void Main(string[] args)
    {
        helperMethod<string>("hello Ram !");
        helperMethod<int>(1024);
        Console.Read();
    }
}

关于这一点:c#编译器通常足够聪明，可以找出函数调用的参数类型，例如上面的那些，所以你可以只写:

    helperMethod("hello Ram !");
    helperMethod(1024);

并且如果类型参数在创建泛型类时使用，为什么与泛型方法相比，在类型参数中使用不同的数据类型?

你发布的例子太简单了，这样做没有任何好处。你可以有一个基于一种类型的泛型类，它可以有一个采用另一种类型的泛型方法调用。该方法调用将是操作类型T的类的一部分，该方法本身接受类型y的参数。这方面的一个简单示例可以是将不同类型转换为类类型的Converter类。例如:

class Program
{
    static void Main(string[] args)
    {
        var converter = new Converter<string>();
        var converted_objected = converter.ConvertThis<int>(200);
        Console.Read();
    }
}
class Converter<T>
{
    public T ConvertThis<O>(O to_convert)
    {
        T result = default(T);
        // do stuff with to_convert and the answer ends up in result
        return result;
    }
}

一个过于简单的例子，它并不适用于所有类型，但我希望它能帮助你了解情况。

问候,亚当。

相关内容

最新更新

热门标签：