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 Microsoft
|
|
// @backupOwner Microsoft
|
|
//---------------------------------------------------------------------
|
|
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){}
|
|
|
|
}
|
|
}
|