Files
mono/mcs/class/referencesource/System.Web.Entity/System/Data/WebControls/EntityDataSourceMemberPath.cs
T
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

206 lines
6.7 KiB
C#

//---------------------------------------------------------------------
// <copyright file="EntityDataSourceMemberPath.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//
// @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
{
/// <summary>
/// A glorified linked list. Describes a chain of properties from a primitive
/// type to a root entity.
/// </summary>
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);
}
/// <summary>
/// Describes the member path in the form 'property1.property2...'. Use to
/// determine display name for nested properties in the EDSC.
/// </summary>
/// <returns>Description of the </returns>
internal string GetDescription()
{
string prefix = null == this.parent ? string.Empty : this.parent.GetDescription() + ".";
return prefix + this.property.Name;
}
/// <summary>
/// Indicates whether original values of this member should be preserved.
/// </summary>
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);
}
}
/// <summary>
/// Indicates whether this member represents a primary key value.
/// </summary>
internal bool IsKey
{
get { return this.isKey; }
}
/// <summary>
/// Indicates whether this member can be assigned a value of null.
/// </summary>
internal bool IsNullable
{
get { return this.property.Nullable; }
}
internal bool IsScalar
{
get { return EntityDataSourceUtil.IsScalar(this.property.TypeUsage.EdmType); }
}
/// <summary>
/// Gets the CLR type of the last member in the path.
/// </summary>
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;
}
}
}