FacetValueContainer.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / ndp / fx / src / DataEntity / System / Data / Metadata / Edm / FacetValueContainer.cs / 1 / FacetValueContainer.cs

                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner  [....], [....]
//--------------------------------------------------------------------- 
using System; 
using System.Collections.Generic;
using System.Linq; 
using System.Text;
using System.Diagnostics;

namespace System.Data.Metadata.Edm 
{
    ///  
    /// This Class is never expected to be used except for by the FacetValues class. 
    ///
    /// The purpose of this class is to allow strong type checking by the compiler while setting facet values which 
    /// are typically stored as Object because they can either on of these things
    ///
    /// 1. null
    /// 2. scalar type (bool, int, byte) 
    /// 3. Unbounded object
    /// 
    /// without this class it would be very easy to accidentally set precision to an int when it really is supposed to be 
    /// a byte value.  Also you would be able to set the facet value to any Object derived class (ANYTHING!!!) when really only
    /// null and Unbounded are allowed besides an actual scalar value.  The magic of the class happens in the implicit constructors with 
    /// allow patterns like
    ///
    /// new FacetValues( MaxLength = EdmConstants.UnboundedValue, Nullable = true};
    /// 
    /// and these are type checked at compile time
    ///  
    ///  
    internal struct FacetValueContainer
    { 
        T _value;
        bool _hasValue;
        bool _isUnbounded;
 
        internal T Value
        { 
            set 
            {
                _isUnbounded = false; 
                _hasValue = true;
                _value = value;
            }
        } 

        private void SetUnbounded() 
        { 
            _isUnbounded = true;
            _hasValue = true; 
        }

        // don't add an implicit conversion from object because it will kill the compile time type checking.
        public static implicit operator FacetValueContainer(System.Data.Metadata.Edm.EdmConstants.Unbounded unbounded) 
        {
            Debug.Assert(object.ReferenceEquals(unbounded, EdmConstants.UnboundedValue), "you must pass the unbounded value.  If you are trying to set null, use the T parameter overload"); 
            FacetValueContainer container = new FacetValueContainer(); 
            container.SetUnbounded();
            return container; 
        }

        public static implicit operator FacetValueContainer(T value)
        { 
            FacetValueContainer container = new FacetValueContainer();
            container.Value = value; 
            return container; 
        }
 
        internal object GetValueAsObject()
        {
            Debug.Assert(_hasValue, "Don't get the value if it has not been set");
            if (_isUnbounded) 
            {
                return EdmConstants.UnboundedValue; 
            } 
            else
            { 
                return (object)_value;
            }
        }
 
        internal bool HasValue
        { 
            get 
            {
                return _hasValue; 
            }
        }
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner  [....], [....]
//--------------------------------------------------------------------- 
using System; 
using System.Collections.Generic;
using System.Linq; 
using System.Text;
using System.Diagnostics;

namespace System.Data.Metadata.Edm 
{
    ///  
    /// This Class is never expected to be used except for by the FacetValues class. 
    ///
    /// The purpose of this class is to allow strong type checking by the compiler while setting facet values which 
    /// are typically stored as Object because they can either on of these things
    ///
    /// 1. null
    /// 2. scalar type (bool, int, byte) 
    /// 3. Unbounded object
    /// 
    /// without this class it would be very easy to accidentally set precision to an int when it really is supposed to be 
    /// a byte value.  Also you would be able to set the facet value to any Object derived class (ANYTHING!!!) when really only
    /// null and Unbounded are allowed besides an actual scalar value.  The magic of the class happens in the implicit constructors with 
    /// allow patterns like
    ///
    /// new FacetValues( MaxLength = EdmConstants.UnboundedValue, Nullable = true};
    /// 
    /// and these are type checked at compile time
    ///  
    ///  
    internal struct FacetValueContainer
    { 
        T _value;
        bool _hasValue;
        bool _isUnbounded;
 
        internal T Value
        { 
            set 
            {
                _isUnbounded = false; 
                _hasValue = true;
                _value = value;
            }
        } 

        private void SetUnbounded() 
        { 
            _isUnbounded = true;
            _hasValue = true; 
        }

        // don't add an implicit conversion from object because it will kill the compile time type checking.
        public static implicit operator FacetValueContainer(System.Data.Metadata.Edm.EdmConstants.Unbounded unbounded) 
        {
            Debug.Assert(object.ReferenceEquals(unbounded, EdmConstants.UnboundedValue), "you must pass the unbounded value.  If you are trying to set null, use the T parameter overload"); 
            FacetValueContainer container = new FacetValueContainer(); 
            container.SetUnbounded();
            return container; 
        }

        public static implicit operator FacetValueContainer(T value)
        { 
            FacetValueContainer container = new FacetValueContainer();
            container.Value = value; 
            return container; 
        }
 
        internal object GetValueAsObject()
        {
            Debug.Assert(_hasValue, "Don't get the value if it has not been set");
            if (_isUnbounded) 
            {
                return EdmConstants.UnboundedValue; 
            } 
            else
            { 
                return (object)_value;
            }
        }
 
        internal bool HasValue
        { 
            get 
            {
                return _hasValue; 
            }
        }
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK