- 可以考虑在一般类型参数的名字中表示出添加给该一般类型参数的约束。例如，一个被约束到ISession接口的参数可以起名为TSession。
我应该在泛型接口上面添加约束吗？
接口可以为其使用的范型类型添加约束，例如：
[C#]
public interface ILinkedList<T> where T : IComparable<T>
{...}
[Visual Basic]
Public Interface ILinkedList(Of T As IComparable(Of T))
...
End Interface
[C++]
generic <typename T> where T : IComparable<T>
public interface class ILinkedList
{...};
但是，你应该小心，在接口层面上定义约束还隐含有另外一层意思。为了强调接口与实现分离的思想，接口不应该包括任何一点实现的细节。虽然有很多方法可以用来实现范型接口，但是使用特定的类型参数毕竟是一种实现的细节。约束通常情况下会更加耦合（couple）接口和特定的实现。
更好的方法是，为实现范型接口的类添加约束，保持接口本身没有约束：
[C#]
public class LinkedList<T> : ILinkedList<T> where T : IComparable<T>
{
//Rest of the implementation
}
[Visual Basic]
Public Class LinkedList(Of T As IComparable(Of T))
Implements ILinkedList(Of T)
' Rest of the implementation
End Class
[C++]
generic <typename T> where T : IComparable<T>
public ref class LinkedList : ILinkedList<T>
{
//Rest of the implementation
};
如何处置（Dispose）泛型接口？
在C#和Visual Basic中，如果你把一个一般类型参数的对象放在using语句中，编译器无法知道客户端（client）指定的实际类型是否支持IDisposable接口。因此编译器不允许在using语句中使用一般类型参数的实例。
[C#]
public class MyClass<T>
{
public void SomeMethod(T t)
{
using(t)//Does not compile
{...}
}
}
[Visual Basic]
Public Class SomeClass(Of T)
Public Sub SomeMethod(ByVal value As T)
Using value ' Does not compile
End Using
End Sub
End Class
当然，你可以强制约束类型参数支持IDisposable接口：
[C#]
public class MyClass<T> where T : IDisposable
{
public void SomeMethod(T t)
{
using(t)
{...}
}
}
[Visual Basic]
Public Class SomeClass(Of T As IDisposable)
Public Sub SomeMethod(ByVal value As T)
Using value
End Using
End Sub
End Class
但是你不应该这么做。这样做的问题在于你不能使用接口作为类型参数了，即使这个接口的基础类型（underlying type）支持IDisposable也不行：
[C#]
public interface IMyInterface
{}
public class MyOtherClass : IMyInterface,IDisposable
{...}
public class MyClass<T> where T : IDisposable
{
public void SomeMethod(T t)
{
using(t)
{...}
}
}
MyOtherClass myOtherClass = new MyOtherClass();
MyClass<IMyInterface> obj = new MyClass<IMyInterface>();//Does not compile
obj.SomeMethod(myOtherClass);
[Visual Basic]
Public Interface IMyInterface
End Interface
Public Class MyOtherClass
Implements IMyInterface, IDisposable
...
End Class
Public Class SomeClass(Of T As IDisposable)
Public Sub SomeMethod(ByVal value As T)
Using value
End Using
End Sub
End Class
Dim myOtherClass As New MyOtherClass
Dim obj As New SomeClass(Of IMyInterface) ' Does not compile
obj.SomeMethod(myOtherClass)
作为替代，我建议你在using语句里对一般类型参数使用C#中的as操作符或者Visual Basic中的TryCast操作符来允许接口作为一般类型参数使用：
[C#]
public class MyClass<T>
{
public void SomeMethod(T t)
{
using(t as IDisposable)
{...}
}
}
[Visual Basic]
Public Class SomeClass(Of T)
Public Sub SomeMethod(ByVal value As T)
Using TryCast(value, IDisposable)
End Using
End Sub
End Class
可以对一般类型参数进行类型转换吗？
对于隐式转换，编译器只允许将一般类型参数转换为object类型，或者其约束里指定的那个类型：
[C#]
interface ISomeInterface
{...}
class BaseClass
{...}
class MyClass<T> where T : BaseClass,ISomeInterface
{
void SomeMethod(T t)
{
ISomeInterface obj1 = t;
BaseClass obj2 = t;
object obj3 = t;
}
}
[Visual Basic]
Interface ISomeInterface
...
End Interface
Class BaseClass
...
End Class
Class SomeClass(Of T As{BaseClass,ISomeInterface})
Private Sub SomeMethod(ByVal value As T)
Dim obj1 As ISomeInterface = value
Dim obj2 As BaseClass = value
Dim obj3 As Object = value
End Sub
End Class
[C++]
interface class ISomeInterface
{...};
ref class BaseClass
{...};
generic <typename T> where T : BaseClass,ISomeInterface
ref class MyClass
{
void SomeMethod(T t)
{
ISomeInterface ^obj1 = t;
BaseClass ^obj2 = t;
Object ^obj3 = t;
}
};
这种隐式转换当然是类型安全的，因为无效的转换在编译时就会被发现。
对于显示转换，编译器允许将一般类型参数转换到任何接口，但是不能转换为类：
[C#]
interface ISomeInterface
{...}
class SomeClass
{...}
class MyClass<T>
{
void SomeMethod(T t)
{
ISomeInterface obj1 = (ISomeInterface)t;//Compiles
SomeClass obj2 = (SomeClass)t; //Does not compile
}
}
[Visual Basic]
Interface ISomeInterface
...
End Interface
Class BaseClass
...
End Class
Class SomeClass(Of T)
Private Sub SomeMethod(ByVal value As T)
Dim obj1 As ISomeInterface = CType(value,ISomeInterface)' Compiles
Dim obj2 As BaseClass = CType(value,BaseClass)' Does not compile
End Sub
End Class
[C++]
interface class ISomeInterface
{...};
ref class SomeClass
{...};
generic <typename T>
ref class MyClass
{
void SomeMethod(T t)
{
ISomeInterface ^obj1 = (ISomeInterface ^)t;//Compiles
SomeClass ^obj2 = (SomeClass ^)t; //Does not compile
}
};
但是，你可以通过使用一个临时的object类型变量来强制将一般类型参数转到到任何其他类型：
[C#]
class MyOtherClass
{...}
class MyClass<T>
{
void SomeMethod(T t)
{
object temp = t;
MyOtherClass obj = (MyOtherClass)temp;
}
}
[Visual Basic]
Class MyOtherClass
...
End Class
Class SomeClass(Of T)
Sub SomeMethod(ByVal value As T)
Dim temp As Object = value
Dim obj As MyOtherClass = CType(temp, MyOtherClass)
End Sub
End Class
[C++]
ref class SomeClass
{...};
generic <typename T>
ref class MyClass
{
void SomeMethod(T t)
{
Object ^temp = t;
SomeClass ^obj = (SomeClass ^)temp;
}
};
毫无疑问，这样的显示转换是很危险的，因为如果实际使用的替代一般类型参数的类型不是从你要转换到的类型那里继承的话，就可能在运行时抛出异常。
[C#]
为了避免这种转换时有异常的风险，一个更好的办法是使用is或者as操作符。如果一般类型参数是（is）要查询的类型，is 操作符会返回true，而as操作符会在两个类型兼容的时候执行转换，否则将返回null。
public class MyClass<T>
{
public void SomeMethod(T t)
{
if(t is int)
{...}
if(t is LinkedList<int,string>)
{...}
string str = t as string;
if(str != null)
{...}
LinkedList<int,string> list = t as LinkedList<int,string>;
if(list != null)
{...}
}
}
[Visual Basic]
为了避免这种转换时有异常的风险，一个更好的办法是使用TypeOf和TryCast操作符。如果一般类型参数是（is）要查询的类型，is 操作符会返回true。你也可以使用TryCast操作符在两个类型兼容的时候执行转换，否则就返回Nothing。
Class SomeClass(Of T)
Public Sub SomeMethod(ByVal value As T)
If TypeOf value Is Integer Then
...
End If
If TypeOf value Is LinkedList(Of Integer, String) Then
...
End If
Dim str As String = TryCast(value,String)
If (Not str Is Nothing) Then
...
End If
Dim list As LinkedList(Of Integer, String) = _
TryCast(value,LinkedList(Of
Integer, String))
If (Not list Is Nothing) Then
...
End If
End Sub
End Class
对泛型类如何同步多线程访问？
通常来说，你不应该在一般类型参数上应用Monitor。这是因为Monitor只能用于引用类型。当你使用范型的时候，编译器不能预先判断你将会提供一个引用类型还是值类型的类型参数。在C#中，编译器会允许你使用lock语句，但是如果你提供了一个值类型作为类型参数，lock语句在运行时将不起作用。在Visual Basic中，编译器如果不能确定一般类型参数是一个引用类型，它将不允许在一般类型参数上面使用SyncLock。
在C#和Visual Basic中，唯一你可以安全地将一般类型参数锁住的时候，是你将一般类型参数限制为引用类型，要么添加约束使其为引用类型，要么从一个基类中继承：
[C#]
public class MyClass<T> where T : class
{..}
[Visual Basic]
Public Class SomeClass(Of T As Class)
...
End Class
或者：
[C#]
public class SomeClass
{...}
public class MyClass<T> where T : SomeClass
{...}
[Visual Basic]
Public Class SomeClass
...
End Class
Public Class SomeClass(Of T As SomeClass)
...
End Class
然而，通常对于同步来说，最好避免部分地锁住单独的成员变量，因为这会增加死锁的可能性。
如何序列化泛型类？
包括了一般类型参数作为成员的范型类是可以被标记为序列化的：
[C#]
[Serializable]
public class MySerializableClass<T>
{
T m_T;
}
[Visual Basic]
<Serializable()> _
Public Class MySerializableClass(Of T)
Dim m_T As T
End Class
[C++]
generic <typename T>
[Serializable]
public ref class MyClass
{
T m_T;
};
但是，在这种情况下，只有指定的类型参数可以被序列化时，范型类才可以被序列化。看下面的代码：
[C#]
public class SomeClass
{}
MySerializableClass<SomeClass> obj;
[Visual Basic]
Public Class SomeClass
End Class
Dim obj as MySerializableClass(Of SomeClass)
[C++]
public ref class SomeClass
{};
MyClass<SomeClass ^> ^obj;
obj不能被序列化，因为类型参数SomeClass不可以被序列化。因此，MySerializableClass<T>可能可以，也可能不可以被序列化，取决于使用的一般类型参数。这样可能导致在运行时丢失数据或者系统崩溃，因为客户应用程序可能不能够保持对象的状态。
目前，.NET没有提供将一般类型参数约束为可序列化的机制。解决办法是在运行时在使用这个类型之前单独进行检查，并且在任何损害发生之前马上中止使用。你可以把这个运行时的验证放在静态构造器里面：
[C#]
[Serializable]
class MySerializableClass<T>
{
T m_T;
static MySerializableClass()
{
ConstrainType(typeof(T));
}
static void ConstrainType(Type type)
{
bool serializable = type.IsSerializable;
if(serializable == false)
{
string message = "The type " + type + " is not serializable";
throw new InvalidOperationException(message);
}
}
}
[Visual Basic]
<Serializable()> _
Class SomeClass(Of T)
Private m_T As T
Shared Sub New()
ConstrainType(GetType(T))
End Sub
Private Shared Sub ConstrainType(ByVal t As Type)
If Not t.IsSerializable Then
Dim message As String = "The type " + t.ToString() + " is not
serializable"
Throw New InvalidOperationException(message)
End If
End Sub
End Class
[C++]
generic <typename T>
[Serializable]
ref class MyClass
{
T m_T;
public:
static MyClass()
{
ConstrainType(typeid<T>);
}
private:
static void ConstrainType(Type type)
{
bool serializable = type->IsSerializable;
if(serializable == false)
{
String ^message = String::Concat("The type ", type->Name,
" is not serializable");
throw gcnew SerializationException(message);
}
}
};
静态构造器对每一个应用程序域的每一个类型只执行一次，而且是在类型第一次被请求实例化之前。尽管你有一些通过编程的方式来在运行时进行判断和执行检查，但是这种在静态构造器里面执行约束验证的技术，对任何无法在编译时进行检查的约束都适用。
