Add generic friendly Nullable<T>-like structure that also support reference types

[dmitriyse]

The problem:

public class MyType<T> // T allowed to be Value or Reference type.
{
    // An app object model requires property with this semantic, but currently it's impossible:
    public T? ValueOrNull { get; set;}     // error CS0453: The type 'T' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or method 'Nullable<T>'
}

The workaround:
Helper class that wrap anything into struct:

    /// <summary>
    /// Makes any value to be wrapped as value type.
    /// </summary>
    /// <typeparam name="T">The value to be stored in the box.</typeparam>
    public struct ValueBox<T>: IEquatable<ValueBox<T>>
    {
        /// <inheritdoc/>
        public bool Equals(ValueBox<T> other)
        {
            return EqualityComparer<T>.Default.Equals(Value, other.Value);
        }

        /// <inheritdoc/>
        public override bool Equals(object obj)
        {
            if (ReferenceEquals(null, obj))
            {
                return false;
            }

            return EqualityComparer<T>.Default.Equals(Value, ((ValueBox<T>)obj).Value);
        }

        /// <inheritdoc/>
        public override int GetHashCode()
        {
            return EqualityComparer<T>.Default.GetHashCode(Value);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ValueBox{T}"/> struct.
        /// </summary>
        /// <param name="value">The box content.</param>
        public ValueBox(T value)
        {
            Value = value;
        }

        /// <summary>
        /// The box content.
        /// </summary>
        public T Value { get; }

        /// <summary>
        /// Implicitly converts box to value.
        /// </summary>
        /// <param name="box">The box to convert.</param>
        public static implicit operator T(ValueBox<T> box)
        {
            return box.Value;
        }

        /// <summary>
        /// Implicitly converts value to box.
        /// </summary>
        /// <param name="value">The value </param>
        public static implicit operator ValueBox<T>(T value)
        {
            return new ValueBox<T>(value);
        }

        /// <inheritdoc/>
        public override string ToString()
        {
            return Value != null ? Value.ToString() : "null";
        }
    }

Usage:

public class MyType<T> // T allowed to be Value or Reference type.
{
    // An app object model requires property with this semantic, but currently it's impossible:
    public ValueBox<T>? ValueOrNull { get; set;}     // Now it's supported
}

void Test()
{
            var myInt = new MyType<int>
                             {
                                 ValueOrNull = 10
                             };

            if (myInt.ValueOrNull.HasValue)
            {
                var myStr = new MyType<string>
                                {
                                    ValueOrNull = "Tst"
                                };

                string str = myStr.ValueOrNull.Value;
            }
}

This is dirty trick with multiple side-cases

Probably C# vs CoreClr should have more elegant solution for "ValueOrNull" variables in generic type/methods.

One of the possible approach is to relax restriction:
From

 public struct Nullable<T> where T: struct{}; 

To

 public struct Nullable<T> {}

But this is very very dangerous change, only LDM can predict what will happens after that change.

[iam3yal]

@dmitriyse

Probably C# vs CoreClr should have more elegant solution for "ValueOrNull" variables in generic type/methods.

Did you search anything related to nullable reference types before posting?

[dmitriyse]

The same problem was discussed in "nullable reference types" feature (#36 (comment)) but @gafter answers that "nullable reference types" does not solves "generic nullable types" problem.

[dmitriyse]

Also this problem was discussed here #403

[dmitriyse]

But currently I don't know any "non closed" solution for the problem.

[alrz]

With nullable reference types, I hope we can get T? support on an unconstrained generic type which is to say Nullable<T> should support reference types. That I assume require CLR changes.

[dmitriyse]

@alrz, CoreCLR 2.2 + C# 8.0 is a good roadmap point for this change, hope CLR changes will not be toxic and hard.

[Joe4evr]

Probably the most damning objection to the wrapper structs is probably the degree to which they would hamper interoperation between the different variations of a type. For instance, the conversion from string! to string and on to string? wouldn't be a reference conversion at runtime. Hence, IEnumerable<string!> wouldn't convert to IEnumerable<string>, despite covariance.

Source.

@alrz They're going to add extra constraints, but they won't be CLR-enforced.