泛型学习由浅入深
第一章：根据具体的需求得出结果：
需求为：通过编写单独的方法在控制台同时输出 int iValue=123,long lValue=123123 的类型。
第一种方法：单独调用方法并输出 （明确类型前提下）
class Program
{
static void Main(string[] args)
{
Console.WriteLine("开始学习!!!");
int iValue = 123;
long lValue = 123123;
MethodShow.ShowInt(iValue);
MethodShow.ShowLong(lValue);
Console.Read();
}
}
public class MethodShow
{
/// <summary>
/// int参数
/// </summary>
/// <param name="iParameter"></param>
public static void ShowInt(int iParameter)
{
Console.WriteLine("这里是MethodShow下的ShowInt{0}类型为{1}", iParameter,iParameter.GetType());
}
/// <summary>
/// long参数
/// </summary>
/// <param name="lParameter"></param>
public static void ShowLong(long lParameter)
{
Console.WriteLine("这里是MethodShow下的ShowLong{0}类型为{1}", lParameter, lParameter.GetType());
}
}从上可以看出为了实现int 类型 和long 类型 各自单独写了各自的方法，这样容易造成代码冗余，代码质量低下。希望能将两者的方法进行一个合并，故考虑使用某种类型能够同时容纳这两种类型，
因此想到object类型和泛型方法
第二种方法，通过object类型的参数
代码为：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Study
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("开始学习!!!");
int iValue = 123;
long lValue = 123123;
MethodShow.ShowObject(iValue);
MethodShow.ShowObject(lValue);
Console.Read();
}
}
public class MethodShow
{
/// <summary>
/// object 参数
/// </summary>
/// <param name="oParameter"></param>
public static void ShowObject(object oParameter)
{
Console.WriteLine("这里是MethodShow下的ShowObject{0}类型为{1}", oParameter, oParameter.GetType());
}
}
}
第三种方法，泛型方法 ，用一个通用的数据类型T来作为一个占位符，等待在实例化时用一个实际的类型来代替
class Program
{
static void Main(string[] args)
{
Console.WriteLine("开始学习!!!");
//int iValue = 123;
//long lValue = 123123;
//MethodShow.ShowGeneric(iValue);//调用泛型方法
//MethodShow.ShowGeneric(lValue);//调用泛型方法
等价于：
////////////////////////////////在调用时才指明参数类型
//int iValue = 123;
//long lValue = 123123;
MethodShow.ShowGeneric<int>(iValue);
MethodShow.ShowGeneric<long>(lValue);
//注意：传参时所传递的参数类型必须与参数类型（T被指定的类型）一致否则立即报错
Console.Read();
}
}
public class MethodShow
{
/// <summary>
/// 泛型 参数
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tParameter"></param>
public static void ShowGeneric<T>(T tParameter)//声明泛型
{
Console.WriteLine("这里是MethodShow下的ShowGeneric{0}类型为{1}", tParameter, tParameter.GetType());
}
}通过以上的方法可以看出使用object类型的参数和使用泛型参数后可以减少代码的书写，但也有区别。
1.使用object类型的原理：
（1）object类型是任何类型的父类
（2）任何父类出现的地方，都可以用子类代替（里氏转换原则）
缺点：
(1)使用object类型参数的方法需要经过装箱和拆箱的过程，影响了性能
（2）使用object类型参数的方法，无法知道在运行的时候的准确类型（因为object类型是任何类型的父类）可能传入错误的参数导致出错
2.泛型方法（有类型 参数）在调用的时候才指明参数类型
使用格式：
首先，声明泛型方法： T是类型参数 在使用时才指定具体类型
访问修饰符 返回值类型 方法名称<T>(T 形参)
{
方法体
}
然后，调用泛型方法
方法名称<具体的参数类型>（对应的实参t）；//对应的实参t：有具体的参数类型
注意：具体的参数类型与对应的实参t必须要是相同的类型
相对于object类型参数方法使用泛型的优点有：
（1）性能优于object类型，与普通方法一样（使用效率高）
（2）传参时所传递的参数类型(t)必须与参数类型（T被指定的类型）一致，否则立即报错，也就是能够立即知道所传的参数是否准确。
第二章：泛型约束
泛型可以进行类型的约束，但object不可以进行类型的约束（因为object类型是所有类型的父类）
class Program
{
static void Main(string[] args)
{
Console.WriteLine("开始学习!!!");
Chinese chinese = new Chinese()
{
CN = "中文",
Wall = "万里长城",
Id=12123,
Name= "张三",
Age=19
};//对象初始化器
MethodShow.SayHiShow(chinese); //调用泛型方法
Console.Read();
}
}
public class MethodShow
{
/// <summary>
/// 泛型约束
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
public static void SayHiShow<T>(T t) where T :People //对类型参数T进行约束
{
t.SayHi();
Console.WriteLine("{0},{1},{2}", t.Id, t.Name, t.Age);
}
//public static void SayHiObject(object o) // 无法约束
// {
//}
}
public class People
{
public int Id { get; set; }
public string Name { get; set; }
public int Age { get; set; }
public void SayHi()
{
Console.WriteLine("{0}说，早上好", this.Name);
}
}
public class Chinese:People
{
/// <summary>
/// 中文
/// </summary>
public string CN { get; set; }
/// <summary>
/// 长城
/// </summary>
public string Wall { get; set; }
}注意：使用泛型时参数必须是约束的参数类型和可以(类型参数T和参数类型t)匹配的参数。
更多泛型知识请访问：http://blog.csdn.net/haukwong/article/details/7840158