FacetValueContainer.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Metadata / Edm / FacetValueContainer.cs / 1305376 / FacetValueContainer.cs

                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner       [....]
// @backupOwner [....] 
//--------------------------------------------------------------------- 
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