EntityDataSourceColumn.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataWebControls / System / Data / WebControls / EntityDataSourceColumn.cs / 1599186 / EntityDataSourceColumn.cs
                        
                        
                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner       [....]
// @backupOwner [....] 
//--------------------------------------------------------------------- 

using System; 
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.EntityClient; 
using System.Data.Metadata.Edm;
using System.Diagnostics; 
using System.Globalization; 
using System.Reflection;
using System.ComponentModel; 
using System.Data.Common;
using System.Data.Objects.DataClasses;
using System.Data.Objects;
using System.Data; 
using System.Runtime.CompilerServices;
 
namespace System.Web.UI.WebControls 
{
    ///  
    /// Represents a column in EntityDataSourceView.
    /// 
    internal abstract class EntityDataSourceColumn
    { 
        protected EntityDataSourceColumn(string displayName)
            : this(displayName, (EntityDataSourceColumn)null) 
        { 
        }
 
        protected EntityDataSourceColumn(string displayName, EntityDataSourceColumn controllingColumn)
        {
            EntityDataSourceUtil.CheckArgumentNull(displayName, "displayName");
 
            this.DisplayName = displayName;
            this.ControllingColumn = controllingColumn; 
        } 

        ///  
        /// Gets the display name for this column.
        /// 
        internal readonly string DisplayName;
 
        /// 
        /// Gets the column exposed to the user. For instance, the reference key 
        /// it.Order.OrderID might have a dependent it.OrderID where there is a 
        /// ReferentialConstraint.
        ///  
        internal readonly EntityDataSourceColumn ControllingColumn;

        /// 
        /// Gets value indicating whether the column should be exposed to the user. 
        /// 
        internal bool IsHidden 
        { 
            get
            { 
                // Columns with dependents are not shown to the user. They are
                // merely used to plumb values (e.g. via referential integrity
                // constraints)
                return this.ControllingColumn != null; 
            }
        } 
 
        /// 
        /// Gets the CLR type for the column value. 
        /// 
        internal abstract Type ClrType { get; }

        ///  
        /// Gets a value indicating whether the original value for the column
        /// needs to be preserved. 
        ///  
        internal abstract bool IsInteresting { get; }
 
        /// 
        /// Gets a value indicating whether the column can be modified. Can be
        /// overridden by the collection (which may be readonly).
        ///  
        internal abstract bool CanWrite { get; }
 
        ///  
        /// Indicates whether this column can be assigned a value of null.
        ///  
        internal abstract bool IsNullable { get; }

        /// 
        /// Indicates whether this column represents a primitive type. 
        /// 
        internal abstract bool IsPrimitive { get; } 
 
        /// Returns an Entity-SQL representation of this column with respect
        /// to entity parameter 'it'. 
        /// 
        /// Entity-SQL string.
        internal abstract string GetEntitySqlValue();
 
        internal abstract object GetValue(EntityDataSourceWrapper entity);
        internal abstract void SetValue(EntityDataSourceWrapper entity, object value); 
    } 

    ///  
    /// An EntityDataSourceView column that is an entity type or complex type property.
    /// 
    internal class EntityDataSourcePropertyColumn : EntityDataSourceColumn
    { 
        private readonly EntityDataSourceMemberPath memberPath;
 
        internal EntityDataSourcePropertyColumn(EntityDataSourceMemberPath memberPath) 
            : base(EntityDataSourceUtil.CheckArgumentNull(memberPath, "memberPath").GetDescription())
        { 
            this.memberPath = memberPath;
        }

        internal override bool IsInteresting 
        {
            get 
            { 
                // the member path knows if its interesting...
                return this.memberPath.IsInteresting; 
            }
        }

        internal override bool CanWrite 
        {
            get 
            { 
                // can always write
                return true; 
            }
        }

        internal override bool IsNullable 
        {
            get { return memberPath.IsNullable; } 
        } 

        internal override bool IsPrimitive 
        {
            get { return memberPath.IsPrimitive; }
        }
 
        internal override Type ClrType
        { 
            get { return this.memberPath.ClrType; } 
        }
 
        override internal object GetValue(EntityDataSourceWrapper entity)
        {
            return this.memberPath.GetValue(entity);
        } 

