Returning nullable and null in single C# generic method?

There is one more option here you may not have considered...

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;
}

Which lets you do things like this:

int value = 0;
if (!TrySafeGet(myIntList, 0, out value))
{
    //Error handling here
}
else
{
    //value is a valid value here
}

And on the top side, its compatible with the TryXXX of many other type collections, and even the conversion/parsing API's. Its also very apparent of what the function is from the name of the method, it "tries" to get the value, and if it can't, it returns false.

You can do something similar, but different. The result is almost the same. This relies on overloading and method resolution rules.

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...

Not pretty right? But it works.

I would then wrap the whole thing up in a T4 template to reduce the amount of code writing.

EDIT: My OCD has made me use IList instead of List.

The short answer is no, it is not possible. The reason biggest reason I can think of being that if you were able to say "I want an A or a B in this generic method" it would become far more complicated to compile. How would the compiler know that A and B can both be used in the same way? What you have is about as good as it is going to get.

For reference, see this SO question and answer.

I think that one problem with your requirement is that you are trying to make T be both a struct and the respective Nullable<> type of that struct. So I would add second type parameter to the type signature, making it:

static TResult SafeGet<TItem, TResult>(List<TItem> list, int index)

But there's still one problem: there are no generic constraints for the relationships you want to express between the source type and the result type, so you'll have to perform some runtime checks.

If you're willing to do the above, then you could go for something like this:

    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];
            }
        }
    }

My solution to this is to write a better Nullable<T>. It's not as elegant, mainly you can't use int?, but it allows the use of a nullable value without knowing if it's a class or a struct.

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;
   }
}

It may be tempting to write a GetValueOrDefault method, but that is where you will hit the problem. To use this you will always have to check if the value is there or not first.