Files
mono/mcs/class/referencesource/System.Web/UI/WebControls/ObjectDataSourceView.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

2097 lines
90 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="ObjectDataSourceView.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.UI.WebControls {
using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Data;
using System.Globalization;
using System.Reflection;
using System.Security;
using System.Text;
using System.Web.Compilation;
using System.Web.UI;
using System.Web.Util;
using ConflictOptions = System.Web.UI.ConflictOptions;
/// <devdoc>
/// Represents a single view of an ObjectDataSource.
/// </devdoc>
public class ObjectDataSourceView : DataSourceView, IStateManager {
private static readonly object EventDeleted = new object();
private static readonly object EventDeleting = new object();
private static readonly object EventFiltering = new object();
private static readonly object EventInserted = new object();
private static readonly object EventInserting = new object();
private static readonly object EventObjectCreated = new object();
private static readonly object EventObjectCreating = new object();
private static readonly object EventObjectDisposing = 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 HttpContext _context;
private ObjectDataSource _owner;
private bool _tracking;
private ConflictOptions _conflictDetection = ConflictOptions.OverwriteChanges;
private bool _convertNullToDBNull;
private string _dataObjectTypeName;
private string _deleteMethod;
private ParameterCollection _deleteParameters;
private bool _enablePaging;
private string _filterExpression;
private ParameterCollection _filterParameters;
private string _insertMethod;
private ParameterCollection _insertParameters;
private string _maximumRowsParameterName;
private string _oldValuesParameterFormatString;
private string _selectCountMethod;
private string _selectMethod;
private ParameterCollection _selectParameters;
private string _sortParameterName;
private string _startRowIndexParameterName;
private string _typeName;
private string _updateMethod;
private ParameterCollection _updateParameters;
/// <devdoc>
/// Creates a new ObjectDataSourceView.
/// </devdoc>
public ObjectDataSourceView(ObjectDataSource owner, string name, HttpContext context)
: base(owner, name) {
Debug.Assert(owner != null);
_owner = owner;
_context = context;
}
/// <devdoc>
/// Indicates that the view can delete rows.
/// </devdoc>
public override bool CanDelete {
get {
return (DeleteMethod.Length != 0);
}
}
/// <devdoc>
/// Indicates that the view can add new rows.
/// </devdoc>
public override bool CanInsert {
get {
return (InsertMethod.Length != 0);
}
}
/// <devdoc>
/// Indicates that the view can do server paging.
/// </devdoc>
public override bool CanPage {
get {
return EnablePaging;
}
}
/// <devdoc>
/// Indicates that the view can return the total number of rows returned by the query.
/// </devdoc>
public override bool CanRetrieveTotalRowCount {
get {
// We don't necessarily know if the data source can get the total row count until after the SelectMethod has
// been executed (e.g. it might return a DataSet). If the SelectCountMethod is set, we can definitely
// get the count. However, if it is not, we can only get the row count from the Selected data if it was not
// paged by the user's object, and it happened to be a DataView, DataSet, DataTable, ICollection, or object.
return ((SelectCountMethod.Length > 0) || (!EnablePaging));
}
}
/// <devdoc>
/// Indicates that the view can sort rows.
/// </devdoc>
public override bool CanSort {
get {
// We don't really know if the data source can sort until after the SelectMethod has
// been executed (e.g. it might return a DataSet), so we just assume it's true.
return true;
//return (SortParameterName.Length > 0);
}
}
/// <devdoc>
/// Indicates that the view can update rows.
/// </devdoc>
public override bool CanUpdate {
get {
return (UpdateMethod.Length != 0);
}
}
/// <devdoc>
/// Whether the delete command passes old values in the parameter collection.
/// </devdoc>
public ConflictOptions ConflictDetection {
get {
return _conflictDetection;
}
set {
if ((value < ConflictOptions.OverwriteChanges) || (value > ConflictOptions.CompareAllValues)) {
throw new ArgumentOutOfRangeException("value");
}
_conflictDetection = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
/// <devdoc>
/// Whether null values passed into insert/update/delete operations
/// will be converted to System.DbNull.
/// </devdoc>
public bool ConvertNullToDBNull {
get {
return _convertNullToDBNull;
}
set {
_convertNullToDBNull = value;
}
}
/// <devdoc>
/// An optional type that is used for update, insert, and delete
/// scenarios where the object's methods take in an aggregate object
/// rather than one parameter for each property in the selected data.
/// </devdoc>
public string DataObjectTypeName {
get {
if (_dataObjectTypeName == null) {
return String.Empty;
}
return _dataObjectTypeName;
}
set {
if (DataObjectTypeName != value) {
_dataObjectTypeName = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
/// <devdoc>
/// The method to execute when Delete() is called.
/// </devdoc>
public string DeleteMethod {
get {
if (_deleteMethod == null) {
return String.Empty;
}
return _deleteMethod;
}
set {
_deleteMethod = value;
}
}
/// <devdoc>
// Collection of parameters used when calling the DeleteMethod. These parameters are merged with the parameters provided by data-bound controls.
/// </devdoc>
public ParameterCollection DeleteParameters {
get {
if (_deleteParameters == null) {
_deleteParameters = new ParameterCollection();
}
return _deleteParameters;
}
}
/// <devdoc>
/// Indicates whether the Select method supports paging. If this is set to true, the
/// StartRowIndexParameterName and MaximumRowsParameterName properties must be set to the
/// names of the parameters of the Select method that accept the values for the starting
/// record to retrieve and the number of records to retrieve.
/// </devdoc>
public bool EnablePaging {
get {
return _enablePaging;
}
set {
if (EnablePaging != value) {
_enablePaging = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
/// <devdoc>
/// Filter expression used when Select() is called. Filtering is only available when the SelectMethod returns a DataSet or a DataTable.
/// </devdoc>
public string FilterExpression {
get {
if (_filterExpression == null) {
return String.Empty;
}
return _filterExpression;
}
set {
if (FilterExpression != value) {
_filterExpression = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
/// <devdoc>
/// Collection of parameters used in the FilterExpression property. Filtering is only available when the SelectMethod returns a DataSet or a DataTable.
/// </devdoc>
public ParameterCollection FilterParameters {
get {
if (_filterParameters == null) {
_filterParameters = new ParameterCollection();
_filterParameters.ParametersChanged += new EventHandler(SelectParametersChangedEventHandler);
if (_tracking) {
((IStateManager)_filterParameters).TrackViewState();
}
}
return _filterParameters;
}
}
/// <devdoc>
/// The method to execute when Insert() is called.
/// </devdoc>
public string InsertMethod {
get {
if (_insertMethod == null) {
return String.Empty;
}
return _insertMethod;
}
set {
_insertMethod = value;
}
}
/// <devdoc>
/// Collection of values used when calling the InsertMethod. These parameters are merged with the parameters provided by data-bound controls.
/// </devdoc>
public ParameterCollection InsertParameters {
get {
if (_insertParameters == null) {
_insertParameters = new ParameterCollection();
}
return _insertParameters;
}
}
/// <devdoc>
/// Returns whether this object is tracking view state.
/// </devdoc>
protected bool IsTrackingViewState {
get {
return _tracking;
}
}
/// <devdoc>
/// When EnablePaging is set to true, this property indicates the parameter of the Select
/// method that accepts the value for the number of records to retrieve.
/// </devdoc>
public string MaximumRowsParameterName {
get {
if (_maximumRowsParameterName == null) {
return "maximumRows";
}
return _maximumRowsParameterName;
}
set {
if (MaximumRowsParameterName != value) {
_maximumRowsParameterName = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
/// <devdoc>
/// The format string applied to the names of the old values parameters
/// </devdoc>
[
DefaultValue("{0}"),
WebCategory("Data"),
WebSysDescription(SR.DataSource_OldValuesParameterFormatString),
]
public string OldValuesParameterFormatString {
get {
if (_oldValuesParameterFormatString == null) {
return "{0}";
}
return _oldValuesParameterFormatString;
}
set {
_oldValuesParameterFormatString = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
/// <devdoc>
/// The method to execute when the total row count is needed. This method is only
/// used when EnablePaging is true and is optional.
/// </devdoc>
public string SelectCountMethod {
get {
if (_selectCountMethod == null) {
return String.Empty;
}
return _selectCountMethod;
}
set {
if (SelectCountMethod != value) {
_selectCountMethod = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
/// <devdoc>
/// The method to execute when Select() is called.
/// </devdoc>
public string SelectMethod {
get {
if (_selectMethod == null) {
return String.Empty;
}
return _selectMethod;
}
set {
if (SelectMethod != value) {
_selectMethod = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
/// <devdoc>
/// Collection of parameters used when calling the SelectMethod.
/// </devdoc>
public ParameterCollection SelectParameters {
get {
if (_selectParameters == null) {
_selectParameters = new ParameterCollection();
_selectParameters.ParametersChanged += new EventHandler(SelectParametersChangedEventHandler);
if (_tracking) {
((IStateManager)_selectParameters).TrackViewState();
}
}
return _selectParameters;
}
}
/// <devdoc>
/// The name of the parameter in the SelectMethod that specifies the
/// sort expression. This parameter's value will be automatically set
/// at runtime with the appropriate sort expression.
/// </devdoc>
public string SortParameterName {
get {
if (_sortParameterName == null) {
return String.Empty;
}
return _sortParameterName;
}
set {
if (SortParameterName != value) {
_sortParameterName = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
/// <devdoc>
/// When EnablePaging is set to true, this property indicates the parameter of the Select
/// method that accepts the value for the number of first record to retrieve.
/// </devdoc>
public string StartRowIndexParameterName {
get {
if (_startRowIndexParameterName == null) {
return "startRowIndex";
}
return _startRowIndexParameterName;
}
set {
if (StartRowIndexParameterName != value) {
_startRowIndexParameterName = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
/// <devdoc>
/// The type that contains the methods specified in this control.
/// </devdoc>
public string TypeName {
get {
if (_typeName == null) {
return String.Empty;
}
return _typeName;
}
set {
if (TypeName != value) {
_typeName = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
/// <devdoc>
/// The method to execute when Update() is called.
/// </devdoc>
public string UpdateMethod {
get {
if (_updateMethod == null) {
return String.Empty;
}
return _updateMethod;
}
set {
_updateMethod = value;
}
}
/// <devdoc>
/// Collection of parameters and values used when calling the UpdateMethod. These parameters are merged with the parameters provided by data-bound controls.
/// </devdoc>
public ParameterCollection UpdateParameters {
get {
if (_updateParameters == null) {
_updateParameters = new ParameterCollection();
}
return _updateParameters;
}
}
/// <summary>
/// Indicates which <see cref='System.Globalization.CultureInfo'/> is used by ObjectDataSourceView
/// when converting string values to actual types of properties of data object.
/// </summary>
public ParsingCulture ParsingCulture {
get;
set;
}
/// <devdoc>
/// This event is raised after the Delete operation has completed.
/// Handle this event if you need to examine the return values of
/// the method call, or examine an exception that may have been thrown.
/// </devdoc>
public event ObjectDataSourceStatusEventHandler Deleted {
add {
Events.AddHandler(EventDeleted, value);
}
remove {
Events.RemoveHandler(EventDeleted, value);
}
}
/// <devdoc>
/// This event is raised before the Delete operation has been executed.
/// Handle this event if you need to validate the values of parameters or
/// change their values.
/// </devdoc>
public event ObjectDataSourceMethodEventHandler Deleting {
add {
Events.AddHandler(EventDeleting, value);
}
remove {
Events.RemoveHandler(EventDeleting, value);
}
}
public event ObjectDataSourceFilteringEventHandler Filtering {
add {
Events.AddHandler(EventFiltering, value);
}
remove {
Events.RemoveHandler(EventFiltering, value);
}
}
/// <devdoc>
/// This event is raised after the Insert operation has completed.
/// Handle this event if you need to examine the return values of
/// the method call, or examine an exception that may have been thrown.
/// </devdoc>
public event ObjectDataSourceStatusEventHandler Inserted {
add {
Events.AddHandler(EventInserted, value);
}
remove {
Events.RemoveHandler(EventInserted, value);
}
}
/// <devdoc>
/// This event is raised before the Insert operation has been executed.
/// Handle this event if you need to validate the values of parameters or
/// change their values.
/// </devdoc>
public event ObjectDataSourceMethodEventHandler Inserting {
add {
Events.AddHandler(EventInserting, value);
}
remove {
Events.RemoveHandler(EventInserting, value);
}
}
/// <devdoc>
/// This event is raised after the instance of the object has been created.
/// Handle this event if you need to set additional properties on the
/// object before any other methods are called. This event will not be
/// raised if a custom instance was provided in the ObjectCreating event.
/// </devdoc>
public event ObjectDataSourceObjectEventHandler ObjectCreated {
add {
Events.AddHandler(EventObjectCreated, value);
}
remove {
Events.RemoveHandler(EventObjectCreated, value);
}
}
/// <devdoc>
/// This event is raised before the instance of the object has been created.
/// Handle this event if you need to call a non-default constructor on the
/// object. Set the ObjectInstance property of the EventArgs with the
/// custom instance. If this is set, the ObjectCreated event will not be
/// raised.
/// </devdoc>
public event ObjectDataSourceObjectEventHandler ObjectCreating {
add {
Events.AddHandler(EventObjectCreating, value);
}
remove {
Events.RemoveHandler(EventObjectCreating, value);
}
}
/// <devdoc>
/// This event is raised before the instance of the object is disposed.
/// Handle this event if you need to retrieve properties on the
/// object before it is disposed. If the object implements the IDispoable
/// interface, then the Dispose() method will be called automatically.
/// Set the Cancel property of the event args to true if you do not want
/// IDisposable.Dispose() to be called automatically.
/// </devdoc>
public event ObjectDataSourceDisposingEventHandler ObjectDisposing {
add {
Events.AddHandler(EventObjectDisposing, value);
}
remove {
Events.RemoveHandler(EventObjectDisposing, value);
}
}
/// <devdoc>
/// This event is raised after the Select operation has completed.
/// Handle this event if you need to examine the return values of
/// the method call, or examine an exception that may have been thrown.
/// </devdoc>
public event ObjectDataSourceStatusEventHandler Selected {
add {
Events.AddHandler(EventSelected, value);
}
remove {
Events.RemoveHandler(EventSelected, value);
}
}
/// <devdoc>
/// This event is raised before the Select operation has been executed.
/// Handle this event if you need to validate the values of parameters or
/// change their values.
/// </devdoc>
public event ObjectDataSourceSelectingEventHandler Selecting {
add {
Events.AddHandler(EventSelecting, value);
}
remove {
Events.RemoveHandler(EventSelecting, value);
}
}
/// <devdoc>
/// This event is raised after the Update operation has completed.
/// Handle this event if you need to examine the return values of
/// the method call, or examine an exception that may have been thrown.
/// </devdoc>
public event ObjectDataSourceStatusEventHandler Updated {
add {
Events.AddHandler(EventUpdated, value);
}
remove {
Events.RemoveHandler(EventUpdated, value);
}
}
/// <devdoc>
/// This event is raised before the Update operation has been executed.
/// Handle this event if you need to validate the values of parameters or
/// change their values.
/// </devdoc>
public event ObjectDataSourceMethodEventHandler Updating {
add {
Events.AddHandler(EventUpdating, value);
}
remove {
Events.RemoveHandler(EventUpdating, value);
}
}
/// <devdoc>
/// Creates a data object and sets the properties specified by name/value
/// pairs in the dictionary.
/// </devdoc>
private object BuildDataObject(Type dataObjectType, IDictionary inputParameters) {
Debug.Assert(inputParameters != null, "Did not expect null parameter dictionary");
Debug.Assert(dataObjectType != null, "Did not expect null DataObjectType");
object dataObject = Activator.CreateInstance(dataObjectType);
Debug.Assert(dataObject != null, "We should never get back a null instance of the DataObject if the creation succeeded.");
PropertyDescriptorCollection props = TypeDescriptor.GetProperties(dataObject);
foreach (DictionaryEntry de in inputParameters) {
//
string propName = (de.Key == null ? String.Empty : de.Key.ToString());
PropertyDescriptor pd = props.Find(propName, true);
if (pd == null) {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_DataObjectPropertyNotFound, propName, _owner.ID));
}
if (pd.IsReadOnly) {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_DataObjectPropertyReadOnly, propName, _owner.ID));
}
object value = BuildObjectValue(de.Value, pd.PropertyType, propName, ParsingCulture);
pd.SetValue(dataObject, value);
}
return dataObject;
}
/// <devdoc>
/// Builds a strongly typed value to be passed into a method either as a parameter
/// or as part of a data object. This will attempt to perform appropriate type
/// conversions based on the destination type and throw exceptions on fatal errors.
/// </devdoc>
private static object BuildObjectValue(object value, Type destinationType, string paramName, ParsingCulture parsingCulture) {
// Only consider converting the type if the value is non-null and the types don't match
if (value != null && (!destinationType.IsInstanceOfType(value))) {
Type innerDestinationType = destinationType;
bool isNullable = false;
if (destinationType.IsGenericType && (destinationType.GetGenericTypeDefinition() == typeof(Nullable<>))) {
innerDestinationType = destinationType.GetGenericArguments()[0];
isNullable = true;
}
else {
if (destinationType.IsByRef) {
innerDestinationType = destinationType.GetElementType();
}
}
// Try to convert from for example string to DateTime, so that
// afterwards we can convert DateTime to Nullable<DateTime>
// If the value is a string, we attempt to use a TypeConverter to convert it
value = ConvertType(value, innerDestinationType, paramName, parsingCulture);
// Special-case the value when the destination is Nullable<T>
if (isNullable) {
Type paramValueType = value.GetType();
if (innerDestinationType != paramValueType) {
// Throw if for example, we are trying to convert from int to Nullable<bool>
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_CannotConvertType, paramName, paramValueType.FullName, String.Format(CultureInfo.InvariantCulture, "Nullable<{0}>", destinationType.GetGenericArguments()[0].FullName)));
}
}
}
return value;
}
/// <devdoc>
/// Converts a type from a string representation to a strong type using
/// an appropriate TypeConverter. If the value is not a string, the value
/// is left unchanged.
/// </devdoc>
private static object ConvertType(object value, Type type, string paramName, ParsingCulture parsingCulture) {
string s = value as string;
if (s != null) {
// Get the type converter for the destination type
TypeConverter converter = TypeDescriptor.GetConverter(type);
Debug.Assert(converter != null);
if (converter != null) {
// Perform the conversion
try {
if (parsingCulture == ParsingCulture.Current) {
value = converter.ConvertFromString(null, CultureInfo.CurrentCulture, s);
}
else {
value = converter.ConvertFromInvariantString(s);
}
}
catch (NotSupportedException) {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_CannotConvertType, paramName, typeof(string).FullName, type.FullName));
}
catch (FormatException) {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_CannotConvertType, paramName, typeof(string).FullName, type.FullName));
}
}
}
return value;
}
/// <devdoc>
/// Creates an IEnumerable from the given data object and validates that the
/// DataSourceSelectArguments are valid for the conditions.
/// </devdoc>
private IEnumerable CreateEnumerableData(object dataObject, DataSourceSelectArguments arguments) {
if (FilterExpression.Length > 0) {
// Since this type is not valid for filtering, throw if there is a filter
throw new NotSupportedException(SR.GetString(SR.ObjectDataSourceView_FilterNotSupported, _owner.ID));
}
if (!String.IsNullOrEmpty(arguments.SortExpression)) {
throw new NotSupportedException(SR.GetString(SR.ObjectDataSourceView_SortNotSupportedOnIEnumerable, _owner.ID));
}
IEnumerable enumerable = dataObject as IEnumerable;
if (enumerable != null) {
// If object is an IEnumerable, return it as it is
if (!EnablePaging && arguments.RetrieveTotalRowCount && SelectCountMethod.Length == 0) {
ICollection collection = enumerable as ICollection;
if (collection != null) {
arguments.TotalRowCount = collection.Count;
}
}
return enumerable;
}
else {
// The result is neither a DataView, DataSet, DataTable, nor an IEnumerable, so we just wrap it in an IEnumerable
if (arguments.RetrieveTotalRowCount && SelectCountMethod.Length == 0) {
arguments.TotalRowCount = 1;
}
return new object[1] { dataObject };
}
}
/// <devdoc>
/// Creates a filtered DataView with optional filtering.
/// </devdoc>
private IEnumerable CreateFilteredDataView(DataTable dataTable, string sortExpression, string filterExpression) {
IOrderedDictionary parameterValues = FilterParameters.GetValues(_context, _owner);
if (filterExpression.Length > 0) {
ObjectDataSourceFilteringEventArgs filterArgs = new ObjectDataSourceFilteringEventArgs(parameterValues);
OnFiltering(filterArgs);
if (filterArgs.Cancel) {
return null;
}
}
return FilteredDataSetHelper.CreateFilteredDataView(dataTable, sortExpression, filterExpression, parameterValues);
}
public int Delete(IDictionary keys, IDictionary oldValues) {
return ExecuteDelete(keys, oldValues);
}
/// <devdoc>
/// </devdoc>
protected override int ExecuteDelete(IDictionary keys, IDictionary oldValues) {
if (!CanDelete) {
throw new NotSupportedException(SR.GetString(SR.ObjectDataSourceView_DeleteNotSupported, _owner.ID));
}
Type type = GetType(TypeName);
Debug.Assert(type != null, "Should not have a null type at this point");
// Try to get the DataObject type. If we do get the type then we will construct
// DataObjects representing the old values.
Type dataObjectType = TryGetDataObjectType();
ObjectDataSourceMethod method;
if (dataObjectType != null) {
// Build DataObject (Old)
IDictionary caseInsensitiveOldValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
MergeDictionaries(DeleteParameters, keys, caseInsensitiveOldValues);
if (ConflictDetection == ConflictOptions.CompareAllValues) {
if (oldValues == null) {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_Pessimistic, SR.GetString(SR.DataSourceView_delete), _owner.ID, "oldValues"));
}
MergeDictionaries(DeleteParameters, oldValues, caseInsensitiveOldValues);
}
object oldDataObject = BuildDataObject(dataObjectType, caseInsensitiveOldValues);
// Resolve and invoke the method
method = GetResolvedMethodData(type, DeleteMethod, dataObjectType, oldDataObject, null, DataSourceOperation.Delete);
ObjectDataSourceMethodEventArgs eventArgs = new ObjectDataSourceMethodEventArgs(method.Parameters);
OnDeleting(eventArgs);
if (eventArgs.Cancel) {
return 0;
}
}
else {
// Build parameter list that contains old values
IOrderedDictionary caseInsensitiveAllValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
string oldValuesParameterFormatString = OldValuesParameterFormatString;
MergeDictionaries(DeleteParameters, DeleteParameters.GetValues(_context, _owner), caseInsensitiveAllValues);
MergeDictionaries(DeleteParameters, keys, caseInsensitiveAllValues, oldValuesParameterFormatString);
if (ConflictDetection == ConflictOptions.CompareAllValues) {
if (oldValues == null) {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_Pessimistic, SR.GetString(SR.DataSourceView_delete), _owner.ID, "oldValues"));
}
MergeDictionaries(DeleteParameters, oldValues, caseInsensitiveAllValues, oldValuesParameterFormatString);
}
ObjectDataSourceMethodEventArgs eventArgs = new ObjectDataSourceMethodEventArgs(caseInsensitiveAllValues);
OnDeleting(eventArgs);
if (eventArgs.Cancel) {
return 0;
}
// Resolve and invoke the method
method = GetResolvedMethodData(type, DeleteMethod, caseInsensitiveAllValues, DataSourceOperation.Delete);
}
ObjectDataSourceResult result = InvokeMethod(method);
// Invalidate the cache and raise the change event to notify bound controls
if (_owner.Cache.Enabled) {
_owner.InvalidateCacheEntry();
}
OnDataSourceViewChanged(EventArgs.Empty);
return result.AffectedRows;
}
/// <devdoc>
/// </devdoc>
protected override int ExecuteInsert(IDictionary values) {
if (!CanInsert) {
throw new NotSupportedException(SR.GetString(SR.ObjectDataSourceView_InsertNotSupported, _owner.ID));
}
Type type = GetType(TypeName);
Debug.Assert(type != null, "Should not have a null type at this point");
// Try to get the DataObject type. If we do get the type then we will construct
// DataObjects representing the new values.
Type dataObjectType = TryGetDataObjectType();
ObjectDataSourceMethod method;
if (dataObjectType != null) {
// Build DataObject (New)
if (values == null || values.Count == 0) {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_InsertRequiresValues, _owner.ID));
}
IDictionary caseInsensitiveNewValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
MergeDictionaries(InsertParameters, values, caseInsensitiveNewValues);
object newDataObject = BuildDataObject(dataObjectType, caseInsensitiveNewValues);
// Resolve and invoke the method
method = GetResolvedMethodData(type, InsertMethod, dataObjectType, null, newDataObject, DataSourceOperation.Insert);
ObjectDataSourceMethodEventArgs eventArgs = new ObjectDataSourceMethodEventArgs(method.Parameters);
OnInserting(eventArgs);
if (eventArgs.Cancel) {
return 0;
}
}
else {
// Build parameter list that contains new values
IOrderedDictionary caseInsensitiveAllValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
MergeDictionaries(InsertParameters, InsertParameters.GetValues(_context, _owner), caseInsensitiveAllValues);
MergeDictionaries(InsertParameters, values, caseInsensitiveAllValues);
ObjectDataSourceMethodEventArgs eventArgs = new ObjectDataSourceMethodEventArgs(caseInsensitiveAllValues);
OnInserting(eventArgs);
if (eventArgs.Cancel) {
return 0;
}
// Resolve and invoke the method
method = GetResolvedMethodData(type, InsertMethod, caseInsensitiveAllValues, DataSourceOperation.Insert);
}
ObjectDataSourceResult result = InvokeMethod(method);
// Invalidate the cache and raise the change event to notify bound controls
if (_owner.Cache.Enabled) {
_owner.InvalidateCacheEntry();
}
OnDataSourceViewChanged(EventArgs.Empty);
return result.AffectedRows;
}
/// <devdoc>
/// </devdoc>
protected internal override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments) {
if (SelectMethod.Length == 0) {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_SelectNotSupported, _owner.ID));
}
if (CanSort) {
arguments.AddSupportedCapabilities(DataSourceCapabilities.Sort);
}
if (CanPage) {
arguments.AddSupportedCapabilities(DataSourceCapabilities.Page);
}
if (CanRetrieveTotalRowCount) {
arguments.AddSupportedCapabilities(DataSourceCapabilities.RetrieveTotalRowCount);
}
arguments.RaiseUnsupportedCapabilitiesError(this);
// Copy the parameters into a case insensitive dictionary
IOrderedDictionary mergedParameters = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
IDictionary selectParameters = SelectParameters.GetValues(_context, _owner);
foreach (DictionaryEntry de in selectParameters) {
mergedParameters[de.Key] = de.Value;
}
// If caching is enabled, load DataView, DataSet, DataTable, or IEnumerable from cache
bool cacheEnabled = _owner.Cache.Enabled;
if (cacheEnabled) {
object cachedData = _owner.LoadDataFromCache(arguments.StartRowIndex, arguments.MaximumRows);
if (cachedData != null) {
DataView dataView = cachedData as DataView;
if (dataView != null) {
if (arguments.RetrieveTotalRowCount && SelectCountMethod.Length == 0) {
arguments.TotalRowCount = dataView.Count;
}
if (FilterExpression.Length > 0) {
// Since this type is not valid for filtering, throw if there is a filter
throw new NotSupportedException(SR.GetString(SR.ObjectDataSourceView_FilterNotSupported, _owner.ID));
}
if (String.IsNullOrEmpty(arguments.SortExpression)) {
// If there is no sort expression, we can return the cached DataView
// If sorting is requested, we don't use the cached one and we go create a new one (and we'll
// most likely get exception, since caching+sorting+DataView=exception).
return dataView;
}
// Fall through as though the data wasn't in cache
}
else {
DataTable dataTable = FilteredDataSetHelper.GetDataTable(_owner, cachedData);
if (dataTable != null) {
// If we got back a DataTable from cache, return that
ProcessPagingData(arguments, mergedParameters);
return CreateFilteredDataView(dataTable, arguments.SortExpression, FilterExpression);
}
else {
// If we got back an IEnumerable from cache, return that
IEnumerable enumerableReturnValue = CreateEnumerableData(cachedData, arguments);
ProcessPagingData(arguments, mergedParameters);
return enumerableReturnValue;
}
}
}
}
// We have to raise the Selecting event early on so that we respect
// any changes the user has made to the DataSourceSelectArguments.
ObjectDataSourceSelectingEventArgs eventArgs = new ObjectDataSourceSelectingEventArgs(mergedParameters, arguments, false);
OnSelecting(eventArgs);
if (eventArgs.Cancel) {
return null;
}
// Create a copy of mergedParameters for queryRowCount that doesn't get all the Select, Sort, paging parameters
OrderedDictionary queryRowCountParameters = new OrderedDictionary(mergedParameters.Count);
foreach (DictionaryEntry entry in mergedParameters) {
queryRowCountParameters.Add(entry.Key, entry.Value);
}
// NOTE: These special parameters are only added here so that they don't show up
// for the SelectCount operation.
// Add the sort expression as a parameter if necessary
string sortParameterName = SortParameterName;
if (sortParameterName.Length > 0) {
mergedParameters[sortParameterName] = arguments.SortExpression;
// We reset the sort expression here so that we pretend as
// though we're not really sorting (since the developer is
// worrying about it instead of us).
arguments.SortExpression = String.Empty;
}
// Add the paging arguments as parameters if necessary
if (EnablePaging) {
string maximumRowsParameterName = MaximumRowsParameterName;
string startRowIndexParameterName = StartRowIndexParameterName;
if (String.IsNullOrEmpty(maximumRowsParameterName) ||
String.IsNullOrEmpty(startRowIndexParameterName)) {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_MissingPagingSettings, _owner.ID));
}
// Create a new dictionary with the paging information and merge it in (so we get type conversions)
IDictionary pagingParameters = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
pagingParameters[maximumRowsParameterName] = arguments.MaximumRows;
pagingParameters[startRowIndexParameterName] = arguments.StartRowIndex;
MergeDictionaries(SelectParameters, pagingParameters, mergedParameters);
}
Type type = GetType(TypeName);
Debug.Assert(type != null, "Should not have a null type at this point");
object instance = null;
ObjectDataSourceResult result = null;
try {
// Resolve and invoke the method
ObjectDataSourceMethod method = GetResolvedMethodData(type, SelectMethod, mergedParameters, DataSourceOperation.Select);
result = InvokeMethod(method, false, ref instance);
// If the return value is null, there is no more processing to be done
if (result.ReturnValue == null) {
return null;
}
// Get the total row count if it is requested
if (arguments.RetrieveTotalRowCount && SelectCountMethod.Length > 0) {
int cachedTotalRowCount = -1;
if (cacheEnabled) {
cachedTotalRowCount = _owner.LoadTotalRowCountFromCache();
if (cachedTotalRowCount >= 0) {
arguments.TotalRowCount = cachedTotalRowCount;
}
}
if (cachedTotalRowCount < 0) {
cachedTotalRowCount = QueryTotalRowCount(queryRowCountParameters, arguments, true, ref instance);
arguments.TotalRowCount = cachedTotalRowCount;
if (cacheEnabled) {
_owner.SaveTotalRowCountToCache(cachedTotalRowCount);
}
}
}
}
finally {
if (instance != null) {
ReleaseInstance(instance);
}
}
// Process the return value
// Order of precedence: DataView, DataTable, DataSet, IEnumerable, <everything else>
{
// Check if the return value was a DataView
DataView dataView = result.ReturnValue as DataView;
if (dataView != null) {
if (arguments.RetrieveTotalRowCount && SelectCountMethod.Length == 0) {
arguments.TotalRowCount = dataView.Count;
}
if (FilterExpression.Length > 0) {
// Since this type is not valid for filtering, throw if there is a filter
throw new NotSupportedException(SR.GetString(SR.ObjectDataSourceView_FilterNotSupported, _owner.ID));
}
if (!String.IsNullOrEmpty(arguments.SortExpression)) {
if (cacheEnabled) {
// Since this type is not valid for caching, throw if caching is enabled
throw new NotSupportedException(SR.GetString(SR.ObjectDataSourceView_CacheNotSupportedOnSortedDataView, _owner.ID));
}
dataView.Sort = arguments.SortExpression;
}
// If caching is enabled, save data to cache
if (cacheEnabled) {
SaveDataAndRowCountToCache(arguments, result.ReturnValue);
}
return dataView;
}
else {
// Check if the return value was a DataSet or DataTable
DataTable dataTable = FilteredDataSetHelper.GetDataTable(_owner, result.ReturnValue);
if (dataTable != null) {
if (arguments.RetrieveTotalRowCount && SelectCountMethod.Length == 0) {
arguments.TotalRowCount = dataTable.Rows.Count;
}
// If caching is enabled, save data to cache
if (cacheEnabled) {
SaveDataAndRowCountToCache(arguments, result.ReturnValue);
}
// If we got a DataTable from the result, create a view with filtering and sorting
return CreateFilteredDataView(dataTable, arguments.SortExpression, FilterExpression);
}
else {
// CreateEnumerableData will get an appropriate IEnumerable from the data, and also
// validate that filtering and sorting are not used.
IEnumerable enumerableReturnValue = CreateEnumerableData(result.ReturnValue, arguments);
// If caching is enabled, save data to cache
if (cacheEnabled) {
if (enumerableReturnValue is IDataReader) {
// IDataReader is specifically not supported with caching since the contract
// is that they are forward-only (i.e. not resettable).
throw new NotSupportedException(SR.GetString(SR.ObjectDataSourceView_CacheNotSupportedOnIDataReader, _owner.ID));
}
SaveDataAndRowCountToCache(arguments, enumerableReturnValue);
}
return enumerableReturnValue;
}
}
}
}
/// <devdoc>
/// </devdoc>
protected override int ExecuteUpdate(IDictionary keys, IDictionary values, IDictionary oldValues) {
if (!CanUpdate) {
throw new NotSupportedException(SR.GetString(SR.ObjectDataSourceView_UpdateNotSupported, _owner.ID));
}
Type type = GetType(TypeName);
Debug.Assert(type != null, "Should not have a null type at this point");
// Try to get the DataObject type. If we do get the type then we will construct
// DataObjects representing the new (and possibly old) values.
Type dataObjectType = TryGetDataObjectType();
ObjectDataSourceMethod method;
if (dataObjectType != null) {
if (ConflictDetection == ConflictOptions.CompareAllValues) {
// Build two DataObjects (Old + New)
if (oldValues == null) {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_Pessimistic, SR.GetString(SR.DataSourceView_update), _owner.ID, "oldValues"));
}
IDictionary caseInsensitiveNewValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
IDictionary caseInsensitiveOldValues = null;
// 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.
MergeDictionaries(UpdateParameters, oldValues, caseInsensitiveNewValues);
MergeDictionaries(UpdateParameters, keys, caseInsensitiveNewValues);
MergeDictionaries(UpdateParameters, values, caseInsensitiveNewValues);
// For optimistic updates we require that there be old values, and then
// we move them into a case-insensitive dictionary for merging.
if (oldValues == null) {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_Pessimistic, SR.GetString(SR.DataSourceView_update), _owner.ID, "oldValues"));
}
caseInsensitiveOldValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
MergeDictionaries(UpdateParameters, oldValues, caseInsensitiveOldValues);
MergeDictionaries(UpdateParameters, keys, caseInsensitiveOldValues);
object newDataObject = BuildDataObject(dataObjectType, caseInsensitiveNewValues);
object oldDataObject = BuildDataObject(dataObjectType, caseInsensitiveOldValues);
// Resolve and invoke the method
method = GetResolvedMethodData(type, UpdateMethod, dataObjectType, oldDataObject, newDataObject, DataSourceOperation.Update);
}
else {
// Build one DataObject (New)
IDictionary caseInsensitiveNewValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
// 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.
MergeDictionaries(UpdateParameters, oldValues, caseInsensitiveNewValues);
MergeDictionaries(UpdateParameters, keys, caseInsensitiveNewValues);
MergeDictionaries(UpdateParameters, values, caseInsensitiveNewValues);
object newDataObject = BuildDataObject(dataObjectType, caseInsensitiveNewValues);
// Resolve and invoke the method
method = GetResolvedMethodData(type, UpdateMethod, dataObjectType, null, newDataObject, DataSourceOperation.Update);
}
ObjectDataSourceMethodEventArgs eventArgs = new ObjectDataSourceMethodEventArgs(method.Parameters);
OnUpdating(eventArgs);
if (eventArgs.Cancel) {
return 0;
}
}
else {
// Build parameter list that contains old values (optionally), new values, and keys
IOrderedDictionary caseInsensitiveAllValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
string oldValuesParameterFormatString = OldValuesParameterFormatString;
// Add UpdateParameters, but exclude params that are keys (they will be added later)
IDictionary updateParams = UpdateParameters.GetValues(_context, _owner);
if (keys != null) {
foreach (DictionaryEntry de in keys) {
if (updateParams.Contains(de.Key)) {
updateParams.Remove(de.Key);
}
}
}
MergeDictionaries(UpdateParameters, updateParams, caseInsensitiveAllValues);
MergeDictionaries(UpdateParameters, values, caseInsensitiveAllValues);
if (ConflictDetection == ConflictOptions.CompareAllValues) {
MergeDictionaries(UpdateParameters, oldValues, caseInsensitiveAllValues, oldValuesParameterFormatString);
}
MergeDictionaries(UpdateParameters, keys, caseInsensitiveAllValues, oldValuesParameterFormatString);
ObjectDataSourceMethodEventArgs eventArgs = new ObjectDataSourceMethodEventArgs(caseInsensitiveAllValues);
OnUpdating(eventArgs);
if (eventArgs.Cancel) {
return 0;
}
// Resolve and invoke the method
method = GetResolvedMethodData(type, UpdateMethod, caseInsensitiveAllValues, DataSourceOperation.Update);
}
ObjectDataSourceResult result = InvokeMethod(method);
// Invalidate the cache and raise the change event to notify bound controls
if (_owner.Cache.Enabled) {
_owner.InvalidateCacheEntry();
}
OnDataSourceViewChanged(EventArgs.Empty);
return result.AffectedRows;
}
/// <devdoc>
/// Returns true if the two parameters represent the same type of operation.
/// </devdoc>
private static DataObjectMethodType GetMethodTypeFromOperation(DataSourceOperation operation) {
switch (operation) {
case DataSourceOperation.Delete:
return DataObjectMethodType.Delete;
case DataSourceOperation.Insert:
return DataObjectMethodType.Insert;
case DataSourceOperation.Select:
return DataObjectMethodType.Select;
case DataSourceOperation.Update:
return DataObjectMethodType.Update;
}
throw new ArgumentOutOfRangeException("operation");
}
/// <devdoc>
/// Extracts the values of all output (out and ref) parameters given a list of parameters and their respective values.
/// </devdoc>
private IDictionary GetOutputParameters(ParameterInfo[] parameters, object[] values) {
IDictionary outputParameters = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
for (int i = 0; i < parameters.Length; i++) {
ParameterInfo parameter = parameters[i];
if (parameter.ParameterType.IsByRef) {
outputParameters[parameter.Name] = values[i];
}
}
return outputParameters;
}
private ObjectDataSourceMethod GetResolvedMethodData(Type type, string methodName, Type dataObjectType, object oldDataObject, object newDataObject, DataSourceOperation operation) {
Debug.Assert(dataObjectType != null, "This overload of GetResolvedMethodData should only be called when using a DataObject");
Debug.Assert(oldDataObject != null || newDataObject != null, "Did not expect both oldDataObject and newDataObject to be null");
// Get a list of all the overloads of the requested method
MethodInfo[] methods = type.GetMethods(
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.Static |
BindingFlags.FlattenHierarchy);
MethodInfo matchedMethod = null;
ParameterInfo[] matchedMethodParameters = null;
int requiredParameterCount;
if (oldDataObject == null) {
requiredParameterCount = 1;
}
else {
if (newDataObject == null) {
requiredParameterCount = 1;
}
else {
requiredParameterCount = 2;
}
}
foreach (MethodInfo mi in methods) {
if (String.Equals(methodName, mi.Name, StringComparison.OrdinalIgnoreCase)) {
if (mi.IsGenericMethodDefinition) {
// We do not support binding to generic methods, e.g. public void DoSomething<T>(T t)
continue;
}
ParameterInfo[] methodParameters = mi.GetParameters();
int methodParametersCount = methodParameters.Length;
if (methodParametersCount == requiredParameterCount) {
if (requiredParameterCount == 1 &&
methodParameters[0].ParameterType == dataObjectType) {
// Only one parameter, of proper type
// This is only valid for insert, delete, and non-optimistic update
matchedMethod = mi;
matchedMethodParameters = methodParameters;
break;
}
if (requiredParameterCount == 2 &&
methodParameters[0].ParameterType == dataObjectType &&
methodParameters[1].ParameterType == dataObjectType) {
// Two parameters of proper type in Update
// This is only valid for optimistic update
matchedMethod = mi;
matchedMethodParameters = methodParameters;
break;
}
}
}
}
if (matchedMethod == null) {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_MethodNotFoundForDataObject, _owner.ID, methodName, dataObjectType.FullName));
}
Debug.Assert(matchedMethodParameters != null, "Method parameters should not be null if a method was found");
// Set up parameter array for method call
OrderedDictionary parameters = new OrderedDictionary(2, StringComparer.OrdinalIgnoreCase);
if (oldDataObject == null) {
parameters.Add(matchedMethodParameters[0].Name, newDataObject);
}
else {
if (newDataObject == null) {
parameters.Add(matchedMethodParameters[0].Name, oldDataObject);
}
else {
// We know that we matched on 2 objects for a optimistic update.
// Match the parameters based on the format string so we know which one is the old
// object and which is the new, then pass objects into the method in the correct order.
string param0Name = matchedMethodParameters[0].Name;
string param1Name = matchedMethodParameters[1].Name;
string formattedParamName = String.Format(CultureInfo.InvariantCulture, OldValuesParameterFormatString, param0Name);
if (String.Equals(param1Name, formattedParamName, StringComparison.OrdinalIgnoreCase)) {
parameters.Add(param0Name, newDataObject);
parameters.Add(param1Name, oldDataObject);
}
else {
formattedParamName = String.Format(CultureInfo.InvariantCulture, OldValuesParameterFormatString, param1Name);
if (String.Equals(param0Name, formattedParamName, StringComparison.OrdinalIgnoreCase)) {
parameters.Add(param0Name, oldDataObject);
parameters.Add(param1Name, newDataObject);
}
else {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_NoOldValuesParams, _owner.ID));
}
}
}
}
// The parameters collection is always readonly in this case since we
// do not want the user adding/removing the known objects.
return new ObjectDataSourceMethod(operation, type, matchedMethod, parameters.AsReadOnly());
}
/// <devdoc>
/// Resolves a method based on a type and the name of the method. Overload resolution is
/// performed primarily based on the names of parameters passed in the two dictionary
/// parameters. Conflict resolution is done based on a rating scale of confidence levels
/// (see comments in this method).
/// The return value is the MethodInfo that was found along with an array of parameter
/// values to be passed in for the invocation.
/// </devdoc>
private ObjectDataSourceMethod GetResolvedMethodData(Type type, string methodName, IDictionary allParameters, DataSourceOperation operation) {
Debug.Assert(allParameters != null, "The 'allParameters' dictionary should never be null");
// Since there is no method type for SelectCount, we special case it
bool isSelectCount = (operation == DataSourceOperation.SelectCount);
DataObjectMethodType methodType = DataObjectMethodType.Select;
if (!isSelectCount) {
methodType = GetMethodTypeFromOperation(operation);
}
// Get a list of all the overloads of the requested method
MethodInfo[] methods = type.GetMethods(
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.Static |
BindingFlags.FlattenHierarchy);
MethodInfo matchedMethod = null;
ParameterInfo[] matchedMethodParameters = null;
// Indicates how confident we are that a method overload is a good match
// -1 - indicates no confidence - no appropriate methods have been found at all
// 0 - indicates low confidence - only parameter names match
// 1 - indicates medium confidence - parameter names match, method is DataObjectMethod
// 2 - indicates high confidence - parameter names match, method is DataObjectMethod, is default method
int highestConfidence = -1;
bool confidenceConflict = false; // Indicates that there is more than one method at the current highest confidence level
int allParameterCount = allParameters.Count;
foreach (MethodInfo mi in methods) {
if (String.Equals(methodName, mi.Name, StringComparison.OrdinalIgnoreCase)) {
if (mi.IsGenericMethodDefinition) {
// We do not support binding to generic methods, e.g. public void DoSomething<T>(T t)
continue;
}
ParameterInfo[] methodParameters = mi.GetParameters();
int methodParametersCount = methodParameters.Length;
// We are not using DataObject. There is either a Select operation, or it is an
// Update/Insert/Delete operation that does not use DataObjects.
// First check if the parameter counts match
if (methodParametersCount != allParameterCount) {
continue;
}
// Check if all the parameter names match
bool parameterMismatch = false;
foreach (ParameterInfo pi in methodParameters) {
if (!allParameters.Contains(pi.Name)) {
parameterMismatch = true;
break;
}
}
if (parameterMismatch) {
continue;
}
int confidence = 0; // See comment above regarding confidence
if (!isSelectCount) {
DataObjectMethodAttribute attr = Attribute.GetCustomAttribute(mi, typeof(DataObjectMethodAttribute), true) as DataObjectMethodAttribute;
if (attr != null) {
if (attr.MethodType == methodType) {
if (attr.IsDefault) {
// Method is decorated and is default
confidence = 2;
}
else {
// Method is decorated but not default
confidence = 1;
}
}
}
}
// If we found another method
if (confidence == highestConfidence) {
confidenceConflict = true;
}
else {
// If method looks like it's the best match so far, store it
if (confidence > highestConfidence) {
highestConfidence = confidence;
confidenceConflict = false;
matchedMethod = mi;
matchedMethodParameters = methodParameters;
}
}
}
}
if (confidenceConflict) {
// There was more than one method that looked like a good match, but none had
// a higher confidence level than the others, so we fail. See comment above
// regarding confidence levels.
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_MultipleOverloads, _owner.ID));
}
if (matchedMethod == null) {
if (allParameterCount == 0) {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_MethodNotFoundNoParams, _owner.ID, methodName));
}
else {
string[] paramNames = new string[allParameterCount];
allParameters.Keys.CopyTo(paramNames, 0);
string paramString = String.Join(", ", paramNames);
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_MethodNotFoundWithParams, _owner.ID, methodName, paramString));
}
}
Debug.Assert(matchedMethodParameters != null, "Method parameters should not be null if a method was found");
OrderedDictionary parameters = null;
// Create the actual parameter list to be passed to the method
int methodParameterCount = matchedMethodParameters.Length;
if (methodParameterCount > 0) {
parameters = new OrderedDictionary(methodParameterCount, StringComparer.OrdinalIgnoreCase);
bool convertNullToDBNull = ConvertNullToDBNull;
for (int i = 0; i < matchedMethodParameters.Length; i++) {
ParameterInfo methodParameter = matchedMethodParameters[i];
string paramName = methodParameter.Name;
// Check if the required parameter exists in the input parameters
Debug.Assert(allParameters.Contains(paramName));
object parameterValue = allParameters[paramName];
if (convertNullToDBNull && (parameterValue == null)) {
parameterValue = DBNull.Value;
}
else {
parameterValue = BuildObjectValue(parameterValue, methodParameter.ParameterType, paramName, ParsingCulture);
}
parameters.Add(paramName, parameterValue);
}
}
return new ObjectDataSourceMethod(operation, type, matchedMethod, parameters);
}
private Type GetType(string typeName) {
if (TypeName.Length == 0) {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_TypeNotSpecified, _owner.ID));
}
// Load the type using BuildManager (do not throw on fail, ignore case)
Type type = BuildManager.GetType(TypeName, false, true);
// If the type was not found, throw
if (type == null) {
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_TypeNotFound, _owner.ID));
}
return type;
}
public int Insert(IDictionary values) {
return ExecuteInsert(values);
}
private ObjectDataSourceResult InvokeMethod(ObjectDataSourceMethod method) {
object instance = null;
return InvokeMethod(method, true, ref instance);
}
/// <devdoc>
/// Invokes a given method with the specified parameters. This will also raise
/// the appropriate post event after execution.
/// </devdoc>
private ObjectDataSourceResult InvokeMethod(ObjectDataSourceMethod method, bool disposeInstance, ref object instance) {
// If the method is not static, we need to create an instance of the type
if (method.MethodInfo.IsStatic) {
if (instance != null) {
ReleaseInstance(instance);
}
instance = null;
}
else {
if (instance == null) {
// Raise event to allow page developer to supply a custom instance of the type
ObjectDataSourceEventArgs objectEventArgs = new ObjectDataSourceEventArgs(null);
OnObjectCreating(objectEventArgs);
// If page developer did not create a custom instance, we attempt to instantiate
// the object ourselves, and raise the ObjectCreated event
if (objectEventArgs.ObjectInstance == null) {
objectEventArgs.ObjectInstance = Activator.CreateInstance(method.Type);
// Raise ObjectCreated event with the same event args
OnObjectCreated(objectEventArgs);
}
instance = objectEventArgs.ObjectInstance;
}
}
// Call the method and if an exception is thrown, hold on to it to let the page developer attempt to handle it
object returnValue = null;
int affectedRows = -1;
bool eventFired = false;
object[] parameterValues = null;
if (method.Parameters != null && method.Parameters.Count > 0) {
parameterValues = new object[method.Parameters.Count];
for (int i = 0; i < method.Parameters.Count; i++) {
parameterValues[i] = method.Parameters[i];
}
}
try {
returnValue = method.MethodInfo.Invoke(instance, parameterValues);
}
catch (Exception ex) {
// Collect output parameters
IDictionary outputParameters = GetOutputParameters(method.MethodInfo.GetParameters(), parameterValues);
ObjectDataSourceStatusEventArgs statusEventArgs = new ObjectDataSourceStatusEventArgs(returnValue, outputParameters, ex);
eventFired = true;
switch (method.Operation) {
case DataSourceOperation.Delete:
OnDeleted(statusEventArgs);
break;
case DataSourceOperation.Insert:
OnInserted(statusEventArgs);
break;
case DataSourceOperation.Select:
OnSelected(statusEventArgs);
break;
case DataSourceOperation.SelectCount:
OnSelected(statusEventArgs);
break;
case DataSourceOperation.Update:
OnUpdated(statusEventArgs);
break;
}
affectedRows = statusEventArgs.AffectedRows;
if (!statusEventArgs.ExceptionHandled) {
throw;
}
}
finally {
// This block is to ensure that we always at least try to raise
// the Disposing event, even if the other event handlers threw
// exceptions.
try {
if (eventFired == false) {
// Collect output parameters
IDictionary outputParameters = GetOutputParameters(method.MethodInfo.GetParameters(), parameterValues);
ObjectDataSourceStatusEventArgs statusEventArgs = new ObjectDataSourceStatusEventArgs(returnValue, outputParameters);
switch (method.Operation) {
case DataSourceOperation.Delete:
OnDeleted(statusEventArgs);
break;
case DataSourceOperation.Insert:
OnInserted(statusEventArgs);
break;
case DataSourceOperation.Select:
OnSelected(statusEventArgs);
break;
case DataSourceOperation.SelectCount:
OnSelected(statusEventArgs);
break;
case DataSourceOperation.Update:
OnUpdated(statusEventArgs);
break;
}
affectedRows = statusEventArgs.AffectedRows;
}
}
finally {
// Raise ObjectDisposing event
if (instance != null && disposeInstance) {
ReleaseInstance(instance);
instance = null;
}
}
}
return new ObjectDataSourceResult(returnValue, affectedRows);
}
/// <devdoc>
/// Loads view state.
/// </devdoc>
protected virtual void LoadViewState(object savedState) {
if (savedState == null)
return;
Pair myState = (Pair)savedState;
if (myState.First != null)
((IStateManager)SelectParameters).LoadViewState(myState.First);
if (myState.Second != null)
((IStateManager)FilterParameters).LoadViewState(myState.Second);
}
private static void MergeDictionaries(ParameterCollection reference, IDictionary source, IDictionary destination) {
MergeDictionaries(reference, source, destination, null);
}
/// <devdoc>
/// Merges new values in the source dictionary with old values in the destination dictionary.
/// The reference parameter is used to assign types to values that got merged.
/// If a format string is specified, it will be applied to the parameter name when it is
/// added to the destination dictionary.
/// </devdoc>
private static void MergeDictionaries(ParameterCollection reference, IDictionary source, IDictionary destination, string parameterNameFormatString) {
Debug.Assert(destination != null);
Debug.Assert(reference != null);
if (source != null) {
foreach (DictionaryEntry de in source) {
object value = de.Value;
// If the reference collection contains this parameter, we will convert its type to match it
Parameter referenceParameter = null;
string parameterName = (string)de.Key;
if (parameterNameFormatString != null) {
parameterName = String.Format(CultureInfo.InvariantCulture, parameterNameFormatString, parameterName);
}
foreach (Parameter p in reference) {
if (String.Equals(p.Name, parameterName, StringComparison.OrdinalIgnoreCase)) {
referenceParameter = p;
break;
}
}
if (referenceParameter != null) {
value = referenceParameter.GetValue(value, true);
}
destination[parameterName] = value;
}
}
}
/// <devdoc>
/// Raises the Deleted event.
/// </devdoc>
protected virtual void OnDeleted(ObjectDataSourceStatusEventArgs e) {
ObjectDataSourceStatusEventHandler handler = Events[EventDeleted] as ObjectDataSourceStatusEventHandler;
if (handler != null) {
handler(this, e);
}
}
/// <devdoc>
/// Raises the Deleting event.
/// </devdoc>
protected virtual void OnDeleting(ObjectDataSourceMethodEventArgs e) {
ObjectDataSourceMethodEventHandler handler = Events[EventDeleting] as ObjectDataSourceMethodEventHandler;
if (handler != null) {
handler(this, e);
}
}
protected virtual void OnFiltering(ObjectDataSourceFilteringEventArgs e) {
ObjectDataSourceFilteringEventHandler handler = Events[EventFiltering] as ObjectDataSourceFilteringEventHandler;
if (handler != null) {
handler(this, e);
}
}
/// <devdoc>
/// Raises the Inserted event.
/// </devdoc>
protected virtual void OnInserted(ObjectDataSourceStatusEventArgs e) {
ObjectDataSourceStatusEventHandler handler = Events[EventInserted] as ObjectDataSourceStatusEventHandler;
if (handler != null) {
handler(this, e);
}
}
/// <devdoc>
/// Raises the Inserting event.
/// </devdoc>
protected virtual void OnInserting(ObjectDataSourceMethodEventArgs e) {
ObjectDataSourceMethodEventHandler handler = Events[EventInserting] as ObjectDataSourceMethodEventHandler;
if (handler != null) {
handler(this, e);
}
}
/// <devdoc>
/// Raises the ObjectCreated event.
/// </devdoc>
protected virtual void OnObjectCreated(ObjectDataSourceEventArgs e) {
ObjectDataSourceObjectEventHandler handler = Events[EventObjectCreated] as ObjectDataSourceObjectEventHandler;
if (handler != null) {
handler(this, e);
}
}
/// <devdoc>
/// Raises the ObjectCreating event.
/// </devdoc>
protected virtual void OnObjectCreating(ObjectDataSourceEventArgs e) {
ObjectDataSourceObjectEventHandler handler = Events[EventObjectCreating] as ObjectDataSourceObjectEventHandler;
if (handler != null) {
handler(this, e);
}
}
/// <devdoc>
/// Raises the ObjectDisposing event.
/// </devdoc>
protected virtual void OnObjectDisposing(ObjectDataSourceDisposingEventArgs e) {
ObjectDataSourceDisposingEventHandler handler = Events[EventObjectDisposing] as ObjectDataSourceDisposingEventHandler;
if (handler != null) {
handler(this, e);
}
}
/// <devdoc>
/// Raises the Selected event.
/// </devdoc>
protected virtual void OnSelected(ObjectDataSourceStatusEventArgs e) {
ObjectDataSourceStatusEventHandler handler = Events[EventSelected] as ObjectDataSourceStatusEventHandler;
if (handler != null) {
handler(this, e);
}
}
/// <devdoc>
/// Raises the Selecting event.
/// </devdoc>
protected virtual void OnSelecting(ObjectDataSourceSelectingEventArgs e) {
ObjectDataSourceSelectingEventHandler handler = Events[EventSelecting] as ObjectDataSourceSelectingEventHandler;
if (handler != null) {
handler(this, e);
}
}
/// <devdoc>
/// Raises the Updated event.
/// </devdoc>
protected virtual void OnUpdated(ObjectDataSourceStatusEventArgs e) {
ObjectDataSourceStatusEventHandler handler = Events[EventUpdated] as ObjectDataSourceStatusEventHandler;
if (handler != null) {
handler(this, e);
}
}
/// <devdoc>
/// Raises the Updating event.
/// </devdoc>
protected virtual void OnUpdating(ObjectDataSourceMethodEventArgs e) {
ObjectDataSourceMethodEventHandler handler = Events[EventUpdating] as ObjectDataSourceMethodEventHandler;
if (handler != null) {
handler(this, e);
}
}
/// <devdoc>
/// Populates the paging information in the DataSourceSelectArguments and
/// saves the data to cache if necessary.
/// </devdoc>
private void ProcessPagingData(DataSourceSelectArguments arguments, IOrderedDictionary parameters) {
if (arguments.RetrieveTotalRowCount) {
int cachedTotalRowCount = _owner.LoadTotalRowCountFromCache();
if (cachedTotalRowCount >= 0) {
arguments.TotalRowCount = cachedTotalRowCount;
}
else {
// query for row count and then save it in cache
object dummyInstance = null;
cachedTotalRowCount = QueryTotalRowCount(parameters, arguments, true, ref dummyInstance);
arguments.TotalRowCount = cachedTotalRowCount;
_owner.SaveTotalRowCountToCache(cachedTotalRowCount);
}
}
}
/// <devdoc>
/// Executes the SelectCountMethod to retrieve the total row count.
/// </devdoc>
private int QueryTotalRowCount(IOrderedDictionary mergedParameters, DataSourceSelectArguments arguments, bool disposeInstance, ref object instance) {
if (SelectCountMethod.Length > 0) {
ObjectDataSourceSelectingEventArgs eventArgs = new ObjectDataSourceSelectingEventArgs(mergedParameters, arguments, true);
OnSelecting(eventArgs);
if (eventArgs.Cancel) {
return -1;
}
Type type = GetType(TypeName);
Debug.Assert(type != null, "Should not have a null type at this point");
ObjectDataSourceMethod method = GetResolvedMethodData(type, SelectCountMethod, mergedParameters, DataSourceOperation.SelectCount);
ObjectDataSourceResult result = InvokeMethod(method, disposeInstance, ref instance);
if (result.ReturnValue != null && result.ReturnValue is int) {
return (int)result.ReturnValue;
}
}
// Unknown total row count
return -1;
}
private void ReleaseInstance(object instance) {
Debug.Assert(instance != null, "ReleaseInstance: Instance shouldn't be null");
ObjectDataSourceDisposingEventArgs disposingEventArgs = new ObjectDataSourceDisposingEventArgs(instance);
OnObjectDisposing(disposingEventArgs);
// Only call IDisposable.Dispose() if the page developer did not cancel
if (!disposingEventArgs.Cancel) {
// If the object implement IDisposable, call Dispose()
IDisposable disposableObject = instance as IDisposable;
if (disposableObject != null) {
disposableObject.Dispose();
}
}
}
private void SaveDataAndRowCountToCache(DataSourceSelectArguments arguments, object data) {
// Make sure total row count is saved first, since this is the parent key.
// If it's saved after the data, saving the total row count will invalidate
// the data cache.
if (arguments.RetrieveTotalRowCount) {
int totalRowCount = _owner.LoadTotalRowCountFromCache();
if (totalRowCount != arguments.TotalRowCount) {
_owner.SaveTotalRowCountToCache(arguments.TotalRowCount);
}
}
_owner.SaveDataToCache(arguments.StartRowIndex, arguments.MaximumRows, data);
}
/// <devdoc>
/// Saves view state.
/// </devdoc>
protected virtual object SaveViewState() {
Pair myState = new Pair();
myState.First = (_selectParameters != null) ? ((IStateManager)_selectParameters).SaveViewState() : null;
myState.Second = (_filterParameters != null) ? ((IStateManager)_filterParameters).SaveViewState() : null;
if ((myState.First == null) &&
(myState.Second == null)) {
return null;
}
return myState;
}
public IEnumerable Select(DataSourceSelectArguments arguments) {
return ExecuteSelect(arguments);
}
/// <devdoc>
/// Event handler for SelectParametersChanged event.
/// </devdoc>
private void SelectParametersChangedEventHandler(object o, EventArgs e) {
OnDataSourceViewChanged(EventArgs.Empty);
}
/// <devdoc>
/// Starts tracking view state.
/// </devdoc>
protected virtual void TrackViewState() {
_tracking = true;
if (_selectParameters != null) {
((IStateManager)_selectParameters).TrackViewState();
}
if (_filterParameters != null) {
((IStateManager)_filterParameters).TrackViewState();
}
}
private Type TryGetDataObjectType() {
// Load the data object type using BuildManager (do not throw on fail, ignore case)
// We only care about it for Update/Insert/Delete operations since it's not supported for Select
string dataObjectTypeName = DataObjectTypeName;
if (dataObjectTypeName.Length == 0) {
return null;
}
Type dataObjectType = BuildManager.GetType(dataObjectTypeName, false, true);
if (dataObjectType == null) {
// If the type was not found, throw
throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_DataObjectTypeNotFound, _owner.ID));
}
return dataObjectType;
}
public int Update(IDictionary keys, IDictionary values, IDictionary oldValues) {
return ExecuteUpdate(keys, values, oldValues);
}
#region IStateManager implementation
/// <internalonly/>
bool IStateManager.IsTrackingViewState {
get {
return IsTrackingViewState;
}
}
/// <internalonly/>
void IStateManager.LoadViewState(object savedState) {
LoadViewState(savedState);
}
/// <internalonly/>
object IStateManager.SaveViewState() {
return SaveViewState();
}
/// <internalonly/>
void IStateManager.TrackViewState() {
TrackViewState();
}
#endregion
private struct ObjectDataSourceMethod {
internal DataSourceOperation Operation;
internal Type Type;
internal OrderedDictionary Parameters;
internal MethodInfo MethodInfo;
internal ObjectDataSourceMethod(DataSourceOperation operation, Type type, MethodInfo methodInfo, OrderedDictionary parameters) {
Operation = operation;
Type = type;
Parameters = parameters;
MethodInfo = methodInfo;
}
}
private class ObjectDataSourceResult {
internal object ReturnValue;
internal int AffectedRows;
internal ObjectDataSourceResult(object returnValue, int affectedRows) {
ReturnValue = returnValue;
AffectedRows = affectedRows;
}
}
}
}