ObjectParameter.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 / Objects / ObjectParameter.cs / 1305376 / ObjectParameter.cs

                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner [....]
// @backupowner [....] 
//--------------------------------------------------------------------- 

using System; 
using System.Text.RegularExpressions;
using System.Collections;
using System.Collections.Generic;
using System.Data; 
using System.Data.Common;
using System.Data.Common.CommandTrees; 
using System.Data.Metadata.Edm; 
using System.Diagnostics;
 
namespace System.Data.Objects
{
    /// 
    ///   This class represents a query parameter at the object layer, which consists 
    ///   of a Name, a Type and a Value.
    ///  
    public sealed class ObjectParameter 
    {
        #region Static Methods 

        // --------------
        // Static Methods
        // -------------- 

        #region ValidateParameterName 
 
        /// 
        ///   This internal method uses regular expression matching to ensure that the 
        ///   specified parameter name is valid. Parameter names must start with a letter,
        ///   and may only contain letters (A-Z, a-z), numbers (0-9) and underscores (_).
        /// 
        internal static bool ValidateParameterName (string name) 
        {
            // Note: Parameter names must begin with a letter, and may contain only 
            // letters, numbers and underscores. 
            return DbCommandTree.IsValidParameterName(name);
        } 

        #endregion

        #endregion 

        #region Public Constructors 
 
        // -------------------
        // Public Constructors 
        // -------------------

        #region ObjectParameter (string, Type)
 
        /// 
        ///   This constructor creates an unbound (i.e., value-less) parameter from the 
        ///   specified name and type. The value can be set at any time through the 
        ///   public 'Value' property.
        ///  
        /// 
        ///   The parameter name.
        /// 
        ///  
        ///   The CLR type of the parameter.
        ///  
        ///  
        ///   A new unbound ObjectParameter instance.
        ///  
        /// 
        ///   If the value of either argument is null.
        /// 
        ///  
        ///   If the value of the name argument is invalid. Parameter names must start
        ///   with a letter and may only contain letters (A-Z, a-z), numbers (0-9) and 
        ///   underscores (_). 
        /// 
        public ObjectParameter (string name, Type type) 
        {
            EntityUtil.CheckArgumentNull(name, "name");
            EntityUtil.CheckArgumentNull(type, "type");
 
            if (!ObjectParameter.ValidateParameterName(name))
            { 
                throw EntityUtil.Argument(System.Data.Entity.Strings.ObjectParameter_InvalidParameterName(name), "name"); 
            }
 
            this._name  = name;
            this._type  = type;

            // If the parameter type is Nullable<>, we need to extract out the underlying 
            // Nullable<> type argument.
            this._mappableType = System.Data.Objects.ELinq.TypeSystem.GetNonNullableType(this._type); 
        } 

        #endregion 

        #region ObjectParameter (string, object)

        ///  
        ///   This constructor creates a fully-bound (i.e., valued) parameter from the
        ///   specified name and value. The type is inferred from the initial value, but 
        ///   the value can be changed at any time through the public 'Value' property. 
        /// 
        ///  
        ///   The parameter name.
        /// 
        /// 
        ///   The initial value (and inherently, type) of the parameter. 
        /// 
        ///  
        ///   A new fully-bound ObjectParameter instance. 
        /// 
        ///  
        ///   If the value of either argument is null.
        /// 
        /// 
        ///   If the value of the name argument is invalid. Parameter names must start 
        ///   with a letter and may only contain letters (A-Z, a-z), numbers (0-9) and
        ///   underscores (_). 
        ///  
        public ObjectParameter (string name, object value)
        { 
            EntityUtil.CheckArgumentNull(name, "name");
            EntityUtil.CheckArgumentNull(value, "value");

            if (!ObjectParameter.ValidateParameterName(name)) 
            {
                throw EntityUtil.Argument(System.Data.Entity.Strings.ObjectParameter_InvalidParameterName(name), "name"); 
            } 

            this._name  = name; 
            this._type  = value.GetType();
            this._value = value;

            // If the parameter type is Nullable<>, we need to extract out the underlying 
            // Nullable<> type argument.
            this._mappableType = System.Data.Objects.ELinq.TypeSystem.GetNonNullableType(this._type); 
        } 

        #endregion 

        #endregion

        #region Private Constructors 

        // ------------------- 
        // Copy Constructor 
        // -------------------
 