        override internal void SetValue(EntityDataSourceWrapper entity, object value) 
        { 
            this.memberPath.SetValue(entity, value);
        } 

        internal override string GetEntitySqlValue()
        {
            return this.memberPath.GetEntitySqlValue(); 
        }
 
        public override string ToString() 
        {
            return this.memberPath.ToString(); 
        }

        /// 
        /// Indicates whether this column represents a primary key value; 
        /// 
        internal bool IsKey 
        { 
            get { return memberPath.IsKey; }
        } 
    }

    /// 
    /// An EntityDataSourceView column 
    /// 
    internal class EntityDataSourceReferenceKeyColumn : EntityDataSourceColumn 
    { 
        private readonly EntityDataSourceReferenceGroup group;
        private readonly EdmProperty keyMember; 
        private readonly Type clrType;
        private readonly bool isNullable;

        internal EntityDataSourceReferenceKeyColumn(EntityDataSourceReferenceGroup group, EdmProperty keyMember, EntityDataSourceColumn dependent) 
            : base(CreateDisplayName(group, keyMember), dependent)
        { 
            EntityDataSourceUtil.CheckArgumentNull(group, "group"); 
            EntityDataSourceUtil.CheckArgumentNull(keyMember, "keyMember");
 
            this.group = group;
            this.keyMember = keyMember;
            this.clrType = EntityDataSourceUtil.GetPrimitiveMemberClrType(keyMember);
 
            // if the association end is optional (0..1), make sure the CLR type
            // is also nullable 
            if (this.group.End.CorrespondingAssociationEndMember.RelationshipMultiplicity == RelationshipMultiplicity.ZeroOrOne) 
            {
                this.clrType = EntityDataSourceUtil.MakeNullable(clrType); 
                this.isNullable = true;
            }
        }
 
        internal override bool IsInteresting
        { 
            get 
            {
                // references are always interesting 
                return true;
            }
        }
 
        internal override bool CanWrite
        { 
            get 
            {
                // references can always be written 
                return true;
            }
        }
 
        internal override bool IsNullable
        { 
            get { return this.isNullable; } 
        }
 
        internal override bool IsPrimitive
        {
            get { return keyMember.TypeUsage.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType; }
        } 

        internal override Type ClrType 
        { 
            get { return this.clrType; }
        } 

        internal EntityDataSourceReferenceGroup Group
        {
            get { return this.group; } 
        }
 
        internal EdmMember KeyMember 
        {
            get { return this.keyMember; } 
        }

        private static string CreateDisplayName(EntityDataSourceReferenceGroup group, EdmProperty keyMember)
        { 
            EntityDataSourceUtil.CheckArgumentNull(group, "group");
            EntityDataSourceUtil.CheckArgumentNull(keyMember, "keyMember"); 
 
            NavigationProperty navigationProperty;
 
            string result;

            if (EntityDataSourceUtil.TryGetCorrespondingNavigationProperty(group.End.CorrespondingAssociationEndMember, out navigationProperty))
            { 
                result = navigationProperty.Name + "." + keyMember.Name;
            } 
            else 
            {
                // if there is no Navigation property, use the TargetTole and KeyMember name 
                // TargetRole.KeyMember
                result = group.End.Name + "." + keyMember.Name;
            }
 
            return result;
        } 
 
        public override string ToString()
        { 
            return String.Format(CultureInfo.InvariantCulture, "",
                this.group.End.ParentAssociationSet.Name, this.group.End.Name);
        }
 
        internal override object GetValue(EntityDataSourceWrapper entity)
        { 
            EntityKey entityKey = this.Group.GetEntityKey(entity); 
            if (null == entityKey)
            { 
                return null;
            }
            else
            { 
                object value = null;
                // loop through to find the correct keymember, take compound key into consideration 
                foreach (EntityKeyMember entityKeyValue in entityKey.EntityKeyValues) 
                {
                    if (entityKeyValue.Key == this.KeyMember.Name) 
                    {
                        value = entityKeyValue.Value;
                    }
                } 
                return value;
            } 
        } 

        internal override void SetValue(EntityDataSourceWrapper entity, object value) 
        {
            throw new InvalidOperationException(Strings.SetValueNotSupported);
        }
 
