EntityDataSourceMemberPath.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataWebControls / System / Data / WebControls / EntityDataSourceMemberPath.cs / 1305376 / EntityDataSourceMemberPath.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.Data.Common; 
using System.Data.Objects;

namespace System.Web.UI.WebControls
{ 
    /// 
    /// A glorified linked list. Describes a chain of properties from a primitive 
    /// type to a root entity. 
    /// 
    class EntityDataSourceMemberPath 
    {
        private readonly EdmProperty property;
        private readonly PropertyInfo propertyInfo;
        private readonly EntityDataSourceMemberPath parent; 
        private readonly bool isLocallyInteresting;
        private readonly Type clrType; 
        private readonly bool isKey; 

        internal EntityDataSourceMemberPath(MetadataWorkspace ocWorkspace, EntityDataSourceMemberPath parent, EdmProperty property, bool isLocallyInteresting) 
        {
            EntityDataSourceUtil.CheckArgumentNull(ocWorkspace, "ocWorkspace");
            EntityDataSourceUtil.CheckArgumentNull(property, "property");
 
            this.property = property;
            this.parent = parent; 
            this.isLocallyInteresting = isLocallyInteresting; 
            this.clrType = EntityDataSourceUtil.GetMemberClrType(ocWorkspace, property);
            this.isKey = IsPropertyAKey(property); 

            // retrieve PropertyInfo (with respect to parent CLR type)
            StructuralType parentType = property.DeclaringType;
            Type parentClrType = EntityDataSourceUtil.GetClrType(ocWorkspace, parentType); 

            this.propertyInfo = EntityDataSourceUtil.GetPropertyInfo(parentClrType, this.property.Name); 
        } 

         ///  
        /// Describes the member path in the form 'property1.property2...'. Use to
        /// determine display name for nested properties in the EDSC.
        /// 
        /// Description of the  
        internal string GetDescription()
        { 
            string prefix = null == this.parent ? string.Empty : this.parent.GetDescription() + "."; 
            return prefix + this.property.Name;
        } 

        /// 
        /// Indicates whether original values of this member should be preserved.
        ///  
        internal bool IsInteresting
        { 
            get 
            {
                // a member path is interesting if anything along the path is interesting 
                return this.isLocallyInteresting || (null != this.parent && this.parent.IsInteresting);
            }
        }
 
        /// 
        /// Indicates whether this member represents a primary key value. 
        ///  
        internal bool IsKey
        { 
            get { return this.isKey; }
        }

        ///  
        /// Indicates whether this member can be assigned a value of null.
        ///  
        internal bool IsNullable 
        {
            get { return this.property.Nullable; } 
        }

        internal bool IsPrimitive
        { 
            get { return this.property.TypeUsage.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType; }
        } 
 
        /// 
        /// Gets the CLR type of the last member in the path. 
        /// 
        internal Type ClrType
        {
            get { return this.clrType; } 
        }
 
        internal object GetValue(EntityDataSourceWrapper entity) 
        {
            object parentObjectValue = GetParentObjectValue(entity, false /* initialize */); 
            if (null == parentObjectValue)
            {
                // use convention that property of null is null
                return null; 
            }
            else 
            { 
                // get this property
                object propertyValue = this.propertyInfo.GetValue(parentObjectValue, new object[] { }); 

                return propertyValue;
            }
        } 

        internal void SetValue(EntityDataSourceWrapper entity, object value) 
        { 
            object parentObjectValue = GetParentObjectValue(entity, true /* initialize */);
 
            // set property value on parent
            this.propertyInfo.SetValue(parentObjectValue, value, new object[] { });
        }
 
        private object Initialize(EntityDataSourceWrapper entity)
        { 
            // get parent's value 
            object parentObjectValue = GetParentObjectValue(entity, true /* initialize */);
 
            // construct type instance for this property
            object propertyValue = EntityDataSourceUtil.InitializeType(this.ClrType);

            // set property 
            this.propertyInfo.SetValue(parentObjectValue, propertyValue, new object[] { });
 
            return propertyValue; 
        }
 
        private object GetParentObjectValue(EntityDataSourceWrapper entity, bool initialize)
        {
            // get parent's value
            object parentObjectValue; 

            if (null == this.parent) 
            { 
                // at the top level, the entity is the value
                parentObjectValue = entity.WrappedEntity; 
            }
            else
            {
                parentObjectValue = this.parent.GetValue(entity); 

                if (null == parentObjectValue && initialize) 
                { 
                    parentObjectValue = this.parent.Initialize(entity);
                } 
            }

            return parentObjectValue;
        } 

        internal string GetEntitySqlValue() 
        { 
            // it.[member1].[member2]...
            string prefix; 

            if (null != parent)
            {
                prefix = parent.GetEntitySqlValue(); 
            }
            else 
            { 
                prefix = EntityDataSourceUtil.EntitySqlElementAlias;
            } 

            string eSql = prefix + "." + EntityDataSourceUtil.QuoteEntitySqlIdentifier(this.property.Name);

            return eSql; 
        }
 
        private bool IsPropertyAKey(EdmProperty property) 
        {
            bool isKey = false; 
            EntityType entityType = property.DeclaringType as EntityType;
            if (null != entityType)
            {
                isKey = entityType.KeyMembers.Contains(property); 
            }
            return isKey; 
        } 

        public override string ToString() 
        {
            string prefix = null == this.parent ? string.Empty : this.parent.ToString() + "->";
            return prefix + this.property.Name;
        } 
    }
} 

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

Source code for the .NET framework in C#

Code:

Link Menu
