mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
442 lines
15 KiB
C#
442 lines
15 KiB
C#
//---------------------------------------------------------------------
|
|
// <copyright file="EntityDataSourceColumn.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.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
|
|
{
|
|
/// <summary>
|
|
/// Represents a column in EntityDataSourceView.
|
|
/// </summary>
|
|
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;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the display name for this column.
|
|
/// </summary>
|
|
internal readonly string DisplayName;
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
internal readonly EntityDataSourceColumn ControllingColumn;
|
|
|
|
/// <summary>
|
|
/// Gets value indicating whether the column should be exposed to the user.
|
|
/// </summary>
|
|
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;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the CLR type for the column value.
|
|
/// </summary>
|
|
internal abstract Type ClrType { get; }
|
|
|
|
/// <summary>
|
|
/// Gets a value indicating whether the original value for the column
|
|
/// needs to be preserved.
|
|
/// </summary>
|
|
internal abstract bool IsInteresting { get; }
|
|
|
|
/// <summary>
|
|
/// Gets a value indicating whether the column can be modified. Can be
|
|
/// overridden by the collection (which may be readonly).
|
|
/// </summary>
|
|
internal abstract bool CanWrite { get; }
|
|
|
|
/// <summary>
|
|
/// Indicates whether this column can be assigned a value of null.
|
|
/// </summary>
|
|
internal abstract bool IsNullable { get; }
|
|
|
|
/// <summary>
|
|
/// Indicates whether this column represents a scalar type.
|
|
/// </summary>
|
|
internal abstract bool IsScalar { get; }
|
|
|
|
/// Returns an Entity-SQL representation of this column with respect
|
|
/// to entity parameter 'it'.
|
|
/// </summary>
|
|
/// <returns>Entity-SQL string.</returns>
|
|
internal abstract string GetEntitySqlValue();
|
|
|
|
internal abstract object GetValue(EntityDataSourceWrapper entity);
|
|
internal abstract void SetValue(EntityDataSourceWrapper entity, object value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// An EntityDataSourceView column that is an entity type or complex type property.
|
|
/// </summary>
|
|
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 IsScalar
|
|
{
|
|
get { return memberPath.IsScalar; }
|
|
}
|
|
|
|
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();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates whether this column represents a primary key value;
|
|
/// </summary>
|
|
internal bool IsKey
|
|
{
|
|
get { return memberPath.IsKey; }
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// An EntityDataSourceView column
|
|
/// </summary>
|
|
internal class EntityDataSourceReferenceKeyColumn : EntityDataSourceColumn
|
|
{
|
|
private readonly EntityDataSourceReferenceGroup group;
|
|
private readonly EdmProperty keyMember;
|
|
private readonly Type clrType;
|
|
private readonly bool isNullable;
|
|
|
|
internal EntityDataSourceReferenceKeyColumn(MetadataWorkspace workspace, EntityDataSourceReferenceGroup group, EdmProperty keyMember, EntityDataSourceColumn dependent)
|
|
: base(CreateDisplayName(group, keyMember), dependent)
|
|
{
|
|
EntityDataSourceUtil.CheckArgumentNull(group, "group");
|
|
EntityDataSourceUtil.CheckArgumentNull(keyMember, "keyMember");
|
|
Debug.Assert(EntityDataSourceUtil.IsScalar(keyMember.TypeUsage.EdmType), "Expected primitive or enum type for key members.");
|
|
|
|
this.group = group;
|
|
this.keyMember = keyMember;
|
|
this.clrType = EntityDataSourceUtil.GetMemberClrType(workspace, 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 IsScalar
|
|
{
|
|
get { return EntityDataSourceUtil.IsScalar(keyMember.TypeUsage.EdmType); }
|
|
}
|
|
|
|
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, "<Set = {0}, Role = {1}>",
|
|
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 IsScalar
|
|
{
|
|
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<T> : EntityDataSourceReferenceValueColumn
|
|
where T : class
|
|
{
|
|
public EntityDataSourceReferenceValueColumn(MetadataWorkspace ocWorkspace, NavigationProperty navigationProperty)
|
|
: base(ocWorkspace, navigationProperty)
|
|
{
|
|
}
|
|
|
|
internal override object GetValue(EntityDataSourceWrapper entity)
|
|
{
|
|
object result;
|
|
EntityReference<T> reference = GetRelatedReference(entity);
|
|
if (reference.IsLoaded)
|
|
{
|
|
result = reference.Value;
|
|
}
|
|
else
|
|
{
|
|
result = null;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
internal override Type ClrType
|
|
{
|
|
get
|
|
{
|
|
return typeof(T);
|
|
}
|
|
}
|
|
|
|
private EntityReference<T> GetRelatedReference(EntityDataSourceWrapper entity)
|
|
{
|
|
RelationshipManager relationshipManager = entity.RelationshipManager;
|
|
Debug.Assert(relationshipManager != null, "Coldn't retrieve a RelationshipManager");
|
|
EntityReference<T> reference = relationshipManager.GetRelatedReference<T>(
|
|
this.NavigationProperty.RelationshipType.FullName,
|
|
this.NavigationProperty.ToEndMember.Name);
|
|
return reference;
|
|
}
|
|
}
|
|
}
|