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
1783 lines
78 KiB
C#
1783 lines
78 KiB
C#
//---------------------------------------------------------------------
|
|
// <copyright file="EntityDataSourceView.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//
|
|
// @owner [....]
|
|
// @backupOwner [....]
|
|
//---------------------------------------------------------------------
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Data.Common;
|
|
using System.Data.Metadata.Edm;
|
|
using System.Data.Objects;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Web.DynamicData;
|
|
using System.Runtime.CompilerServices;
|
|
|
|
namespace System.Web.UI.WebControls
|
|
{
|
|
public class EntityDataSourceView : DataSourceView, IStateManager
|
|
{
|
|
/// <summary>
|
|
/// Helper class used to manage EntityDataSourceWrapperCollection collections.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Entities in EntityDataSourceWrapperCollection are wrapped in order to allow for easy access to nested properties (and also
|
|
/// to be able to handle independendent associations - it was especially important in v1 where foreign keys were not supported).
|
|
/// This is handy when we need to get or set property values because we set values the same way regeradless if a
|
|
/// property is nested or not. Additional benefit is that the entities from EntityDataSourceWrapperCollection can be
|
|
/// easily stored and restored into/from the viewstate.
|
|
/// We cache entities in EntityDataSourceWrapperCollection in two cases:
|
|
/// - EntityDataSource.EnableFlattening flag is set to true. In this case the user requested entities to be flattened and wrapping allows
|
|
/// for an easy translation between tabular and hierarchical forms
|
|
/// - EntityDataSource.EnableUpdate flag is set meaning the user allows for updating entities. In this case we use EntityDataSourceWrapperCollection
|
|
/// to cache original values so that we can store them easily in the viewstate. The reason for storing values in the viewstate is that the
|
|
/// update operation can be mapped to a function. If we don't store the original values we would invoke the update function but some parameters
|
|
/// would not be. This would result in data corruption as we would override existing data in the database with default values (nulls) or an exception
|
|
/// if the target column in the database does not allow null values.
|
|
/// When the parameters would not be set? This happens when the dictionary containing oldValues passed to ExecuteUpdate method is missing some
|
|
/// values. This in turn can happen if EnableFlattening is set to false and the entity contains a complex property. The values of child properties of the
|
|
/// complex property are not displayed to the user and as a result the values for columns that were not shown are not passed back to the
|
|
/// ExecuteUpdate method. Another case is when the user uses a GridView bound to EntityDataSource. If the user hides some columns the values
|
|
/// for the hidden columns will not be passed to the ExecuteUpdate method.
|
|
/// Note that when entity flattening is enabled we will always store values returned from Select in the viewstate so we don't need to do anything special
|
|
/// for update. When entity flattening is disabled we always store the values if EnableUpdate is set to true. This is not really needed if the update operation
|
|
/// is not mapped to a function but if you are not inside System.Data.Entity.dll there is no way to tell whether the operation is mapped to a function so we need
|
|
/// to do it always.
|
|
/// </remarks>
|
|
private class WrapperCollectionManager
|
|
{
|
|
/// <summary>
|
|
/// Modes the manager can be working in.
|
|
/// </summary>
|
|
public enum ManagerMode
|
|
{
|
|
/// <summary>
|
|
/// None - entities are not stored. <see cref="_collection"/> is null.
|
|
/// Both <see cref="FlattenedEntityCollection"/> and <see cref="UpdateCache"/> return null.
|
|
/// </summary>
|
|
None,
|
|
|
|
/// <summary>
|
|
/// Entites are stored because <see cref="EntityDataSource.EnableFlattening"/> flag is set to true.
|
|
/// <see cref="FlattenedEntityCollection"/> returns non-null value whiel <see cref="UpdateCache"/> returns null.
|
|
/// </summary>
|
|
FlattenedEntities,
|
|
|
|
/// <summary>
|
|
/// Entites are stored because <see cref="EntityDataSource.EnableFlattening"/> flag is set to false but
|
|
/// <see cref="EntityDataSource.EnableUpdate"/> is set to true.
|
|
/// <see cref="FlattenedEntityCollection"/> returns non-null value whiel <see cref="UpdateCache"/> returns null.
|
|
/// </summary>
|
|
UpdateCache
|
|
}
|
|
|
|
private ManagerMode _collectionMode;
|
|
private EntityDataSourceWrapperCollection _collection;
|
|
|
|
/// <summary>
|
|
/// Mode the WrapperCollectionManager is working in.
|
|
/// </summary>
|
|
public ManagerMode Mode
|
|
{
|
|
get { return _collectionMode; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets collection containing flattened entities. Possibly null.
|
|
/// </summary>
|
|
public EntityDataSourceWrapperCollection FlattenedEntityCollection
|
|
{
|
|
get { return _collectionMode == ManagerMode.FlattenedEntities ? _collection : null; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets collection cached entities. Possibly null.
|
|
/// </summary>
|
|
public EntityDataSourceWrapperCollection UpdateCache
|
|
{
|
|
get { return _collectionMode == ManagerMode.UpdateCache ? _collection : null; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a collection for storing wrapped entities.
|
|
/// </summary>
|
|
/// <param name="context">ObjectContext</param>
|
|
/// <param name="entitySet">Entity set the stored belongs to.</param>
|
|
/// <param name="CSpaceFilteredEntityType">What entity type restrict the collection to. Null if all derived entity types are allowed.</param>
|
|
/// <param name="mode">What mode to store the entities. Never <see cref="ManagerMode.None"/>.</param>
|
|
public void CreateCollection(ObjectContext context, EntitySet entitySet, EntityType CSpaceFilteredEntityType, ManagerMode mode)
|
|
{
|
|
Debug.Assert(context != null);
|
|
Debug.Assert(entitySet != null);
|
|
Debug.Assert(mode != ManagerMode.None);
|
|
Debug.Assert(_collectionMode == ManagerMode.None || _collectionMode == mode, "Cannot reset a collection working in a different mode.");
|
|
|
|
_collectionMode = mode;
|
|
_collection = new EntityDataSourceWrapperCollection(context, entitySet, CSpaceFilteredEntityType);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wraps the <paramref name="entity"/> and adds it to the collection.
|
|
/// </summary>
|
|
/// <param name="entity">Entity to add to the collection. Must not be null.</param>
|
|
public void AddWrappedEntity(object entity)
|
|
{
|
|
Debug.Assert(entity != null);
|
|
Debug.Assert(Mode != ManagerMode.None);
|
|
|
|
_collection.AddWrappedEntity(entity);
|
|
}
|
|
}
|
|
|
|
private EntityDataSource _owner;
|
|
private ObjectContext _ctx = null;
|
|
private ReadOnlyMetadataCollection<EdmMember> _keyMembers = null;
|
|
|
|
private static readonly object EventContextCreated = new object();
|
|
private static readonly object EventContextCreating = new object();
|
|
private static readonly object EventContextDisposing = new object();
|
|
private static readonly object EventDeleted = new object();
|
|
private static readonly object EventDeleting = new object();
|
|
private static readonly object EventInserted = new object();
|
|
private static readonly object EventInserting = new object();
|
|
private static readonly object EventSelected = new object();
|
|
private static readonly object EventSelecting = new object();
|
|
private static readonly object EventUpdated = new object();
|
|
private static readonly object EventUpdating = new object();
|
|
private static readonly object EventException = new object();
|
|
private static readonly object EventQueryCreated = new object();
|
|
|
|
// values saved in ViewState
|
|
private bool _disableUpdates = false;
|
|
private bool _tracking = false;
|
|
|
|
private Dictionary<string, ArrayList> _originalProperties;
|
|
|
|
private WrapperCollectionManager _collectionManager = new WrapperCollectionManager();
|
|
|
|
#region Constructor
|
|
|
|
/// <summary>
|
|
/// Initialize a new named instance of the EntityDataSourceView class, and
|
|
/// associates the specified EntityDataSource with it.
|
|
/// </summary>
|
|
public EntityDataSourceView(EntityDataSource owner, string viewName)
|
|
: base(owner, viewName)
|
|
{
|
|
_owner = owner;
|
|
}
|
|
#endregion Constructor
|
|
|
|
#region ExecuteSelect
|
|
|
|
private static readonly MethodInfo _executeSelectMethod = typeof(EntityDataSourceView).GetMethod("ExecuteSelectTyped", BindingFlags.NonPublic | BindingFlags.Instance);
|
|
private static readonly MethodInfo _continueSelectMethod = typeof(EntityDataSourceView).GetMethod("ContinueSelectTyped", BindingFlags.NonPublic | BindingFlags.Instance);
|
|
private static readonly Type[] queryBuilderCreatorArgTypes = { typeof(DataSourceSelectArguments), typeof(string), typeof(ObjectParameter[]),
|
|
typeof(string), typeof(ObjectParameter[]), typeof(string),
|
|
typeof(string), typeof(string), typeof(ObjectParameter[]),
|
|
typeof(OrderByBuilder), typeof(string) };
|
|
|
|
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
|
|
protected override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)
|
|
{
|
|
// reset collections
|
|
_collectionManager = new WrapperCollectionManager();
|
|
|
|
AddSupportedCapabilities(arguments);
|
|
arguments.RaiseUnsupportedCapabilitiesError(this);
|
|
|
|
ConstructContext();
|
|
|
|
var selectArgs = new EntityDataSourceSelectingEventArgs(_owner, arguments);
|
|
OnSelecting(selectArgs);
|
|
if (selectArgs.Cancel)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
_disableUpdates = _owner.ValidateUpdatableConditions();
|
|
|
|
if (_owner.ValidateWrappable() || CanUpdate)
|
|
{
|
|
_collectionManager.CreateCollection(
|
|
Context,
|
|
EntitySet,
|
|
CSpaceFilteredEntityType,
|
|
_owner.ValidateWrappable() ? WrapperCollectionManager.ManagerMode.FlattenedEntities : WrapperCollectionManager.ManagerMode.UpdateCache);
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(_owner.Select))
|
|
{
|
|
return ExecuteSelectTyped<DbDataRecord>(arguments, EntityDataSourceRecordQueryBuilder.Create);
|
|
}
|
|
else if (!string.IsNullOrEmpty(_owner.CommandText))
|
|
{
|
|
return ExecuteSelectTyped<object>(arguments, EntityDataSourceObjectQueryBuilder<object>.Create);
|
|
}
|
|
else
|
|
{
|
|
Type builderType = typeof(EntityDataSourceObjectQueryBuilder<>).MakeGenericType(EntityClrType);
|
|
MethodInfo getCreatorMethod = builderType.GetMethod("GetCreator", BindingFlags.Static | BindingFlags.NonPublic);
|
|
object createDelegate = getCreatorMethod.Invoke(null, null);
|
|
try
|
|
{
|
|
return (IEnumerable)_executeSelectMethod.MakeGenericMethod(EntityClrType).Invoke(this, new object[] { arguments, createDelegate });
|
|
}
|
|
catch (TargetInvocationException e)
|
|
{
|
|
throw e.InnerException;
|
|
}
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
|
|
private IEnumerable ExecuteSelectTyped<T>(DataSourceSelectArguments arguments, EntityDataSourceQueryBuilder<T>.Creator qbConstructor)
|
|
{
|
|
string whereClause;
|
|
ObjectParameter[] whereParameters;
|
|
GenerateWhereClause(out whereClause, out whereParameters);
|
|
string entitySetQueryExpression = GenerateEntitySetQueryExpression();
|
|
|
|
var orderByBuilder = new OrderByBuilder(arguments.SortExpression, _collectionManager.FlattenedEntityCollection,
|
|
_owner.OrderBy, _owner.AutoGenerateOrderByClause, _owner.OrderByParameters,
|
|
CanPage, //There's no need to generate the default OrderBy clause if paging is disabled. Prevents an unnecessary sort at the server.
|
|
_owner);
|
|
|
|
EntityDataSourceQueryBuilder<T> queryBuilder =
|
|
qbConstructor(
|
|
arguments,
|
|
_owner.CommandText, _owner.GetCommandParameters(),
|
|
whereClause, whereParameters, entitySetQueryExpression,
|
|
_owner.Select, _owner.GroupBy, _owner.GetSelectParameters(),
|
|
orderByBuilder,
|
|
_owner.Include);
|
|
|
|
// We need to keep two copies, the unsorted and sorted because if the event does not
|
|
// modify the query we'll need to revert back to the unsorted one so we can re-apply the
|
|
// ESQL sort criteria as part of skip/take.
|
|
ObjectQuery<T> query = queryBuilder.BuildBasicQuery(Context, arguments.RetrieveTotalRowCount);
|
|
ObjectQuery<T> sortedQuery = queryBuilder.ApplyOrderBy(query);
|
|
|
|
var queryEventArgs = new QueryCreatedEventArgs(sortedQuery);
|
|
OnQueryCreated(queryEventArgs);
|
|
|
|
var queryReturned = queryEventArgs.Query;
|
|
bool wasQueryModified = (queryReturned != sortedQuery);
|
|
if (wasQueryModified)
|
|
{
|
|
// Check that we still have an object query
|
|
if (queryReturned as ObjectQuery == null)
|
|
{
|
|
throw new InvalidOperationException(Strings.EntityDataSourceView_QueryCreatedNotAnObjectQuery(queryReturned.GetType().FullName, typeof(T).Name));
|
|
}
|
|
|
|
// Check that new type is at least substitutable
|
|
var elementType = queryReturned.ElementType;
|
|
if (elementType != typeof(T))
|
|
{
|
|
if (!typeof(T).IsAssignableFrom(elementType))
|
|
{
|
|
throw new InvalidOperationException(Strings.EntityDataSourceView_QueryCreatedWrongType(elementType.Name, typeof(T).Name));
|
|
}
|
|
|
|
// Recreate the query builder for new type and then run it
|
|
var newQueryBuilderCreateMethod = typeof(EntityDataSourceObjectQueryBuilder<>).MakeGenericType(queryReturned.ElementType).GetMethod("Create", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic, null, queryBuilderCreatorArgTypes, null);
|
|
Debug.Assert(newQueryBuilderCreateMethod != null, "Unable to bind to EntityDataSourceObjectQueryBuilder<T>.Create (static, non-visible) method");
|
|
|
|
// If the query results were wrapped before, we need to reset the wrapper to use the new type
|
|
if (_collectionManager.Mode == WrapperCollectionManager.ManagerMode.FlattenedEntities)
|
|
{
|
|
Debug.Assert(_collectionManager.FlattenedEntityCollection != null);
|
|
|
|
MetadataWorkspace workspace = Context.MetadataWorkspace;
|
|
EntityType newOSpaceType = workspace.GetItem<EntityType>(elementType.FullName, DataSpace.OSpace);
|
|
EntityType newCSpaceType = (EntityType)workspace.GetEdmSpaceType((StructuralType)newOSpaceType);
|
|
|
|
_collectionManager.CreateCollection(Context, EntitySet, newCSpaceType, WrapperCollectionManager.ManagerMode.FlattenedEntities);
|
|
|
|
// Don't need to regenerate the where clause and parameters because they must be declaratively specified and if they reference
|
|
// properties that only exist in the subtype we would have already failed to generate the where clause previously and couldn't get this far
|
|
|
|
// Regeneate the OrderByBuilder so that we can apply the sort expression later based on the new wrapper properties
|
|
orderByBuilder = new OrderByBuilder(arguments.SortExpression, _collectionManager.FlattenedEntityCollection,
|
|
_owner.OrderBy, _owner.AutoGenerateOrderByClause, _owner.OrderByParameters,
|
|
CanPage, //There's no need to generate the default OrderBy clause if paging is disabled. Prevents an unnecessary sort at the server.
|
|
_owner);
|
|
}
|
|
|
|
object newQueryBuilder = newQueryBuilderCreateMethod.Invoke(null, new object[] {
|
|
arguments,
|
|
_owner.CommandText, _owner.GetCommandParameters(),
|
|
whereClause, whereParameters, entitySetQueryExpression,
|
|
_owner.Select, _owner.GroupBy, _owner.GetSelectParameters(),
|
|
orderByBuilder,
|
|
_owner.Include });
|
|
return (IEnumerable)_continueSelectMethod.MakeGenericMethod(elementType).Invoke(this, new object[] { arguments, newQueryBuilder, queryReturned, wasQueryModified });
|
|
}
|
|
|
|
// Type hasn't changed, we can dispatch as normal
|
|
query = queryReturned as ObjectQuery<T>;
|
|
}
|
|
|
|
return ContinueSelectTyped<T>(arguments, queryBuilder, query, wasQueryModified);
|
|
}
|
|
|
|
private IEnumerable ContinueSelectTyped<T>(DataSourceSelectArguments arguments, EntityDataSourceQueryBuilder<T> queryBuilder, ObjectQuery<T> queryT, bool wasQueryModified)
|
|
{
|
|
// Reset the MergeOption to AppendOnly
|
|
queryT.MergeOption = MergeOption.AppendOnly;
|
|
queryT = queryBuilder.CompleteBuild(queryT, Context, arguments.RetrieveTotalRowCount, wasQueryModified);
|
|
|
|
// SelectedEventArgs.TotalRowCount has three possible states:
|
|
// 1. The databound control requests it via arguments.RetrieveTotalRowCount
|
|
// This returns the total number of rows on all pages.
|
|
// arguments.TotalRowCount is only set if arguments.RetrieveTotalRowCount is true.
|
|
// 2. Paging is disabled via !CanPage.
|
|
// This returns the number of rows returned. On one page.
|
|
// 3. Else it returns negative one.
|
|
int totalRowCount = -1;
|
|
|
|
if (arguments.RetrieveTotalRowCount)
|
|
{
|
|
// The Selected event args gets the total number of rows on all pages.
|
|
totalRowCount = queryBuilder.TotalCount;
|
|
// The databound control requests totalRowCount. We return the total rows on all pages.
|
|
arguments.TotalRowCount = totalRowCount;
|
|
}
|
|
|
|
if (!_disableUpdates)
|
|
{
|
|
Debug.Assert(null != EntitySet, "Can't be updatable with a null EntitySet");
|
|
EntityDataSourceUtil.
|
|
CheckNonPolymorphicTypeUsage(EntitySet.ElementType,
|
|
Context.MetadataWorkspace.GetItemCollection(DataSpace.CSpace),
|
|
_owner.EntityTypeFilter);
|
|
}
|
|
|
|
IEnumerable entities = null;
|
|
try
|
|
{
|
|
entities = queryBuilder.Execute(queryT);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
entities = null;
|
|
var selectedArgs = new EntityDataSourceSelectedEventArgs(e);
|
|
OnSelected(selectedArgs);
|
|
OnException(new DynamicValidatorEventArgs(e, DynamicDataSourceOperation.Select));
|
|
if (!selectedArgs.ExceptionHandled)
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
// OnSelected outside "try" to prevent double-calling OnSelected if the first OnSelected throws
|
|
if (null != entities)
|
|
{
|
|
if (!CanPage)
|
|
{
|
|
// Paging is disabled, totalRowCount gets the number of rows returned from this query.
|
|
totalRowCount = ((IList)entities).Count;
|
|
}
|
|
OnSelected(new EntityDataSourceSelectedEventArgs(Context, entities, totalRowCount, arguments));
|
|
}
|
|
|
|
var checkEntitySet = wasQueryModified && !String.IsNullOrEmpty(_owner.EntitySetName) && (CanDelete || CanUpdate);
|
|
|
|
if (_collectionManager.Mode == WrapperCollectionManager.ManagerMode.None && !checkEntitySet)
|
|
{
|
|
Debug.Assert(
|
|
_collectionManager.FlattenedEntityCollection == null && _collectionManager.UpdateCache == null,
|
|
"ManagerMode is None so both collections should be null.");
|
|
|
|
return entities;
|
|
}
|
|
|
|
foreach (object element in entities)
|
|
{
|
|
var elementEntitySet = Context.ObjectStateManager.GetObjectStateEntry(element).EntitySet;
|
|
if (elementEntitySet != EntitySet)
|
|
{
|
|
throw new InvalidOperationException(Strings.EntityDataSourceView_EntitySetMismatchWithQueryResults(elementEntitySet, EntitySet));
|
|
}
|
|
if (_collectionManager.Mode != WrapperCollectionManager.ManagerMode.None)
|
|
{
|
|
_collectionManager.AddWrappedEntity(element);
|
|
}
|
|
}
|
|
|
|
// If EnableFlattening flag is true return flattened entities. Otherwise if we ended up here
|
|
// because we needed to cache values in the viewstate for further updates we return non-flattened entities.
|
|
// Same happens if neither of the above is true and we ended up here because we needed to verify that
|
|
// all entities are from the same entity set.
|
|
return _collectionManager.Mode == WrapperCollectionManager.ManagerMode.FlattenedEntities ?
|
|
_collectionManager.FlattenedEntityCollection :
|
|
entities;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restrict the query to the type specified by EntityTypeFilter.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private string GenerateEntitySetQueryExpression()
|
|
{
|
|
if (null == EntitySet)
|
|
{
|
|
return String.Empty;
|
|
}
|
|
|
|
string entitySetIdentifier = EntityDataSourceUtil.CreateEntitySqlSetIdentifier(EntitySet);
|
|
|
|
if (String.IsNullOrEmpty(_owner.EntityTypeFilter))
|
|
{
|
|
return entitySetIdentifier;
|
|
}
|
|
|
|
Debug.Assert(EntityOSpaceType != null, "EntitySet is not null, EntityOSpaceType should also be defined.");
|
|
|
|
// oftype ([Northwind].[Products], only [Northwind].[ActiveProducts])
|
|
StringBuilder queryExpressionBuilder = new StringBuilder();
|
|
queryExpressionBuilder.Append("oftype (");
|
|
queryExpressionBuilder.Append(entitySetIdentifier);
|
|
queryExpressionBuilder.Append(", only ");
|
|
queryExpressionBuilder.Append(EntityDataSourceUtil.CreateEntitySqlTypeIdentifier(EntityOSpaceType));
|
|
queryExpressionBuilder.Append(")");
|
|
|
|
return queryExpressionBuilder.ToString();
|
|
}
|
|
|
|
#endregion ExecuteSelect
|
|
|
|
#region ExecuteUpdate
|
|
|
|
protected override int ExecuteUpdate(IDictionary keys, IDictionary values, IDictionary oldValues)
|
|
{
|
|
if (!CanUpdate)
|
|
{
|
|
throw new InvalidOperationException(Strings.EntityDataSourceView_UpdateDisabledForThisControl);
|
|
}
|
|
|
|
ConstructContext();
|
|
EntityDataSourceChangingEventArgs changingArgs;
|
|
|
|
Dictionary<string, object> originalEntityValues = new Dictionary<string, object>();
|
|
EntityDataSourceWrapperCollection wrapperCollection =
|
|
new EntityDataSourceWrapperCollection(Context, EntitySet, CSpaceFilteredEntityType);
|
|
EntityDataSourceWrapper modifiedEntityWrapper;
|
|
try
|
|
{
|
|
object entity = EntityDataSourceUtil.InitializeType(this.EntityClrType);
|
|
Context.AddObject(_owner.FQEntitySetName, entity);
|
|
modifiedEntityWrapper = new EntityDataSourceWrapper(wrapperCollection, entity);
|
|
|
|
// Get the values in the following order
|
|
// 1. Key values from the page
|
|
// 2. Values from view state
|
|
// 3. Values from oldValues
|
|
ConvertProperties(keys, modifiedEntityWrapper.GetProperties(), /* ParameterCollection */null, originalEntityValues);
|
|
GetValuesFromViewState(originalEntityValues);
|
|
ConvertProperties(oldValues, modifiedEntityWrapper.GetProperties(), /* ParameterCollection */null, originalEntityValues);
|
|
|
|
// Validate that we have values for key properties
|
|
EntityDataSourceUtil.ValidateKeyPropertyValuesExist(modifiedEntityWrapper, originalEntityValues);
|
|
|
|
// Populate the entity with values
|
|
EntityDataSourceUtil.SetAllPropertiesWithVerification(modifiedEntityWrapper, originalEntityValues, /*overwrite*/true);
|
|
}
|
|
catch (EntityDataSourceValidationException e)
|
|
{
|
|
changingArgs = new EntityDataSourceChangingEventArgs(e);
|
|
OnUpdating(changingArgs);
|
|
OnException(new DynamicValidatorEventArgs(e, DynamicDataSourceOperation.Update));
|
|
if (!changingArgs.ExceptionHandled)
|
|
{
|
|
throw;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
//Modify the properties with the new values
|
|
try
|
|
{
|
|
Context.AcceptAllChanges(); //Puts modifiedEntityWrapper into unchanged state.
|
|
UpdateEntity(originalEntityValues, values, modifiedEntityWrapper, _owner.UpdateParameters);
|
|
}
|
|
catch (EntityDataSourceValidationException e)
|
|
{
|
|
changingArgs = new EntityDataSourceChangingEventArgs(e);
|
|
OnUpdating(changingArgs);
|
|
OnException(new DynamicValidatorEventArgs(e, DynamicDataSourceOperation.Update));
|
|
if (!changingArgs.ExceptionHandled)
|
|
{
|
|
throw;
|
|
}
|
|
return -1;
|
|
}
|
|
try
|
|
{
|
|
// Call DetectChanges to ensure the changes to the entity are reflected in the state manager
|
|
Context.DetectChanges();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
changingArgs = new EntityDataSourceChangingEventArgs(e);
|
|
OnUpdating(changingArgs);
|
|
OnException(new DynamicValidatorEventArgs(e, DynamicDataSourceOperation.Update));
|
|
if (!changingArgs.ExceptionHandled)
|
|
{
|
|
throw;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
try
|
|
{
|
|
// Call DetectChanges to ensure the changes to the entity are reflected in the state manager
|
|
Context.DetectChanges();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
changingArgs = new EntityDataSourceChangingEventArgs(e);
|
|
OnUpdating(changingArgs);
|
|
OnException(new DynamicValidatorEventArgs(e, DynamicDataSourceOperation.Update));
|
|
if (!changingArgs.ExceptionHandled)
|
|
{
|
|
throw;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
changingArgs = new EntityDataSourceChangingEventArgs(Context, modifiedEntityWrapper.WrappedEntity);
|
|
OnUpdating(changingArgs);
|
|
if (changingArgs.Cancel)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
try
|
|
{
|
|
Context.SaveChanges();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
// Catches SaveChanges exceptions.
|
|
EntityDataSourceChangedEventArgs changedArgs = new EntityDataSourceChangedEventArgs(e);
|
|
OnUpdated(changedArgs);
|
|
OnException(new DynamicValidatorEventArgs(e, DynamicDataSourceOperation.Update));
|
|
if (!changedArgs.ExceptionHandled)
|
|
{
|
|
throw;
|
|
}
|
|
return -1;
|
|
}
|
|
OnUpdated(new EntityDataSourceChangedEventArgs(Context, modifiedEntityWrapper.WrappedEntity));
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endregion ExecuteUpdate
|
|
|
|
#region ExecuteDelete
|
|
protected override int ExecuteDelete(IDictionary keys, IDictionary oldValues)
|
|
{
|
|
if (!CanDelete)
|
|
{
|
|
throw new InvalidOperationException(Strings.EntityDataSourceView_DeleteDisabledForThiscontrol);
|
|
}
|
|
|
|
ConstructContext();
|
|
|
|
EntityDataSourceWrapperCollection wrapperCollection = new EntityDataSourceWrapperCollection(Context, EntitySet, CSpaceFilteredEntityType);
|
|
EntityDataSourceWrapper entityWrapper;
|
|
object entity;
|
|
EntityDataSourceChangingEventArgs changingArgs;
|
|
try
|
|
{
|
|
entity = EntityDataSourceUtil.InitializeType(this.EntityClrType);
|
|
Context.AddObject(_owner.FQEntitySetName, entity); // Add/AcceptAllChanges because wrappers must contain attached entities
|
|
entityWrapper = new EntityDataSourceWrapper(wrapperCollection, entity);
|
|
|
|
// Get the values in the following order
|
|
// 1. Key values from the page
|
|
// 2. Values from view state
|
|
// 3. Values from oldValues
|
|
Dictionary<string, object> entityValues = new Dictionary<string, object>();
|
|
ConvertProperties(keys, entityWrapper.GetProperties(), _owner.DeleteParameters, entityValues);
|
|
GetValuesFromViewState(entityValues);
|
|
ConvertProperties(oldValues, entityWrapper.GetProperties(), _owner.DeleteParameters, entityValues);
|
|
|
|
// Validate that we have values for key properties
|
|
EntityDataSourceUtil.ValidateKeyPropertyValuesExist(entityWrapper, entityValues);
|
|
|
|
// Populate the entity with values
|
|
EntityDataSourceUtil.SetAllPropertiesWithVerification(entityWrapper, entityValues, /*overwrite*/true);
|
|
|
|
Context.AcceptAllChanges(); //Force the entity just added into unchanged state. Wrapped entities must be tracked.
|
|
}
|
|
catch (EntityDataSourceValidationException e)
|
|
{
|
|
changingArgs = new EntityDataSourceChangingEventArgs(e);
|
|
OnDeleting(changingArgs);
|
|
OnException(new DynamicValidatorEventArgs(e, DynamicDataSourceOperation.Delete));
|
|
if (!changingArgs.ExceptionHandled)
|
|
{
|
|
throw;
|
|
}
|
|
return -1;
|
|
}
|
|
changingArgs = new EntityDataSourceChangingEventArgs(Context, entityWrapper.WrappedEntity);
|
|
OnDeleting(changingArgs); //Outside "try" to prevent from begin called twice.
|
|
if (changingArgs.Cancel)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
try
|
|
{
|
|
Context.DeleteObject(entityWrapper.WrappedEntity);
|
|
Context.SaveChanges();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
// Catches errors on the context.
|
|
EntityDataSourceChangedEventArgs changedArgs = new EntityDataSourceChangedEventArgs(e);
|
|
OnDeleted(changedArgs);
|
|
OnException(new DynamicValidatorEventArgs(e, DynamicDataSourceOperation.Delete));
|
|
if (!changedArgs.ExceptionHandled)
|
|
{
|
|
throw;
|
|
}
|
|
return -1;
|
|
}
|
|
OnDeleted(new EntityDataSourceChangedEventArgs(Context, entity)); //Outside "try" to prevent being called twice.
|
|
return 1;
|
|
}
|
|
#endregion ExecuteDelete
|
|
|
|
#region ExecuteInsert
|
|
|
|
protected override int ExecuteInsert(IDictionary values)
|
|
{
|
|
if (!CanInsert)
|
|
{
|
|
throw new InvalidOperationException(Strings.EntityDataSourceView_InsertDisabledForThisControl);
|
|
}
|
|
|
|
ConstructContext();
|
|
|
|
EntityDataSourceChangingEventArgs changingArgs;
|
|
EntityDataSourceWrapperCollection wrapperCollection = new EntityDataSourceWrapperCollection(Context, EntitySet, CSpaceFilteredEntityType);
|
|
EntityDataSourceWrapper entityWrapper;
|
|
try
|
|
{
|
|
object entity = EntityDataSourceUtil.InitializeType(this.EntityClrType);
|
|
Context.AddObject(_owner.FQEntitySetName, entity);
|
|
entityWrapper = new EntityDataSourceWrapper(wrapperCollection, entity);
|
|
CreateEntityForInsert(entityWrapper, values, _owner.InsertParameters);
|
|
}
|
|
catch (EntityDataSourceValidationException e)
|
|
{
|
|
changingArgs = new EntityDataSourceChangingEventArgs(e);
|
|
OnInserting(changingArgs);
|
|
OnException(new DynamicValidatorEventArgs(e, DynamicDataSourceOperation.Insert));
|
|
if (!changingArgs.ExceptionHandled)
|
|
{
|
|
throw;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
changingArgs = new EntityDataSourceChangingEventArgs(Context, entityWrapper.WrappedEntity);
|
|
OnInserting(changingArgs); //Could return an entity to insert.
|
|
if (changingArgs.Cancel)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if (!Object.ReferenceEquals(entityWrapper.WrappedEntity, changingArgs.Entity))
|
|
{
|
|
Context.Detach(entityWrapper.WrappedEntity);
|
|
Context.AddObject(_owner.EntitySetName, changingArgs.Entity);
|
|
entityWrapper = new EntityDataSourceWrapper(wrapperCollection, changingArgs.Entity);
|
|
}
|
|
|
|
try
|
|
{
|
|
Context.SaveChanges();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
EntityDataSourceChangedEventArgs changedArgs = new EntityDataSourceChangedEventArgs(e);
|
|
OnInserted(changedArgs);
|
|
OnException(new DynamicValidatorEventArgs(e, DynamicDataSourceOperation.Insert));
|
|
if (!changedArgs.ExceptionHandled)
|
|
{
|
|
throw;
|
|
}
|
|
return -1;
|
|
}
|
|
OnInserted(new EntityDataSourceChangedEventArgs(Context, entityWrapper.WrappedEntity));
|
|
return 1;
|
|
}
|
|
|
|
#endregion ExecuteInsert
|
|
|
|
#region Public Methods
|
|
public DataTable GetViewSchema()
|
|
{
|
|
EntityDataSourceViewSchema propTable;
|
|
if (_owner.ValidateWrappable())
|
|
{
|
|
ConstructContext();
|
|
EntityDataSourceWrapperCollection wrappers = new EntityDataSourceWrapperCollection(Context, EntitySet, CSpaceFilteredEntityType);
|
|
propTable = new EntityDataSourceViewSchema(wrappers);
|
|
}
|
|
else
|
|
{
|
|
string where = _owner.Where;
|
|
_owner.Where = "0=1";
|
|
try
|
|
{
|
|
DataSourceSelectArguments args = new DataSourceSelectArguments();
|
|
args.RetrieveTotalRowCount = false;
|
|
IEnumerable results = ExecuteSelect(args);
|
|
ITypedList typedList = results as ITypedList;
|
|
if (null != typedList)
|
|
{
|
|
propTable = new EntityDataSourceViewSchema(typedList);
|
|
}
|
|
else if (_owner.HasIdentity())
|
|
{
|
|
// If the results have an identity/primary keys, gather them from restricted type or the element type from the set the control is querying
|
|
// Make sure to use keys from the ObjectSpace type in case there were name mappings
|
|
EntityType entityType = Context.MetadataWorkspace.GetObjectSpaceType(CSpaceFilteredEntityType ?? EntitySet.ElementType) as EntityType;
|
|
propTable = new EntityDataSourceViewSchema(results, entityType.KeyMembers.Select(x => x.Name).ToArray());
|
|
}
|
|
else
|
|
{
|
|
propTable = new EntityDataSourceViewSchema(results);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
_owner.Where = where;
|
|
}
|
|
}
|
|
return propTable;
|
|
}
|
|
#endregion Public Methods
|
|
|
|
#region Private Methods
|
|
|
|
#region ExecuteSelect Support
|
|
|
|
private void GenerateWhereClause(out string whereClause, out ObjectParameter[] whereParameters)
|
|
{
|
|
if (!_owner.AutoGenerateWhereClause)
|
|
{
|
|
whereClause = _owner.Where;
|
|
whereParameters = _owner.GetWhereParameters();
|
|
return;
|
|
}
|
|
|
|
//This is the automatically generated Where clause.
|
|
IOrderedDictionary paramValues = _owner.WhereParameters.GetValues(_owner.HttpContext, _owner);
|
|
// Under some conditions, the paramValues has a null entry.
|
|
StringBuilder whereClauseBuilder = new StringBuilder();
|
|
List<ObjectParameter> whereParameterList = new List<ObjectParameter>();
|
|
bool first = true;
|
|
|
|
int idx = 0;
|
|
foreach (DictionaryEntry de in paramValues)
|
|
{
|
|
string propertyName = (string)(de.Key);
|
|
if (0 < propertyName.Length && null != de.Value)
|
|
{
|
|
if (!String.IsNullOrEmpty(_owner.EntitySetName) && !EntityDataSourceUtil.PropertyIsOnEntity(propertyName, _collectionManager.FlattenedEntityCollection, EntitySet, null))
|
|
{
|
|
throw new InvalidOperationException(Strings.EntityDataSourceView_PropertyDoesNotExistOnEntity(propertyName, EntityClrType.FullName));
|
|
}
|
|
|
|
if (first)
|
|
{
|
|
first = false;
|
|
}
|
|
else
|
|
{
|
|
whereClauseBuilder.Append(" AND ");
|
|
}
|
|
|
|
string namedParameterName = "NamedParameter" + idx.ToString(CultureInfo.InvariantCulture);
|
|
|
|
whereClauseBuilder.Append(EntityDataSourceUtil.GetEntitySqlValueForColumnName(propertyName, _collectionManager.FlattenedEntityCollection));
|
|
whereClauseBuilder.Append("=@");
|
|
whereClauseBuilder.Append(namedParameterName);
|
|
|
|
whereParameterList.Add(new ObjectParameter(namedParameterName, de.Value));
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
whereParameters = whereParameterList.ToArray();
|
|
whereClause = whereClauseBuilder.ToString();
|
|
}
|
|
|
|
#endregion ExecuteSelect Support
|
|
|
|
#region Entity Creation Support for Update/Insert/Delete
|
|
|
|
private object ConvertProperty(object origPropertyValue, PropertyDescriptor propertyDescriptor, WebControlParameterProxy referenceParameter)
|
|
{
|
|
if (null == propertyDescriptor)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
object propValue = origPropertyValue;
|
|
propValue = Parameter_GetValue(propValue, referenceParameter, true);
|
|
propValue = EntityDataSourceUtil.ConvertType(propValue, propertyDescriptor.PropertyType, propertyDescriptor.Name);
|
|
return propValue;
|
|
}
|
|
|
|
private void ConvertWCProperty(IDictionary values,
|
|
Dictionary<string, object> convertedValues,
|
|
List<string> visitedProperties,
|
|
PropertyDescriptor pd,
|
|
ParameterCollection referenceParameters,
|
|
ref Dictionary<string, Exception> exceptions)
|
|
{
|
|
Debug.Assert(pd != null, "PropertyDescriptor is null");
|
|
string propertyName = pd.Name;
|
|
WebControlParameterProxy wcParameter = new WebControlParameterProxy(propertyName, referenceParameters, _owner);
|
|
object propValue = null;
|
|
object value = null;
|
|
if (null != values)
|
|
{
|
|
value = values[propertyName];
|
|
}
|
|
try
|
|
{
|
|
propValue = ConvertProperty(value, pd, wcParameter);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (null == exceptions)
|
|
{
|
|
exceptions = new Dictionary<string, Exception>();
|
|
}
|
|
exceptions.Add(propertyName, e);
|
|
}
|
|
convertedValues[propertyName] = propValue;
|
|
visitedProperties.Add(propertyName);
|
|
}
|
|
private void ConvertProperties(IDictionary values, PropertyDescriptorCollection propertyDescriptors, ParameterCollection referenceParameters, Dictionary<string, object> convertedValues)
|
|
{
|
|
List<string> visitedProperties = new List<string>();
|
|
Dictionary<string, Exception> exceptions = null;
|
|
|
|
// "values" come from the web page. Either via keys or original values. This loops sets them as first priority
|
|
foreach (string propertyName in values.Keys)
|
|
{
|
|
if (!convertedValues.ContainsKey(propertyName))
|
|
{
|
|
PropertyDescriptor pd = propertyDescriptors.Find(propertyName, /*ignoreCase*/ false);
|
|
if (pd == null)
|
|
{
|
|
throw new InvalidOperationException(Strings.EntityDataSourceView_UnknownProperty(propertyName));
|
|
}
|
|
ConvertWCProperty(values, convertedValues, visitedProperties,
|
|
pd, referenceParameters, ref exceptions);
|
|
}
|
|
// else ignore the value because it is already contained in the set of output values
|
|
}
|
|
|
|
// If a property hasn't been set by visible columns or DataKeyNames, then we set them here.
|
|
// "referenceParameters" are Insert, Update or DeleteParameters assigning default values to
|
|
// columns that are not set by the control
|
|
if (null != referenceParameters)
|
|
{
|
|
IOrderedDictionary referenceValues = referenceParameters.GetValues(_owner.HttpContext, _owner);
|
|
foreach (string propertyName in referenceValues.Keys)
|
|
{
|
|
if (!visitedProperties.Contains(propertyName))
|
|
{
|
|
PropertyDescriptor pd = propertyDescriptors.Find(propertyName, /*ignoreCase*/ false);
|
|
if (pd == null)
|
|
{
|
|
throw new InvalidOperationException(Strings.EntityDataSourceView_UnknownProperty(propertyName));
|
|
}
|
|
ConvertWCProperty(null, convertedValues, visitedProperties,
|
|
pd, referenceParameters, ref exceptions);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (null != exceptions)
|
|
{
|
|
// The IDynamicValidationException encapsulates all of the data conversion errors.
|
|
// This exposes one of the encapsulated errors in its own message like:
|
|
// "Error while setting property 'ProductName': 'The value cannot be null.'."
|
|
string key = exceptions.Keys.First();
|
|
throw new EntityDataSourceValidationException(
|
|
Strings.EntityDataSourceView_DataConversionError(
|
|
key, exceptions[key].Message), exceptions);
|
|
}
|
|
}
|
|
|
|
private void CreateEntityForInsert(EntityDataSourceWrapper entityWrapper, IDictionary values, ParameterCollection insertParameters)
|
|
{
|
|
EntityDataSourceUtil.ValidateWebControlParameterNames(entityWrapper, insertParameters, _owner);
|
|
|
|
// Throws EntityDataSourceValidationException if data conversion fails
|
|
Dictionary<string, object> entityValues = new Dictionary<string, object>();
|
|
ConvertProperties(values, entityWrapper.GetProperties(), insertParameters, entityValues);
|
|
|
|
EntityDataSourceUtil.SetAllPropertiesWithVerification(entityWrapper, entityValues, /*overwrite*/true);
|
|
}
|
|
|
|
private void UpdateEntity(Dictionary<string, object> originalEntityValues, IDictionary values,
|
|
EntityDataSourceWrapper entityWrapper, ParameterCollection updateParameters)
|
|
{
|
|
EntityDataSourceUtil.ValidateWebControlParameterNames(entityWrapper, updateParameters, _owner);
|
|
Dictionary<string, object> currentEntityValues = new Dictionary<string, object>();
|
|
ConvertProperties(values, entityWrapper.GetProperties(), updateParameters, currentEntityValues);
|
|
Dictionary<string, object> allModifiedProperties = new Dictionary<string, object>();
|
|
|
|
// Compare the propertyValues from the original values from the page to those in the new "values" properties.
|
|
// Note that the comparison is between the values that came back from the databound control, BUT
|
|
// The values on the entity in the entityWrapper came from ViewState. We can't compare the values from the page
|
|
// To those stored in ViewState in case they didn't roundtrip well. Hence this next loop.
|
|
foreach (string propertyName in currentEntityValues.Keys)
|
|
{
|
|
object originalValue = null;
|
|
originalEntityValues.TryGetValue(propertyName, out originalValue);
|
|
object newValue = currentEntityValues[propertyName];
|
|
|
|
if (!OriginalValueMatches(originalValue, newValue))
|
|
{
|
|
allModifiedProperties[propertyName] = newValue;
|
|
}
|
|
}
|
|
|
|
EntityDataSourceUtil.SetAllPropertiesWithVerification(entityWrapper, allModifiedProperties, /*overwrite*/false);
|
|
}
|
|
|
|
#endregion Entity Creation Support
|
|
|
|
#region ViewState Storage
|
|
|
|
internal void StoreOriginalPropertiesIntoViewState()
|
|
{
|
|
EntityDataSourceWrapperCollection wrapperCollection = _collectionManager.FlattenedEntityCollection ?? _collectionManager.UpdateCache;
|
|
|
|
if (null == wrapperCollection ||
|
|
0 == wrapperCollection.Count ||
|
|
!_owner.StoreOriginalValuesInViewState ||
|
|
(!CanDelete && !CanUpdate)) //Only store entities into viewstate if Delete or Update is enabled.
|
|
{
|
|
return;
|
|
}
|
|
|
|
_originalProperties = new Dictionary<string, ArrayList>();
|
|
|
|
PropertyDescriptorCollection collection = wrapperCollection.GetItemProperties(null);
|
|
|
|
// Retrieve the named properties from each entity and place them into the viewstate collection.
|
|
foreach (EntityDataSourceWrapper wrapper in wrapperCollection)
|
|
{
|
|
foreach (PropertyDescriptor propertyDescriptor in collection)
|
|
{
|
|
EntityDataSourceWrapperPropertyDescriptor wrapperPropertyDescriptor = (EntityDataSourceWrapperPropertyDescriptor)propertyDescriptor;
|
|
|
|
if (wrapperPropertyDescriptor.Column.IsInteresting && wrapperPropertyDescriptor.Column.IsScalar)
|
|
{
|
|
object property = wrapperPropertyDescriptor.GetValue(wrapper);
|
|
string propertyName = wrapperPropertyDescriptor.DisplayName;
|
|
|
|
if (!_originalProperties.ContainsKey(propertyName))
|
|
{
|
|
_originalProperties[propertyName] = new ArrayList();
|
|
}
|
|
|
|
(_originalProperties[propertyName]).Add(property);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void GetValuesFromViewState(Dictionary<string, object> entityValues)
|
|
{
|
|
int idx = FindIdxOfPropertiesStoredInViewState(entityValues);
|
|
|
|
if (0 <= idx) // "-1" indicates that the value was not found in ViewState
|
|
{
|
|
foreach (string propertyName in _originalProperties.Keys)
|
|
{
|
|
object property = (_originalProperties[propertyName])[idx];
|
|
entityValues[propertyName] = property;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the index of the entity in ViewState that has key values that match the values from the page.
|
|
/// If a match is not found, it returns -1.
|
|
/// </summary>
|
|
/// <param name="mergedKeysAndOldValues"></param>
|
|
/// <returns></returns>
|
|
private int FindIdxOfPropertiesStoredInViewState(IDictionary mergedKeysAndOldValues)
|
|
{
|
|
if (null == _originalProperties || 0 == _originalProperties.Count)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
Dictionary<string, object> localMergedKeysAndOldValues = (Dictionary<string, object>)mergedKeysAndOldValues;
|
|
|
|
// This get the number of entities from the first property's values.
|
|
// The ArrayList that holds the values contains the count of the number of entities.
|
|
int numEntities = (_originalProperties.First().Value).Count;
|
|
for (int idx = 0; idx < numEntities; idx++)
|
|
{
|
|
bool match = true;
|
|
foreach (EdmMember edmMember in KeyMembers)
|
|
{
|
|
string propertyName = edmMember.Name;
|
|
// The page must return the key values.
|
|
if (!localMergedKeysAndOldValues.ContainsKey(propertyName))
|
|
{
|
|
match = false;
|
|
break;
|
|
}
|
|
|
|
object origValue = (_originalProperties[propertyName])[idx];
|
|
object pageValue = localMergedKeysAndOldValues[propertyName];
|
|
if (!OriginalValueMatches(origValue, pageValue))
|
|
{
|
|
match = false;
|
|
break;
|
|
}
|
|
}
|
|
if (match)
|
|
{
|
|
return idx;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
private bool OriginalValueMatches(object originalValue, object value)
|
|
{
|
|
if (null == originalValue)
|
|
{
|
|
if (null == value)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// NOTE: Comparing IEnumerable contents instead of instances to ensure that
|
|
// timestamp columns (of type byte[]) can be matched appropriately.
|
|
IEnumerable originalValueEnumerable = originalValue as IEnumerable;
|
|
IEnumerable valueEnumerable = value as IEnumerable;
|
|
if ((originalValueEnumerable != null) && (valueEnumerable != null))
|
|
{
|
|
return EnumerableContentEquals(originalValueEnumerable, valueEnumerable);
|
|
}
|
|
|
|
return originalValue.Equals(value);
|
|
}
|
|
|
|
#endregion ViewState Storage
|
|
|
|
#region Context and Query construction
|
|
|
|
private void ConstructContext()
|
|
{
|
|
this.DisposeContext();
|
|
|
|
Type contextType = null;
|
|
EntityDataSourceContextCreatingEventArgs creatingArgs = new EntityDataSourceContextCreatingEventArgs();
|
|
OnContextCreating(creatingArgs);
|
|
if (null != creatingArgs.Context) //Context was created in event code
|
|
{
|
|
_ctx = creatingArgs.Context;
|
|
contextType = _ctx.GetType();
|
|
}
|
|
else if (null != _owner.ContextType || !String.IsNullOrEmpty(_owner.ContextTypeName))
|
|
{
|
|
//Construct the context.
|
|
if (null != _owner.ContextType)
|
|
{
|
|
contextType = _owner.ContextType;
|
|
}
|
|
else
|
|
{
|
|
contextType = System.Web.Compilation.BuildManager.GetType(_owner.ContextTypeName, /*throw on error*/ true);
|
|
}
|
|
|
|
ConstructorInfo ctxInfo = contextType.GetConstructor(
|
|
BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.CreateInstance,
|
|
null, System.Type.EmptyTypes, null);
|
|
|
|
if (null == ctxInfo)
|
|
{
|
|
throw new InvalidOperationException(Strings.EntityDataSourceView_NoParameterlessConstructorForTheContext);
|
|
}
|
|
|
|
_ctx = (ObjectContext)ctxInfo.Invoke(new object[0]);
|
|
}
|
|
else // Non-strongly-typed context built from ConnectionString and DefaultContainerName
|
|
{
|
|
if (!String.IsNullOrEmpty(_owner.DefaultContainerName) &&
|
|
!String.IsNullOrEmpty(_owner.ConnectionString))
|
|
{
|
|
_ctx = new ObjectContext(_owner.ConnectionString);
|
|
|
|
if (System.Web.Hosting.HostingEnvironment.IsHosted)
|
|
{
|
|
// Since we don't have the type from the strongly-typed context,
|
|
// load from all of the referenced assemblies, including code from App_Code and the top-level directory:
|
|
// http://msdn2.microsoft.com/en-us/library/system.web.compilation.buildmanager.getreferencedassemblies.aspx
|
|
ICollection codeAssemblies = System.Web.Compilation.BuildManager.GetReferencedAssemblies();
|
|
foreach (Assembly assembly in codeAssemblies)
|
|
{
|
|
if (ShouldTryLoadTypesFrom(assembly))
|
|
{
|
|
try
|
|
{
|
|
_ctx.MetadataWorkspace.LoadFromAssembly(assembly);
|
|
}
|
|
catch (ReflectionTypeLoadException)
|
|
{
|
|
// BuildManager returns all assemblies that could possibly be involved in generating this page (e.g.
|
|
// assemblies that are defined in config files, assemblies generated for the files compiled on the fly,
|
|
// assemblies that are in the bin folder. If for some reason (security, missing dependencies etc.) we are
|
|
// not able to load one of these just skip it and continue looking instead of dying. In vast majority of
|
|
// cases the assembly causing problem is not the assembly that contains the types we are interested in.
|
|
// If this exception happens for an assembly we are interested in then we will be missing OSpace type for
|
|
// a CSpace type and will throw when we will try using the type for the first time.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (!String.IsNullOrEmpty(_owner.DefaultContainerName) &&
|
|
null != _owner.Connection)
|
|
{
|
|
_ctx = new ObjectContext(_owner.Connection);
|
|
}
|
|
else
|
|
{
|
|
throw new InvalidOperationException(Strings.EntityDataSourceView_ObjectContextMustBeSpecified);
|
|
}
|
|
// Must set the DefaultContainerName for both of the above conditions.
|
|
_ctx.DefaultContainerName = _owner.DefaultContainerName;
|
|
contextType = typeof(ObjectContext);
|
|
}
|
|
|
|
_ctx.MetadataWorkspace.LoadFromAssembly(System.Reflection.Assembly.GetCallingAssembly());
|
|
_ctx.MetadataWorkspace.LoadFromAssembly(contextType.Assembly);
|
|
|
|
|
|
// Error Checking on the Context
|
|
ValidateContainerName();
|
|
|
|
OnContextCreated(new EntityDataSourceContextCreatedEventArgs(Context));
|
|
}
|
|
|
|
// QueryCreated Event
|
|
private void OnQueryCreated(QueryCreatedEventArgs e)
|
|
{
|
|
var handler = (EventHandler<QueryCreatedEventArgs>)Events[EventQueryCreated];
|
|
if (null != handler)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
[CLSCompliant(false)]
|
|
public event EventHandler<QueryCreatedEventArgs> QueryCreated
|
|
{
|
|
add { Events.AddHandler(EventQueryCreated, value); }
|
|
remove { Events.RemoveHandler(EventQueryCreated, value); }
|
|
}
|
|
|
|
internal void DisposeContext()
|
|
{
|
|
if (null != _ctx)
|
|
{
|
|
EntityDataSourceContextDisposingEventArgs disposeArgs = new EntityDataSourceContextDisposingEventArgs(_ctx);
|
|
OnContextDisposing(disposeArgs);
|
|
if (!disposeArgs.Cancel)
|
|
{
|
|
_ctx.Dispose();
|
|
_ctx = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Context and Query construction
|
|
#endregion Private Methods
|
|
|
|
#region Public Overrides
|
|
public override bool CanInsert
|
|
{
|
|
get { return _owner.EnableInsert && !_disableUpdates; }
|
|
}
|
|
public override bool CanUpdate
|
|
{
|
|
get { return _owner.EnableUpdate && !_disableUpdates; }
|
|
}
|
|
public override bool CanDelete
|
|
{
|
|
get { return _owner.EnableDelete && !_disableUpdates; }
|
|
}
|
|
public override bool CanSort
|
|
{
|
|
get { return _owner.AutoSort; }
|
|
}
|
|
public override bool CanPage
|
|
{
|
|
get { return _owner.AutoPage; }
|
|
}
|
|
public override bool CanRetrieveTotalRowCount
|
|
{
|
|
get { return _owner.AutoPage; }
|
|
}
|
|
#endregion Public Overrides
|
|
|
|
#region Events
|
|
|
|
//Oryx exception event
|
|
private void OnException(DynamicValidatorEventArgs args)
|
|
{
|
|
var handler = (EventHandler<DynamicValidatorEventArgs>)Events[EventException];
|
|
if (null != handler)
|
|
{
|
|
handler(this, args);
|
|
}
|
|
}
|
|
public event EventHandler<DynamicValidatorEventArgs> Exception
|
|
{
|
|
add { Events.AddHandler(EventException, value); }
|
|
remove { Events.RemoveHandler(EventException, value); }
|
|
}
|
|
|
|
// ContextCreating Event
|
|
private void OnContextCreating(EntityDataSourceContextCreatingEventArgs e)
|
|
{
|
|
var handler = (EventHandler<EntityDataSourceContextCreatingEventArgs>)Events[EventContextCreating];
|
|
if (null != handler)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
public event EventHandler<EntityDataSourceContextCreatingEventArgs> ContextCreating
|
|
{
|
|
add { Events.AddHandler(EventContextCreating, value); }
|
|
remove { Events.RemoveHandler(EventContextCreating, value); }
|
|
}
|
|
|
|
// ContextCreated Event
|
|
private void OnContextCreated(EntityDataSourceContextCreatedEventArgs e)
|
|
{
|
|
var handler = (EventHandler<EntityDataSourceContextCreatedEventArgs>)Events[EventContextCreated];
|
|
if (null != handler)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
public event EventHandler<EntityDataSourceContextCreatedEventArgs> ContextCreated
|
|
{
|
|
add { Events.AddHandler(EventContextCreated, value); }
|
|
remove { Events.RemoveHandler(EventContextCreated, value); }
|
|
}
|
|
|
|
// ContextDisposing Event
|
|
private void OnContextDisposing(EntityDataSourceContextDisposingEventArgs e)
|
|
{
|
|
var handler = (EventHandler<EntityDataSourceContextDisposingEventArgs>)Events[EventContextDisposing];
|
|
if (null != handler)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
public event EventHandler<EntityDataSourceContextDisposingEventArgs> ContextDisposing
|
|
{
|
|
add { Events.AddHandler(EventContextDisposing, value); }
|
|
remove { Events.RemoveHandler(EventContextDisposing, value); }
|
|
}
|
|
|
|
// Selecting Event
|
|
private void OnSelecting(EntityDataSourceSelectingEventArgs e)
|
|
{
|
|
var handler = (EventHandler<EntityDataSourceSelectingEventArgs>)Events[EventSelecting];
|
|
if (null != handler)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
public event EventHandler<EntityDataSourceSelectingEventArgs> Selecting
|
|
{
|
|
add { Events.AddHandler(EventSelecting, value); }
|
|
remove { Events.RemoveHandler(EventSelecting, value); }
|
|
}
|
|
|
|
// Selected Event
|
|
private void OnSelected(EntityDataSourceSelectedEventArgs e)
|
|
{
|
|
var handler = (EventHandler<EntityDataSourceSelectedEventArgs>)Events[EventSelected];
|
|
if (null != handler)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
public event EventHandler<EntityDataSourceSelectedEventArgs> Selected
|
|
{
|
|
add { Events.AddHandler(EventSelected, value); }
|
|
remove { Events.RemoveHandler(EventSelected, value); }
|
|
}
|
|
|
|
// Deleting Event
|
|
private void OnDeleting(EntityDataSourceChangingEventArgs e)
|
|
{
|
|
var handler = (EventHandler<EntityDataSourceChangingEventArgs>)Events[EventDeleting];
|
|
if (null != handler)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
public event EventHandler<EntityDataSourceChangingEventArgs> Deleting
|
|
{
|
|
add { Events.AddHandler(EventDeleting, value); }
|
|
remove { Events.RemoveHandler(EventDeleting, value); }
|
|
}
|
|
|
|
// Deleted Event
|
|
private void OnDeleted(EntityDataSourceChangedEventArgs e)
|
|
{
|
|
var handler = (EventHandler<EntityDataSourceChangedEventArgs>)Events[EventDeleted];
|
|
if (null != handler)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
public event EventHandler<EntityDataSourceChangedEventArgs> Deleted
|
|
{
|
|
add { Events.AddHandler(EventDeleted, value); }
|
|
remove { Events.RemoveHandler(EventDeleted, value); }
|
|
}
|
|
|
|
//Inserting Event
|
|
private void OnInserting(EntityDataSourceChangingEventArgs e)
|
|
{
|
|
var handler = (EventHandler<EntityDataSourceChangingEventArgs>)Events[EventInserting];
|
|
if (handler != null)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
public event EventHandler<EntityDataSourceChangingEventArgs> Inserting
|
|
{
|
|
add { Events.AddHandler(EventInserting, value); }
|
|
remove { Events.RemoveHandler(EventInserting, value); }
|
|
}
|
|
|
|
//Inserted Event
|
|
private void OnInserted(EntityDataSourceChangedEventArgs e)
|
|
{
|
|
var handler = (EventHandler<EntityDataSourceChangedEventArgs>)Events[EventInserted];
|
|
if (handler != null)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
public event EventHandler<EntityDataSourceChangedEventArgs> Inserted
|
|
{
|
|
add { Events.AddHandler(EventInserted, value); }
|
|
remove { Events.RemoveHandler(EventInserted, value); }
|
|
}
|
|
|
|
//Updating Event
|
|
private void OnUpdating(EntityDataSourceChangingEventArgs e)
|
|
{
|
|
var handler = (EventHandler<EntityDataSourceChangingEventArgs>)Events[EventUpdating];
|
|
if (handler != null)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
public event EventHandler<EntityDataSourceChangingEventArgs> Updating
|
|
{
|
|
add { Events.AddHandler(EventUpdating, value); }
|
|
remove { Events.RemoveHandler(EventUpdating, value); }
|
|
}
|
|
|
|
//Updated Event
|
|
private void OnUpdated(EntityDataSourceChangedEventArgs e)
|
|
{
|
|
var handler = (EventHandler<EntityDataSourceChangedEventArgs>)Events[EventUpdated];
|
|
if (handler != null)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
public event EventHandler<EntityDataSourceChangedEventArgs> Updated
|
|
{
|
|
add { Events.AddHandler(EventUpdated, value); }
|
|
remove { Events.RemoveHandler(EventUpdated, value); }
|
|
}
|
|
|
|
|
|
internal void RaiseChangedEvent()
|
|
{
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
|
|
#endregion Events
|
|
|
|
#region Private Properties
|
|
|
|
private StructuralType EntityOSpaceType
|
|
{
|
|
get
|
|
{
|
|
// If the CSpaceType is not determinable (e.g. DataSource.EntitySetName is not specified),
|
|
// then return null.
|
|
if (null == EntityCSpaceType)
|
|
{
|
|
return null;
|
|
}
|
|
StructuralType oSpaceType = Context.MetadataWorkspace.GetObjectSpaceType(EntityCSpaceType);
|
|
return oSpaceType;
|
|
}
|
|
}
|
|
|
|
// Returns the type for EntityTypeFilter, or
|
|
// null if both EntitySet and EntityTypeFilter are not specified.
|
|
private EntityType CSpaceFilteredEntityType
|
|
{
|
|
get
|
|
{
|
|
EntityType cSpaceType = null;
|
|
if (null == EntitySet)
|
|
{
|
|
return null; //read-only scenario in which the EntitySet is not specified on the DataSource
|
|
}
|
|
|
|
// Return the type specified in EntityTypeFilter
|
|
if (!String.IsNullOrEmpty(_owner.EntityTypeFilter))
|
|
{
|
|
cSpaceType = (EntityType)Context.MetadataWorkspace.GetType(_owner.EntityTypeFilter, EntitySet.ElementType.NamespaceName, DataSpace.CSpace);
|
|
if (!EntityDataSourceUtil.IsTypeOrSubtypeOf(EntitySet.ElementType, cSpaceType, Context.MetadataWorkspace.GetItemCollection(DataSpace.CSpace)))
|
|
{
|
|
throw new InvalidOperationException(Strings.EntityDataSourceView_FilteredEntityTypeMustBeDerivableFromEntitySet(_owner.EntityTypeFilter, _owner.EntitySetName));
|
|
}
|
|
return cSpaceType;
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
}
|
|
|
|
// Returns the actualy EntityCSpaceType to be returned from the query, either via
|
|
// EntityTypeFilter or via the base type for the EntitySet.
|
|
private EntityType EntityCSpaceType
|
|
{
|
|
get
|
|
{
|
|
EntityType cSpaceType = CSpaceFilteredEntityType;
|
|
if (null != cSpaceType)
|
|
{
|
|
return cSpaceType;
|
|
}
|
|
|
|
if (null != EntitySet)
|
|
{
|
|
//If EntityDataSource.EntityTypeFilter is not specified, return the base type for the EntitySet.
|
|
cSpaceType = EntitySet.ElementType;
|
|
}
|
|
return cSpaceType;
|
|
}
|
|
|
|
}
|
|
|
|
private EntityContainer EntityContainer
|
|
{
|
|
get
|
|
{
|
|
return Context.MetadataWorkspace.GetEntityContainer(ContainerName, DataSpace.CSpace);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The EntitySet Associated with this DataSource. If EntityDataSource.EntitySetName is not set, then
|
|
/// This property returns null.
|
|
/// </summary>
|
|
private EntitySet EntitySet
|
|
{
|
|
get
|
|
{
|
|
if (String.IsNullOrEmpty(_owner.EntitySetName))
|
|
{
|
|
return null;
|
|
}
|
|
return EntityContainer.GetEntitySetByName(_owner.EntitySetName, /*ignoreCase*/ false);
|
|
}
|
|
}
|
|
|
|
private Type EntityClrType
|
|
{
|
|
get
|
|
{
|
|
ObjectItemCollection objectItemCollection =
|
|
(ObjectItemCollection)(Context.MetadataWorkspace.GetItemCollection(DataSpace.OSpace));
|
|
Type clrType = objectItemCollection.GetClrType(EntityOSpaceType);
|
|
return clrType;
|
|
}
|
|
}
|
|
|
|
private ObjectContext Context
|
|
{
|
|
get
|
|
{
|
|
Debug.Assert(null != _ctx, "The context hasn't yet been constructed");
|
|
return _ctx;
|
|
}
|
|
}
|
|
|
|
private ReadOnlyMetadataCollection<EdmMember> KeyMembers
|
|
{
|
|
get
|
|
{
|
|
if (null == _keyMembers)
|
|
{
|
|
EntityContainer entityContainer = Context.MetadataWorkspace.GetEntityContainer(ContainerName, DataSpace.CSpace);
|
|
EntitySet entitySet = entityContainer.GetEntitySetByName(_owner.EntitySetName, false);
|
|
|
|
_keyMembers = ((EntityType)(entitySet.ElementType)).KeyMembers;
|
|
}
|
|
return _keyMembers;
|
|
}
|
|
}
|
|
|
|
private string ContainerName
|
|
{
|
|
get
|
|
{
|
|
if (!string.IsNullOrEmpty(_owner.DefaultContainerName))
|
|
{
|
|
return _owner.DefaultContainerName;
|
|
}
|
|
if (!string.IsNullOrEmpty(Context.DefaultContainerName))
|
|
{
|
|
return Context.DefaultContainerName;
|
|
}
|
|
throw new InvalidOperationException(Strings.EntityDataSourceView_ContainerNameMustBeSpecified);
|
|
}
|
|
}
|
|
|
|
#endregion Private Properties
|
|
|
|
#region private getters
|
|
|
|
#endregion private getters
|
|
|
|
#region IStateManager implementation
|
|
bool IStateManager.IsTrackingViewState
|
|
{
|
|
get { return _tracking; }
|
|
}
|
|
void IStateManager.LoadViewState(object savedState)
|
|
{
|
|
if (null != savedState)
|
|
{
|
|
var state = (Pair)savedState;
|
|
_disableUpdates = (bool)state.First;
|
|
_originalProperties = (Dictionary<string, ArrayList>)state.Second;
|
|
}
|
|
}
|
|
|
|
object IStateManager.SaveViewState()
|
|
{
|
|
StoreOriginalPropertiesIntoViewState();
|
|
return new Pair(_disableUpdates, _originalProperties);
|
|
}
|
|
void IStateManager.TrackViewState()
|
|
{
|
|
_tracking = true;
|
|
}
|
|
#endregion
|
|
|
|
#region Utilities and Error Checking
|
|
|
|
private void AddSupportedCapabilities(DataSourceSelectArguments arguments)
|
|
{
|
|
if (CanSort)
|
|
{
|
|
arguments.AddSupportedCapabilities(DataSourceCapabilities.Sort);
|
|
}
|
|
if (CanPage)
|
|
{
|
|
arguments.AddSupportedCapabilities(DataSourceCapabilities.Page);
|
|
arguments.AddSupportedCapabilities(DataSourceCapabilities.RetrieveTotalRowCount);
|
|
}
|
|
}
|
|
|
|
internal void ValidateEntitySetName()
|
|
{
|
|
EntityContainer entityContainer = Context.MetadataWorkspace.GetEntityContainer(ContainerName, DataSpace.CSpace);
|
|
EntitySet entitySet;
|
|
if (!entityContainer.TryGetEntitySetByName(_owner.EntitySetName, /*ignoreCase*/false, out entitySet))
|
|
{
|
|
throw new InvalidOperationException(Strings.EntityDataSourceView_EntitySetDoesNotExistOnTheContainer(_owner.EntitySetName));
|
|
}
|
|
}
|
|
|
|
private void ValidateContainerName()
|
|
{
|
|
EntityContainer container;
|
|
if (!Context.MetadataWorkspace.TryGetEntityContainer(ContainerName, DataSpace.CSpace, out container))
|
|
{
|
|
throw new InvalidOperationException(Strings.EntityDataSourceView_ContainerNameDoesNotExistOnTheContext(ContainerName));
|
|
}
|
|
}
|
|
|
|
// From LinqDataSourceHelper. Timestamp columns (of type byte[]) are of type IEnumerable.
|
|
// This routine compares all elements of the IEnumerable.
|
|
private static bool EnumerableContentEquals(IEnumerable enumerableA, IEnumerable enumerableB)
|
|
{
|
|
IEnumerator enumeratorA = enumerableA.GetEnumerator();
|
|
IEnumerator enumeratorB = enumerableB.GetEnumerator();
|
|
while (enumeratorA.MoveNext())
|
|
{
|
|
if (!enumeratorB.MoveNext())
|
|
return false;
|
|
object itemA = enumeratorA.Current;
|
|
object itemB = enumeratorB.Current;
|
|
if (itemA == null)
|
|
{
|
|
if (itemB != null)
|
|
return false;
|
|
}
|
|
else if (!itemA.Equals(itemB))
|
|
return false;
|
|
}
|
|
if (enumeratorB.MoveNext())
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
// This routine modified from System.Web.Ui.WebControls.
|
|
private static object Parameter_GetValue(object value, WebControlParameterProxy parameter, bool ignoreNullableTypeChanges)
|
|
{
|
|
// Convert.ChangeType() throws if you attempt to convert to DBNull, so we have to special case it.
|
|
if (parameter.TypeCode == TypeCode.DBNull)
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
// Get the value and convert it to the default value if it is null
|
|
if (parameter.ConvertEmptyStringToNull)
|
|
{
|
|
string stringValue = value as string;
|
|
if ((stringValue != null) && (stringValue.Length == 0))
|
|
{
|
|
value = null;
|
|
}
|
|
|
|
}
|
|
|
|
if (value == null) // Fill it with values from referenceParameters
|
|
{
|
|
// Use the parameter value if it is non-null
|
|
if (!parameter.HasValue)
|
|
{
|
|
return value;
|
|
}
|
|
|
|
object parameterValue = parameter.Value;
|
|
string valueString = parameterValue as String;
|
|
if (parameter.TypeCode == TypeCode.String && parameter.ConvertEmptyStringToNull && String.IsNullOrEmpty(valueString))
|
|
{
|
|
parameterValue = null;
|
|
}
|
|
|
|
if (null == parameterValue)
|
|
{
|
|
return null;
|
|
}
|
|
value = parameterValue;
|
|
}
|
|
|
|
Debug.Assert(value != null, "Value should not be null at this point.");
|
|
|
|
if (parameter.TypeCode == TypeCode.Object || parameter.TypeCode == TypeCode.Empty)
|
|
{
|
|
return value;
|
|
}
|
|
|
|
// For ObjectDataSource we special-case Nullable<T> and do nothing because these
|
|
// types will get converted when we actually call the method.
|
|
if (ignoreNullableTypeChanges)
|
|
{
|
|
Type valueType = value.GetType();
|
|
if (valueType.IsGenericType && (valueType.GetGenericTypeDefinition() == typeof(Nullable<>)))
|
|
{
|
|
return value;
|
|
}
|
|
}
|
|
return value = Convert.ChangeType(value, parameter.TypeCode, CultureInfo.CurrentCulture); ;
|
|
}
|
|
|
|
|
|
|
|
private static byte[] EcmaPublicKeyToken = { 0xb7, 0x7a, 0x5c, 0x56, 0x19, 0x34, 0xe0, 0x89 }; // b77a5c561934e089
|
|
private static byte[] MicrosoftPublicKeyToken = { 0xb0, 0x3f, 0x5f, 0x7f, 0x11, 0xd5, 0x0a, 0x3a }; // b03f5f7f11d50a3a
|
|
private static byte[] SharedLibPublicKeyToken = { 0x31, 0xbf, 0x38, 0x56, 0xad, 0x36, 0x4e, 0x35 }; // 31bf3856ad364e35
|
|
|
|
/// <summary>
|
|
/// Checks whether to try loading types from the <paramref name="assembly"/>.
|
|
/// </summary>
|
|
/// <param name="assembly">Assembly to be checked.</param>
|
|
/// <returns><c>true</c> if we should try loading types from this assembly. <c>false</c> otherwise.</returns>
|
|
/// <remarks>
|
|
/// Assemblies that are part of .NET Framework don't have entity/complex/enum types that could correspond to EdmTypes.
|
|
/// Therefore we should not try loading types from these assemblies. There are a lot of types there so it is costly
|
|
/// but we know that we would not find any interesting types there. This method filters out these assemblies.
|
|
/// </remarks>
|
|
private static bool ShouldTryLoadTypesFrom(Assembly assembly)
|
|
{
|
|
// assembly.GetName() required FileIOPermission and won't work in partial trust.
|
|
// The workaround is to parse the assembly.FullName
|
|
var asmPublicKeyToken = new AssemblyName(assembly.FullName).GetPublicKeyToken();
|
|
|
|
Debug.Assert(asmPublicKeyToken != null);
|
|
|
|
return !(asmPublicKeyToken.SequenceEqual(EcmaPublicKeyToken) ||
|
|
asmPublicKeyToken.SequenceEqual(MicrosoftPublicKeyToken) ||
|
|
asmPublicKeyToken.SequenceEqual(SharedLibPublicKeyToken));
|
|
}
|
|
|
|
#endregion Utilities
|
|
|
|
//public override void Delete(IDictionary keys, IDictionary oldValues, DataSourceViewOperationCallback callback){}
|
|
//public override void Insert(IDictionary values, DataSourceViewOperationCallback callback){}
|
|
//public override void Select(DataSourceSelectArguments arguments, DataSourceViewSelectCallback callback){}
|
|
//public override void Update(IDictionary keys, IDictionary values, IDictionary oldValues, DataSourceViewOperationCallback callback){}
|
|
|
|
}
|
|
}
|