C# 泛型深入理解介绍

using System;
using System.Collections.Generic;

namespace CloseTypeAndOpenType
{
// 声明开放泛型类型
public sealed class DictionaryStringKey<T> : Dictionary<string, T>
{

}

public class Program
{
static void Main(string[] args)
{
object o = null;

// Dictionary<,>是一个开放类型，它有2个类型参数
Type t = typeof(Dictionary<,>);

// 创建开放类型的实例（创建失败，出现异常）
o = CreateInstance(t);
Console.WriteLine();

// DictionaryStringKey<>也是一个开放类型，但它有1个类型参数
t = typeof(DictionaryStringKey<>);

// 创建该类型的实例（同样会失败，出现异常）
o = CreateInstance(t);
Console.WriteLine();

// DictionaryStringKey<int>是一个封闭类型
t = typeof(DictionaryStringKey<int>);

// 创建封闭类型的一个实例（成功）
o = CreateInstance(t);

Console.WriteLine("对象类型 = " + o.GetType());
Console.Read();
}


// 创建类型
private static object CreateInstance(Type t)
{
object o = null;
try
{
// 使用指定类型t的默认构造函数来创建该类型的实例
o = Activator.CreateInstance(t);
Console.WriteLine("已创建{0}的实例", t.ToString());
}
catch(Exception ex)
{
Console.WriteLine(ex.Message);
}

return o;
}
}
}

View Code

namespace GenericStaticFieldAndStaticFunction
{
// 泛型类，具有一个类型参数
public static class TypeWithStaticField<T>
{
public static string field;
public static void OutField()
{
Console.WriteLine(field+":"+typeof(T).Name);
}
}

// 非泛型类
public static class NoGenericTypeWithStaticField
{
public static string field;
public static void OutField()
{
Console.WriteLine(field);
}
}
class Program
{
static void Main(string[] args)
{
// 使用类型实参时，实际上CLR会定义一个新的类型对象
// 所以每个静态字段都是不一样对象里面的静态字段，所以才会每个都有各自的值
// 对泛型类型类的静态字段赋值
TypeWithStaticField<int>.field = "一";
TypeWithStaticField<string>.field = "二";
TypeWithStaticField<Guid>.field = "三";

// 此时filed 值只会有一个值，每个赋值都是改变了原来的值
NoGenericTypeWithStaticField.field = "非泛型类静态字段一";
NoGenericTypeWithStaticField.field = "非泛型类静态字段二";
NoGenericTypeWithStaticField.field = "非泛型类静态字段三";

NoGenericTypeWithStaticField.OutField();

// 证明每个封闭类型都有一个静态字段
TypeWithStaticField<int>.OutField();
TypeWithStaticField<string>.OutField();
TypeWithStaticField<Guid>.OutField();
Console.Read();

}
}
}

// 静态构造函数的例子
public static class Outer<Tx>
{
// 嵌套类
public class Inner<Ty>
{
// 静态构造函数
static Inner()
{
Console.WriteLine("Outer<{0}>.Inner<{1}>", typeof(Tx), typeof(Ty));
}

public static void Print()
{
}
}
}
class Program
{
static void Main(string[] args)
{
#region 静态函数的演示

// 静态构造函数会运行多次
// 因为每个封闭类型都有单独的一个静态构造函数
Outer<int>.Inner<string>.Print();
Outer<int>.Inner<int>.Print();
Outer<string>.Inner<int>.Print();
Outer<string>.Inner<string>.Print();
Outer<object>.Inner<string>.Print();
Outer<object>.Inner<object>.Print();
Outer<string>.Inner<int>.Print();
Console.Read();
#endregion
}
}

 
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;

namespace GeneralDemo
{
public class Program
{
static void Main(string[] args)
{
Stopwatch stopwatch = new Stopwatch();

// 非泛型数组
ArrayList arraylist = new ArrayList();

// 泛型数组
List<int> genericlist= new List<int>();

// 开始计时
stopwatch.Start();
for (int i = 1; i < 10000000; i++)
{
//genericlist.Add(i);
arraylist.Add(i);
}

// 结束计时
stopwatch.Stop();

// 输出所用的时间
TimeSpan ts = stopwatch.Elapsed;
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
ts.Hours, ts.Minutes, ts.Seconds,
ts.Milliseconds/10);
Console.WriteLine("运行的时间： " + elapsedTime);
Console.Read();
}
}
}

IL_001f: ldloc.1
IL_0020: ldloc.3
IL_0021: box [mscorlib]System.Int32
IL_0026: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object)
IL_002b: pop
IL_002c: nop
IL_002d: ldloc.3
IL_002e: ldc.i4.1
IL_002f: add