在C＃泛型方法中是否可以返回对象类型或Nullable类型？
例如，如果我有一个List的安全索引访问器，我想返回一个值，我可以稍后用== null或.HasValue()检查。
我目前有以下两种方法：
static T? SafeGet<T>(List<T> list, int index) where T : struct
{
if (list == null || index < 0 || index >= list.Count)
{
return null;
}
return list[index];
}
static T SafeGetObj<T>(List<T> list, int index) where T : class
{
if (list == null || index < 0 || index >= list.Count)
{
return null;
}
return list[index];
}
如果我尝试将方法组合到一个方法中。
static T SafeGetTest<T>(List<T> list, int index)
{
if (list == null || index < 0 || index >= list.Count)
{
return null;
}
return list[index];
}
我收到编译错误：
无法将null转换为类型参数'T'，因为它可能是不可为空的值类型。考虑使用'default（T）'代替。
但我不想使用default(T)，因为在原语的情况下，0是int的默认值，是一个可能的实际值，我需要区分不可用的值。
这些方法是否可以组合成一个方法？
（为了记录我使用.NET 3.0，虽然我对更现代的C＃可以做什么感兴趣，但我个人只能使用3.0中的答案）
不完全是你想要的，但可能的解决方法是返回一个元组（或其他包装类）：
static Tuple<T> SafeGetObj<T>(List<T> list, int index)
{
if (list == null || index < 0 || index >= list.Count)
{
return null;
}
return Tuple.Create(list[index]);
}
Null总是意味着不能获得任何值，单个元组本身就意味着一个值（即使值本身可以为null）。
在vs2015中，您可以在调用时使用?.表示法：var val = SafeGetObj(somedoublelist, 0)?.Item1;当然，您可以创建自己的通用包装器而不是Tuple。
如上所述，并不完全是最优的，但它是一个可行的工作，并且具有能够看到不是有效选择和空元素之间的区别的额外好处。
自定义包装器实现的示例：
struct IndexValue<T>
{
T value;
public bool Succes;
public T Value
{
get
{
if (Succes) return value;
throw new Exception("Value could not be obtained");
}
}
public IndexValue(T Value)
{
Succes = true;
value = Value;
}
public static implicit operator T(IndexValue<T> v) { return v.Value; }
}
static IndexValue<T> SafeGetObj<T>(List<T> list, int index)
{
if (list == null || index < 0 || index >= list.Count)
{
return new IndexValue<T>();
}
return new IndexValue<T>(list[index]);
}
还有一个选项，你可能没有考虑过......
public static bool TrySafeGet<T>(IList<T> list, int index, out T value)
{
value = default(T);
if (list == null || index < 0 || index >= list.Count)
{
return false;
}
value = list[index];
return true;
}
这可以让你做这样的事情：
int value = 0;
if (!TrySafeGet(myIntList, 0, out value))
{
//Error handling here
}
else
{
//value is a valid value here
}
在顶部，它兼容许多其他类型集合的TryXXX，甚至转换/解析API。它也很明显该函数来自方法的名称，它“尝试”获取值，如果不能，则返回false。
你可以做类似但不同的事情。结果几乎相同。这依赖于重载和方法解析规则。
private static T? SafeGetStruct<T>(IList<T> list, int index) where T : struct
{
if (list == null || index < 0 || index >= list.Count)
{
return null;
}
return list[index];
}
public static T SafeGet<T>(IList<T> list, int index) where T : class
{
if (list == null || index < 0 || index >= list.Count)
{
return null;
}
return list[index];
}
public static int? SafeGet(IList<int> list, int index)
{
return SafeGetStruct(list, index);
}
public static long? SafeGet(IList<long> list, int index)
{
return SafeGetStruct(list, index);
}
etc...
不太对劲？但它的确有效。
然后我会在T4模板中包装整个内容以减少代码编写量。
编辑：我的OCD让我使用IList而不是List。
简短的回答是不，这是不可能的。我能想到的最大原因是，如果你能够说“我想在这个通用方法中使用A或B”，编译就会变得复杂得多。编译器如何知道A和B都可以以相同的方式使用？你所拥有的就是它将会变得如此美好。
有关参考，请参阅this SO question and answer。
我认为你的要求的一个问题是你试图使T既是结构又是该结构的Nullable<>类型。所以我会在类型签名中添加第二个类型参数，使其成为：
static TResult SafeGet<TItem, TResult>(List<TItem> list, int index)
但是仍然存在一个问题：对于要在源类型和结果类型之间表达的关系没有通用约束，因此您必须执行一些运行时检查。
如果你愿意做上述事情，那么你可以选择这样的事情：
static TResult SafeGet<TItem, TResult>(List<TItem> list, int index)
{
var typeArgumentsAreValid =
// Either both are reference types and the same type
(!typeof (TItem).IsValueType && typeof (TItem) == typeof (TResult))
// or one is a value type, the other is a generic type, in which case it must be
|| (typeof (TItem).IsValueType && typeof (TResult).IsGenericType
// from the Nullable generic type definition
&& typeof (TResult).GetGenericTypeDefinition() == typeof (Nullable<>)
// with the desired type argument.
&& typeof (TResult).GetGenericArguments()[0] == typeof(TItem));
if (!typeArgumentsAreValid)
{
throw new InvalidOperationException();
}
var argumentsAreInvalid = list == null || index < 0 || index >= list.Count;
if (typeof (TItem).IsValueType)
{
var nullableType = typeof (Nullable<>).MakeGenericType(typeof (TItem));
if (argumentsAreInvalid)
{
return (TResult) Activator.CreateInstance(nullableType);
}
else
{
return (TResult) Activator.CreateInstance(nullableType, list[index]);
}
}
else
{
if (argumentsAreInvalid)
{
return default(TResult);
}
else
{
return (TResult)(object) list[index];
}
}
}
我的解决方案是写一个更好的Nullable<T>。它并不优雅，主要是你不能使用int?，但它允许使用可空值而不知道它是一个类还是一个结构。
public sealed class MyNullable<T> {
T mValue;
bool mHasValue;
public bool HasValue { get { return mHasValue; } }
public MyNullable() {
}
public MyNullable(T pValue) {
SetValue(pValue);
}
public void SetValue(T pValue) {
mValue = pValue;
mHasValue = true;
}
public T GetValueOrThrow() {
if (!mHasValue)
throw new InvalidOperationException("No value.");
return mValue;
}
public void ClearValue() {
mHasValue = false;
}
}
写一个GetValueOrDefault方法可能很诱人，但这就是你遇到问题的地方。要使用它，您必须首先检查值是否存在。