        internal override string GetEntitySqlValue()
        { 
            // syntax: NAVIGATE(it, _association_type_name_, _target_role_name_)._key_member_ 
            StringBuilder builder = new StringBuilder();
 
            builder.Append("NAVIGATE(");
            builder.Append(EntityDataSourceUtil.EntitySqlElementAlias);
            builder.Append(", ");
            builder.Append(EntityDataSourceUtil.CreateEntitySqlTypeIdentifier(this.Group.End.ParentAssociationSet.ElementType)); 
            builder.Append(", ");
            builder.Append(EntityDataSourceUtil.QuoteEntitySqlIdentifier(this.Group.End.CorrespondingAssociationEndMember.Name)); 
            builder.Append(")."); 
            builder.Append(EntityDataSourceUtil.QuoteEntitySqlIdentifier(this.keyMember.Name));
            string result = builder.ToString(); 

            return result;
        }
    } 

    internal abstract class EntityDataSourceReferenceValueColumn : EntityDataSourceColumn 
    { 
        private readonly NavigationProperty navigationProperty;
 
        protected EntityDataSourceReferenceValueColumn(MetadataWorkspace ocWorkspace, NavigationProperty navigationProperty)
            : base(EntityDataSourceUtil.CheckArgumentNull(navigationProperty, "navigationProperty").Name)
        {
            EntityDataSourceUtil.CheckArgumentNull(ocWorkspace, "ocWorkspace"); 

            this.navigationProperty = navigationProperty; 
        } 

        [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)] 
        internal static EntityDataSourceReferenceValueColumn Create(Type clrToType, MetadataWorkspace ocWorkspace, NavigationProperty navigationProperty)
        {
            EntityDataSourceUtil.CheckArgumentNull(clrToType, "clrToType");
 
            Type columnType = typeof(EntityDataSourceReferenceValueColumn<>).MakeGenericType(clrToType);
            EntityDataSourceReferenceValueColumn result = (EntityDataSourceReferenceValueColumn)Activator.CreateInstance(columnType, ocWorkspace, navigationProperty); 
            return result; 
        }
 
        internal override bool CanWrite
        {
            get
            { 
                // can never write to a navigation reference
                return false; 
            } 
        }
 
        internal override bool IsNullable
        {
            get { return navigationProperty.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.ZeroOrOne; }
        } 

        protected NavigationProperty NavigationProperty 
        { 
            get { return this.navigationProperty; }
        } 

        internal override bool IsPrimitive
        {
            get { return false; } 
        }
 
        internal override string GetEntitySqlValue() 
        {
            // it.NavigationPropertyName 
            string result = EntityDataSourceUtil.EntitySqlElementAlias + "." + EntityDataSourceUtil.QuoteEntitySqlIdentifier(this.navigationProperty.Name);
            return result;
        }
 
        internal override bool IsInteresting
        { 
            get 
            {
                // a navigation reference is not written, so its original values aren't interesting 
                return false;
            }
        }
 
        internal override void SetValue(EntityDataSourceWrapper entity, object value)
        { 
            throw new InvalidOperationException(Strings.SetValueNotSupported); 
        }
    } 

    internal class EntityDataSourceReferenceValueColumn : EntityDataSourceReferenceValueColumn
        where T : class
    { 
        public EntityDataSourceReferenceValueColumn(MetadataWorkspace ocWorkspace, NavigationProperty navigationProperty)
            : base(ocWorkspace, navigationProperty) 
        { 
        }
 
        internal override object GetValue(EntityDataSourceWrapper entity)
        {
            object result;
            EntityReference reference = GetRelatedReference(entity); 
            if (reference.IsLoaded)
            { 
                result = reference.Value; 
            }
            else 
            {
                result = null;
            }
            return result; 
        }
 
        internal override Type ClrType 
        {
            get 
            {
                return typeof(T);
            }
        } 

        private EntityReference GetRelatedReference(EntityDataSourceWrapper entity) 
        { 
            RelationshipManager relationshipManager = entity.RelationshipManager;
            Debug.Assert(relationshipManager != null, "Coldn't retrieve a RelationshipManager"); 
            EntityReference reference = relationshipManager.GetRelatedReference(
                this.NavigationProperty.RelationshipType.FullName,
                this.NavigationProperty.ToEndMember.Name);
            return reference; 
        }
    } 
} 

// 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
EntityDataSourceColumn.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