        /// 
        ///   This constructor is used by  to create a new ObjectParameter
        ///   with field values taken from the field values of an existing ObjectParameter.
        ///  
        /// 
        ///   The existing ObjectParameter instance from which field values should be taken. 
        ///  
        /// 
        ///   A new ObjectParameter instance with the same field values as the specified ObjectParameter 
        /// 
        private ObjectParameter(ObjectParameter template)
        {
            Debug.Assert(template != null, "Template ObjectParameter cannot be null"); 

            this._name = template._name; 
            this._type = template._type; 
            this._mappableType = template._mappableType;
            this._effectiveType = template._effectiveType; 
            this._value = template._value;
        }

        #endregion 

        #region Private Fields 
 
        // --------------
        // Private Fields 
        // --------------

        /// 
        ///   The name of the parameter. Cannot be null and is immutable. 
        /// 
        private string _name; 
 
        /// 
        ///   The CLR type of the parameter. Cannot be null and is immutable. 
        /// 
        private Type _type;

        ///  
        ///   The mappable CLR type of the parameter. Unless the parameter type is
        ///   Nullable, this type is equal to the parameter type. In the case of 
        ///   Nullable parameters, this type is the underlying Nullable argument 
        ///   type. Cannot be null and is immutable.
        ///  
        private Type _mappableType;

        /// 
        ///     Used to specify the exact metadata type of this parameter. 
        ///     Typically null, can only be set using the internal  property.
        ///  
        private TypeUsage _effectiveType; 

        ///  
        ///   The value of the parameter. Does not need to be bound until execution
        ///   time and can be modified at any time.
        /// 
        private object _value; 

        #endregion 
 
        #region Public Properties
 
        // -----------------
        // Public Properties
        // -----------------
 
        /// 
        ///   The parameter name, which can only be set through a constructor. 
        ///  
        public string Name
        { 
            get
            {
                return this._name;
            } 
        }
 
        ///  
        ///   The parameter type, which can only be set through a constructor.
        ///  
        public Type ParameterType
        {
            get
            { 
                return this._type;
            } 
        } 

        ///  
        ///   The parameter value, which can be set at any time (and subsequently
        ///   changed) before query execution. Note that type-checking is not
        ///   enforced between the declared parameter type and the type of the
        ///   specified value; such validation is left up to the underlying 
        ///   provider(s) at execution time.
        ///  
        public object Value 
        {
            get 
            {
                return this._value;
            }
 
            set
            { 
                this._value = value; 
            }
        } 

        #endregion

        #region Internal Properties 

        // ------------------- 
        // Internal Properties 
        // -------------------
 
        /// 
        ///     Gets or sets a  that specifies the exact
        ///     type of which the parameter value is considered an instance.
        ///  
        internal TypeUsage TypeUsage
        { 
            get 
            {
                return _effectiveType; 
            }

            set
            { 
                Debug.Assert(null == _effectiveType, "Effective type should only be set once");
                _effectiveType = value; 
            } 
        }
 
        /// 
        ///   The mappable parameter type; this is primarily used to handle the case of
        ///   Nullable parameter types. For example, metadata knows nothing about 'int?',
        ///   only 'Int32'. For internal use only. 
        /// 
        internal Type MappableType 
        { 
            get
            { 
                return this._mappableType;
            }
        }
 
        #endregion
 
        #region Internal Methods 

        // ---------------- 
        // Internal Methods
        // ----------------

        ///  
        /// Creates a new ObjectParameter instance with identical field values to this instance.
        ///  
        /// The new ObjectParameter instance 
        internal ObjectParameter ShallowCopy()
        { 
            return new ObjectParameter(this);
        }

        ///  
        ///   This internal method ensures that the specified type is a scalar
        ///   type supported by the underlying provider by ensuring that scalar 
        ///   metadata for this type is retrievable. 
        /// 
        internal bool ValidateParameterType (ClrPerspective perspective) 
        {
            TypeUsage type = null;

            // The parameter type metadata is only valid if it's scalar or enumeration type metadata. 
            if ((perspective.TryGetType(this._mappableType, out type)) &&
                (TypeSemantics.IsPrimitiveType(type) || TypeSemantics.IsEnumerationType(type))) 
            { 
                return true;
            } 

            return false;
        }
 
        #endregion
    } 
} 

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