Nullable types and their boxing in O/R mapping

Published Nov 22, 2007

Posted in
database
.NET
programming
C#

Nullable types are new to .NET 2.0 and at first glance they seem great. The idea that you can now wrap any type into a generic one that also allows for null values seems valuable enough, especially for database interactions and the dreaded SQL null.

However, having an object that can be both instantiated and null can cause a lot of issues. First of all, boxing! You can define a Nullable<int>, set it to null, then access one of its properties (HasValue). So suddenly a piece of code like obj=null; obj.Property=...; makes sense. But if you want to send it as a parameter for a method, one that receives an object and then does stuff with it, the object must represent the null value, which means it is no longer an instance of anything. Therefore you can't get the type of the variable that was passed to the method!

Quick code snippet:
int? i=null;
DbWrapper.Save("id",i);
With Save defined as:
public void Save(string name,object value)

Now, I want to know what kind of nullable type was sent to the method. I can't see that if the parameter signature is object, so I am creating another signature for the method:
public void Save(string name,Nullable value)

At this time I get an error: static types cannot be used as parameters. And of course I can't, because Nullable is a generic static type that needs the type of the wrapped value. So the type is actually Nullable<int>. My only solution now is to create a signature for every value type: integers, floating point values, booleans, chars and IntPtrs. String and Object are value types, but they accept null, so Nullable<string> is not used on them, but if you count all the other value types , there are 14 of them!

There is another option that I just thought of: a custom object that implicitly converts from a nullable. Then the method would use this object type as a parameter.
I tested it and it works. Here is the code for the object:

Click to show


using System;
using System.Data.SqlTypes;

namespace Siderite.Util
{
    ///<summary>
    /// Wraps a nullable type so that it can be passed as a method parameter
    ///</summary>
    [Serializable]
    public class NullableWrapper
    {
        private Type _underlyingType;
        private object _wrappedValue;

        private NullableWrapper()
        {
        }

        ///<summary>
        /// The underlying type in the nullable type
        ///</summary>
        public Type UnderlyingType
        {
            get { return _underlyingType; }
            set { _underlyingType = value; }
        }

        ///<summary>
        /// The value inside the nullable type
        ///</summary>
        public object WrappedValue
        {
            get { return _wrappedValue; }
            set { _wrappedValue = value; }
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Byte> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Byte);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Int16> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Int16);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Int32> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Int32);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Int64> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Int64);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<UInt16> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (UInt16);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<UInt32> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (UInt32);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<UInt64> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (UInt64);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Single> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Single);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Double> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Double);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Decimal> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Decimal);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Boolean> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Boolean);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Char> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Char);
            nw.WrappedValue = obj ?? null;
            return nw;
        }


        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<IntPtr> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (IntPtr);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<UIntPtr> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (UIntPtr);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Return the Sql Server typed value from the wrapped nullable type
        ///</summary>
        ///<returns></returns>
        ///<exception cref="Exception"></exception>
        public object GetSqlValue()
        {
            if (UnderlyingType == null) return DBNull.Value;
            switch (UnderlyingType.FullName)
            {
                case "System.Byte":
                    return WrappedValue == null
                               ? SqlByte.Null
                               : new SqlByte((byte) WrappedValue);
                case "System.SByte":
                    return WrappedValue == null
                               ? SqlInt16.Null
                               : new SqlInt16((sbyte) WrappedValue);
                case "System.Int16":
                    return WrappedValue == null
                               ? SqlInt16.Null
                               : new SqlInt16((Int16) WrappedValue);
                case "System.Int32":
                    return WrappedValue == null
                               ? SqlInt32.Null
                               : new SqlInt32((Int32) WrappedValue);
                case "System.Int64":
                    return WrappedValue == null
                               ? SqlInt64.Null
                               : new SqlInt64((Int64) WrappedValue);
                case "System.UInt16":
                    return WrappedValue == null
                               ? SqlInt32.Null
                               : new SqlInt32((UInt16) WrappedValue);
                case "System.UInt32":
                    return WrappedValue == null
                               ? SqlInt64.Null
                               : new SqlInt64((UInt32) WrappedValue);
                case "System.UInt64":
                    return WrappedValue == null
                               ? SqlInt64.Null
                               : new SqlInt64(((Int64) WrappedValue));
                case "System.Single":
                    return WrappedValue == null
                               ? SqlSingle.Null
                               : new SqlSingle(((Single) WrappedValue));
                case "System.Double":
                    return WrappedValue == null
                               ? SqlDouble.Null
                               : new SqlDouble(((Double) WrappedValue));
                case "System.Decimal":
                    return WrappedValue == null
                               ? SqlDecimal.Null
                               : new SqlDecimal(((Decimal) WrappedValue));
                case "System.Boolean":
                    return WrappedValue == null
                               ? SqlBoolean.Null
                               : new SqlBoolean(((Boolean) WrappedValue));
                case "System.Char":
                    return WrappedValue == null
                               ? SqlString.Null
                               : new SqlString(((Char) WrappedValue).ToString());
                case "System.String":
                    return WrappedValue == null
                               ? SqlString.Null
                               : new SqlString(((String) WrappedValue));
                default:
                    throw new Exception("Unsupported type " 
                        + UnderlyingType.FullName);
            }
        }
    }
}

Update:
There are issues regarding this object, mainly refering to constants. If you pass a constant value like the number 6 a method that expects either Object or NullableWrapper, will choose NullableWrapper. More than that, it will choose a NullableWrapper<byte> since the value is under 256. Adding signatures for int, double, etc causes Ambiguos reference errors. So my only solution so far is to consider the UnderlyingType of even Nullable<byte> as Int32. It is obviously a hack, but I haven't found a good programming solution to it, yet. If you have an idea, please let me know! Thanks.

Links:
Nullable Types (C# Programming Guide)
Check If Type is a Nullable Type - Convert Nullable Type to Underlying Type - C# 2.0 Generics

Nullable types and their boxing in O/R mapping

Comments

Post a comment