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

838 lines
34 KiB
C#

namespace System.Web.UI.WebControls {
using System.Web.UI.WebControls.Expressions;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Globalization;
using System.Linq;
using System.Security.Permissions;
using System.Web;
using System.Web.Resources;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Diagnostics.CodeAnalysis;
using System.ComponentModel;
public abstract class QueryableDataSourceView : DataSourceView, IStateManager {
//basic query parameters for any Queryable source
private ParameterCollection _whereParameters;
private ParameterCollection _orderByParameters;
private ParameterCollection _orderGroupsByParameters;
private ParameterCollection _selectNewParameters;
private ParameterCollection _groupByParameters;
// CUD operations
private ParameterCollection _deleteParameters;
private ParameterCollection _updateParameters;
private ParameterCollection _insertParameters;
private HttpContext _context;
private DataSourceControl _owner;
private IDynamicQueryable _queryable;
private string _groupBy;
private string _orderBy;
private string _orderGroupsBy;
private string _selectNew;
private string _where;
private bool _autoGenerateOrderByClause;
private bool _autoGenerateWhereClause;
private bool _autoPage = true;
private bool _autoSort = true;
private bool _isTracking;
protected static readonly object EventSelected = new object();
protected static readonly object EventSelecting = new object();
private static readonly object EventQueryCreated = new object();
// using Hashtable for original values so that ObjectStateFormatter will serialize it properly in ViewState.
private Hashtable _originalValues;
protected QueryableDataSourceView(DataSourceControl owner, string viewName, HttpContext context)
: this(owner, viewName, context, new DynamicQueryableWrapper()) {
_context = context;
_owner = owner;
}
internal QueryableDataSourceView(DataSourceControl owner, string viewName, HttpContext context, IDynamicQueryable queryable)
: base(owner, viewName) {
_context = context;
_queryable = queryable;
_owner = owner;
}
public bool AutoGenerateOrderByClause {
get {
return _autoGenerateOrderByClause;
}
set {
if (_autoGenerateOrderByClause != value) {
_autoGenerateOrderByClause = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public bool AutoGenerateWhereClause {
get {
return _autoGenerateWhereClause;
}
set {
if (_autoGenerateWhereClause != value) {
_autoGenerateWhereClause = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public virtual bool AutoPage {
get {
return _autoPage;
}
set {
if (_autoPage != value) {
_autoPage = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public virtual bool AutoSort {
get {
return _autoSort;
}
set {
if (_autoSort != value) {
_autoSort = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public override bool CanDelete {
get {
return false;
}
}
public override bool CanInsert {
get {
return false;
}
}
// When AutoPage is false the user should manually page in the Selecting event.
public override bool CanPage {
get {
return true;
}
}
// When AutoPage is false the user must set the total row count in the Selecting event.
public override bool CanRetrieveTotalRowCount {
get {
return true;
}
}
// When AutoSort is false the user should manually sort in the Selecting event.
public override bool CanSort {
get {
return true;
}
}
public override bool CanUpdate {
get {
return false;
}
}
public virtual ParameterCollection DeleteParameters {
get {
if (_deleteParameters == null) {
_deleteParameters = new ParameterCollection();
}
return _deleteParameters;
}
}
protected abstract Type EntityType {
get;
}
public virtual ParameterCollection GroupByParameters {
get {
if (_groupByParameters == null) {
_groupByParameters = new ParameterCollection();
_groupByParameters.ParametersChanged += new EventHandler(OnQueryParametersChanged);
if (_isTracking) {
DataSourceHelper.TrackViewState(_groupByParameters);
}
}
return _groupByParameters;
}
}
protected bool IsTrackingViewState {
get {
return _isTracking;
}
}
public virtual ParameterCollection InsertParameters {
get {
if (_insertParameters == null) {
_insertParameters = new ParameterCollection();
}
return _insertParameters;
}
}
public virtual ParameterCollection OrderByParameters {
get {
if (_orderByParameters == null) {
_orderByParameters = new ParameterCollection();
_orderByParameters.ParametersChanged += new EventHandler(OnQueryParametersChanged);
if (_isTracking) {
DataSourceHelper.TrackViewState(_orderByParameters);
}
}
return _orderByParameters;
}
}
public virtual ParameterCollection OrderGroupsByParameters {
get {
if (_orderGroupsByParameters == null) {
_orderGroupsByParameters = new ParameterCollection();
_orderGroupsByParameters.ParametersChanged += new EventHandler(OnQueryParametersChanged);
if (_isTracking) {
DataSourceHelper.TrackViewState(_orderGroupsByParameters);
}
}
return _orderGroupsByParameters;
}
}
public virtual string OrderBy {
get {
return _orderBy ?? String.Empty;
}
set {
if (_orderBy != value) {
_orderBy = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public virtual string OrderGroupsBy {
get {
return _orderGroupsBy ?? String.Empty;
}
set {
if (_orderGroupsBy != value) {
_orderGroupsBy = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public virtual string GroupBy {
get {
return _groupBy ?? String.Empty;
}
set {
if (_groupBy != value) {
_groupBy = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public virtual ParameterCollection SelectNewParameters {
get {
if (_selectNewParameters == null) {
_selectNewParameters = new ParameterCollection();
_selectNewParameters.ParametersChanged += new EventHandler(OnQueryParametersChanged);
if (_isTracking) {
DataSourceHelper.TrackViewState(_selectNewParameters);
}
}
return _selectNewParameters;
}
}
[SuppressMessage("Microsoft.Naming", "CA1711:IdentifiersShouldNotHaveIncorrectSuffix",
Justification = "SelectNew refers to a projection and 'New' is not used as a suffix in this case")]
public virtual string SelectNew {
get {
return _selectNew ?? String.Empty;
}
set {
if (_selectNew != value) {
_selectNew = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public virtual ParameterCollection WhereParameters {
get {
if (_whereParameters == null) {
_whereParameters = new ParameterCollection();
_whereParameters.ParametersChanged += new EventHandler(OnQueryParametersChanged);
if (_isTracking) {
DataSourceHelper.TrackViewState(_whereParameters);
}
}
return _whereParameters;
}
}
public virtual string Where {
get {
return _where ?? String.Empty;
}
set {
if (_where != value) {
_where = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public virtual ParameterCollection UpdateParameters {
get {
if (_updateParameters == null) {
_updateParameters = new ParameterCollection();
}
return _updateParameters;
}
}
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", Justification = "Derived classes will use this to as the ParametersChanged EventHandler")]
protected void OnQueryParametersChanged(object sender, EventArgs e) {
RaiseViewChanged();
}
[SuppressMessage("Microsoft.Design", "CA1030:UseEventsWhereAppropriate", Justification = "An event exists already and it it protected")]
public void RaiseViewChanged() {
OnDataSourceViewChanged(EventArgs.Empty);
}
/// <summary>
/// Gets the result to apply query
/// </summary>
/// <returns></returns>
protected abstract object GetSource(QueryContext context);
protected QueryContext CreateQueryContext(DataSourceSelectArguments arguments) {
IDictionary<string, object> whereParameters = WhereParameters.ToDictionary(_context, _owner);
IOrderedDictionary orderByParameters = OrderByParameters.GetValues(_context, _owner).ToCaseInsensitiveDictionary();
IDictionary<string, object> orderGroupsByParameters = OrderGroupsByParameters.ToDictionary(_context, _owner);
IDictionary<string, object> selectNewParameters = SelectNewParameters.ToDictionary(_context, _owner);
IDictionary<string, object> groupByParameters = GroupByParameters.ToDictionary(_context, _owner);
return new QueryContext(
whereParameters,
orderGroupsByParameters,
orderByParameters,
groupByParameters,
selectNewParameters,
arguments);
}
/// <summary>
/// Creates a select expression based on parameters and properties
/// </summary>
protected virtual IQueryable BuildQuery(DataSourceSelectArguments arguments) {
if (arguments == null) {
throw new ArgumentNullException("arguments");
}
// Create the query context
QueryContext context = CreateQueryContext(arguments);
// Clear out old values before selecting new data
_originalValues = null;
// Get the source of the query(root IQueryable)
object result = GetSource(context);
if (result != null) {
IQueryable source = QueryableDataSourceHelper.AsQueryable(result);
// Apply additional filterting
return ExecuteQuery(source, context);
}
return null;
}
protected virtual IQueryable ExecuteQuery(IQueryable source, QueryContext context) {
// Execute Query
source = ExecuteQueryExpressions(source, context);
// Execute Sorting
source = ExecuteSorting(source, context);
// Execute Paging
source = ExecutePaging(source, context);
return source;
}
protected IQueryable ExecuteQueryExpressions(IQueryable source, QueryContext context) {
if (source != null) {
QueryCreatedEventArgs queryArgs = new QueryCreatedEventArgs(source);
OnQueryCreated(queryArgs);
source = queryArgs.Query ?? source;
// Support the Dynamic Expression language used by LinqDataSource
if (AutoGenerateWhereClause) {
if (!String.IsNullOrEmpty(Where)) {
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
AtlasWeb.LinqDataSourceView_WhereAlreadySpecified, _owner.ID));
}
source = QueryableDataSourceHelper.CreateWhereExpression(context.WhereParameters, source, _queryable);
}
else if (!String.IsNullOrEmpty(Where)) {
source = _queryable.Where(source, Where, context.WhereParameters.ToEscapedParameterKeys(_owner));
}
if (AutoGenerateOrderByClause) {
if (!String.IsNullOrEmpty(OrderBy)) {
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
AtlasWeb.LinqDataSourceView_OrderByAlreadySpecified, _owner.ID));
}
source = QueryableDataSourceHelper.CreateOrderByExpression(context.OrderByParameters, source, _queryable);
}
else if (!String.IsNullOrEmpty(OrderBy)) {
source = _queryable.OrderBy(source, OrderBy, context.OrderByParameters.ToEscapedParameterKeys(_owner));
}
string groupBy = GroupBy;
if (String.IsNullOrEmpty(groupBy)) {
if (!String.IsNullOrEmpty(OrderGroupsBy)) {
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
AtlasWeb.LinqDataSourceView_OrderGroupsByRequiresGroupBy, _owner.ID));
}
}
else {
source = _queryable.GroupBy(source, groupBy, "it", context.GroupByParameters.ToEscapedParameterKeys(_owner));
if (!String.IsNullOrEmpty(OrderGroupsBy)) {
source = _queryable.OrderBy(source, OrderGroupsBy, context.OrderGroupsByParameters.ToEscapedParameterKeys(_owner));
}
}
if (!String.IsNullOrEmpty(SelectNew)) {
source = _queryable.Select(source, SelectNew, context.SelectParameters.ToEscapedParameterKeys(_owner));
}
return source;
}
return source;
}
protected IQueryable ExecuteSorting(IQueryable source, QueryContext context) {
string sortExpression = context.Arguments.SortExpression;
if (CanSort && AutoSort && !String.IsNullOrEmpty(sortExpression)) {
source = _queryable.OrderBy(source, sortExpression);
}
return source;
}
protected IQueryable ExecutePaging(IQueryable source, QueryContext context) {
if (CanPage && AutoPage) {
if (CanRetrieveTotalRowCount && context.Arguments.RetrieveTotalRowCount) {
context.Arguments.TotalRowCount = _queryable.Count(source);
}
if ((context.Arguments.MaximumRows > 0) && (context.Arguments.StartRowIndex >= 0)) {
source = _queryable.Skip(source, context.Arguments.StartRowIndex);
source = _queryable.Take(source, context.Arguments.MaximumRows);
}
}
else if (context.Arguments.RetrieveTotalRowCount && (context.Arguments.TotalRowCount == -1)) {
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
AtlasWeb.LinqDataSourceView_PagingNotHandled, _owner.ID));
}
return source;
}
protected virtual void LoadViewState(object savedState) {
if (savedState != null) {
object[] myState = (object[])savedState;
if (myState[0] != null) {
((IStateManager)WhereParameters).LoadViewState(myState[0]);
}
if (myState[1] != null) {
((IStateManager)OrderByParameters).LoadViewState(myState[1]);
}
if (myState[2] != null) {
((IStateManager)GroupByParameters).LoadViewState(myState[2]);
}
if (myState[3] != null) {
((IStateManager)OrderGroupsByParameters).LoadViewState(myState[3]);
}
if (myState[4] != null) {
((IStateManager)SelectNewParameters).LoadViewState(myState[4]);
}
if (myState[5] != null) {
_originalValues = (Hashtable)myState[5];
}
}
}
protected virtual object SaveViewState() {
object[] myState = new object[6];
myState[0] = DataSourceHelper.SaveViewState(_whereParameters);
myState[1] = DataSourceHelper.SaveViewState(_orderByParameters);
myState[2] = DataSourceHelper.SaveViewState(_groupByParameters);
myState[3] = DataSourceHelper.SaveViewState(_orderGroupsByParameters);
myState[4] = DataSourceHelper.SaveViewState(_selectNewParameters);
if ((_originalValues != null) && (_originalValues.Count > 0)) {
myState[5] = _originalValues;
}
return myState;
}
protected virtual void TrackViewState() {
_isTracking = true;
DataSourceHelper.TrackViewState(_whereParameters);
DataSourceHelper.TrackViewState(_orderByParameters);
DataSourceHelper.TrackViewState(_groupByParameters);
DataSourceHelper.TrackViewState(_orderGroupsByParameters);
DataSourceHelper.TrackViewState(_selectNewParameters);
}
protected internal override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments) {
ClearOriginalValues();
IQueryable source = BuildQuery(arguments);
IList results = source.ToList(source.ElementType);
// Store original values for concurrency
StoreOriginalValues(results);
return results;
}
protected void ClearOriginalValues() {
_originalValues = null;
}
protected virtual IDictionary GetOriginalValues(IDictionary keys) {
// Table data is stored in a hashtable with column names for keys and an ArrayList of row data for values.
// i.e, Hashtable { ID = ArrayList { 0, 1, 2 }, Name = ArrayList { "A", "B", "C" } }
if (_originalValues != null) {
// matches list keeps track of row indexes which match.
List<bool> matches = new List<bool>();
foreach (DictionaryEntry entry in keys) {
string propertyName = (String)entry.Key;
if (_originalValues.ContainsKey(propertyName)) {
object propertyValue = entry.Value;
// get the row values for the current column.
ArrayList values = (ArrayList)_originalValues[propertyName];
for (int i = 0; i < values.Count; i++) {
if (matches.Count <= i) { // first column
matches.Add(OriginalValueMatches(values[i], propertyValue));
}
else if (matches[i] == true) { // subsequent columns
matches[i] = OriginalValueMatches(values[i], propertyValue);
}
}
}
}
int rowIndex = matches.IndexOf(true);
// no rows match or too many rows match.
if ((rowIndex < 0) || (matches.IndexOf(true, rowIndex + 1) >= 0)) {
throw new InvalidOperationException(AtlasWeb.LinqDataSourceView_OriginalValuesNotFound);
}
// get original values for the matching row.
Dictionary<string, object> rowValues = new Dictionary<string, object>(_originalValues.Count,
StringComparer.OrdinalIgnoreCase);
foreach (DictionaryEntry entry in _originalValues) {
ArrayList value = (ArrayList)entry.Value;
rowValues.Add((string)entry.Key, value[rowIndex]);
}
return rowValues;
}
return null;
}
protected virtual void StoreOriginalValues(IList results) {
// Derived classes can override this function and call the overload
// to determine which columns it should store for optimistic concurrency
}
protected void StoreOriginalValues(IList results, Func<PropertyDescriptor, bool> include) {
PropertyDescriptorCollection props = TypeDescriptor.GetProperties(EntityType);
int numRows = results.Count;
int maxColumns = props.Count;
_originalValues = new Hashtable(maxColumns, StringComparer.OrdinalIgnoreCase);
foreach (PropertyDescriptor p in props) {
if (include(p) && p.PropertyType.IsSerializable) {
ArrayList values = new ArrayList(numRows);
_originalValues[p.Name] = values;
foreach (object currentRow in results) {
values.Add(p.GetValue(currentRow));
}
}
}
}
public int Update(IDictionary keys, IDictionary values, IDictionary oldValues) {
return ExecuteUpdate(keys, values, oldValues);
}
public int Delete(IDictionary keys, IDictionary oldValues) {
return ExecuteDelete(keys, oldValues);
}
public int Insert(IDictionary values) {
return ExecuteInsert(values);
}
protected QueryableDataSourceEditData BuildDeleteObject(IDictionary keys, IDictionary oldValues, IDictionary<string, Exception> validationErrors) {
QueryableDataSourceEditData editData = new QueryableDataSourceEditData();
Type dataObjectType = EntityType;
IDictionary caseInsensitiveOldValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
IDictionary originalValues = GetOriginalValues(keys);
ParameterCollection deleteParameters = DeleteParameters;
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
deleteParameters,
keys,
caseInsensitiveOldValues,
validationErrors)) {
return editData;
}
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
deleteParameters,
oldValues,
caseInsensitiveOldValues,
validationErrors)) {
return editData;
}
if (originalValues != null) {
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
deleteParameters,
originalValues,
caseInsensitiveOldValues,
validationErrors)) {
return editData;
}
}
editData.OriginalDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveOldValues, validationErrors);
return editData;
}
protected QueryableDataSourceEditData BuildInsertObject(IDictionary values, IDictionary<string, Exception> validationErrors) {
QueryableDataSourceEditData editData = new QueryableDataSourceEditData();
Type dataObjectType = EntityType;
IDictionary caseInsensitiveNewValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
InsertParameters,
InsertParameters.GetValues(_context, _owner),
caseInsensitiveNewValues,
validationErrors)) {
return editData;
}
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
InsertParameters,
values,
caseInsensitiveNewValues, validationErrors)) {
return editData;
}
editData.NewDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveNewValues, validationErrors);
return editData;
}
protected QueryableDataSourceEditData BuildUpdateObjects(IDictionary keys, IDictionary values, IDictionary oldValues, IDictionary<string, Exception> validationErrors) {
QueryableDataSourceEditData editData = new QueryableDataSourceEditData();
Type dataObjectType = EntityType;
IDictionary caseInsensitiveNewValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
IDictionary caseInsensitiveOldValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
IDictionary originalValues = GetOriginalValues(keys);
// We start out with the old values, just to pre-populate the list with items
// that might not have corresponding new values. For example if a GridView has
// a read-only field, there will be an old value, but no new value. The data object
// still has to have *some* value for a given field, so we just use the old value.
ParameterCollection updateParameters = UpdateParameters;
// If we have validation errors bail out while merging bailout
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
updateParameters,
oldValues,
caseInsensitiveOldValues,
caseInsensitiveNewValues,
validationErrors)) {
return editData;
}
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
updateParameters,
keys,
caseInsensitiveOldValues,
caseInsensitiveNewValues,
validationErrors)) {
return editData;
}
if (originalValues != null) {
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
updateParameters,
originalValues,
caseInsensitiveOldValues,
caseInsensitiveNewValues,
validationErrors)) {
return editData;
}
}
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
updateParameters,
values,
caseInsensitiveNewValues,
validationErrors)) {
return editData;
}
editData.NewDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveNewValues, validationErrors);
if (editData.NewDataObject != null) {
editData.OriginalDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveOldValues, validationErrors);
}
return editData;
}
protected virtual int DeleteObject(object oldEntity) {
return 0;
}
protected virtual int UpdateObject(object oldEntity, object newEntity) {
return 0;
}
protected virtual int InsertObject(object newEntity) {
return 0;
}
protected abstract void HandleValidationErrors(IDictionary<string, Exception> errors, DataSourceOperation operation);
protected override int ExecuteDelete(IDictionary keys, IDictionary oldValues) {
IDictionary<string, Exception> errors = new Dictionary<string, Exception>(StringComparer.OrdinalIgnoreCase);
QueryableDataSourceEditData editData = BuildDeleteObject(keys, oldValues, errors);
if (errors.Any()) {
HandleValidationErrors(errors, DataSourceOperation.Delete);
}
else {
return DeleteObject(editData.OriginalDataObject);
}
return -1;
}
protected override int ExecuteInsert(IDictionary values) {
IDictionary<string, Exception> errors = new Dictionary<string, Exception>(StringComparer.OrdinalIgnoreCase);
QueryableDataSourceEditData editData = BuildInsertObject(values, errors);
if (errors.Any()) {
HandleValidationErrors(errors, DataSourceOperation.Insert);
}
else {
return InsertObject(editData.NewDataObject);
}
return -1;
}
protected override int ExecuteUpdate(IDictionary keys, IDictionary values, IDictionary oldValues) {
IDictionary<string, Exception> errors = new Dictionary<string, Exception>(StringComparer.OrdinalIgnoreCase);
QueryableDataSourceEditData editData = BuildUpdateObjects(keys, values, oldValues, errors);
if (errors.Any()) {
HandleValidationErrors(errors, DataSourceOperation.Update);
}
else {
return UpdateObject(editData.OriginalDataObject, editData.NewDataObject);
}
return -1;
}
public event EventHandler<QueryCreatedEventArgs> QueryCreated {
add {
Events.AddHandler(EventQueryCreated, value);
}
remove {
Events.RemoveHandler(EventQueryCreated, value);
}
}
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnQueryCreated(QueryCreatedEventArgs e) {
EventHandler<QueryCreatedEventArgs> handler = (EventHandler<QueryCreatedEventArgs>)Events[EventQueryCreated];
if (handler != null) {
handler(this, e);
}
}
private bool OriginalValueMatches(object originalValue, object value) {
// 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 QueryableDataSourceHelper.EnumerableContentEquals(originalValueEnumerable, valueEnumerable);
}
return originalValue.Equals(value);
}
#region IStateManager Members
bool IStateManager.IsTrackingViewState {
get { return IsTrackingViewState; }
}
void IStateManager.LoadViewState(object state) {
LoadViewState(state);
}
object IStateManager.SaveViewState() {
return SaveViewState();
}
void IStateManager.TrackViewState() {
TrackViewState();
}
#endregion
}
}