mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
1142 lines
39 KiB
C#
1142 lines
39 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="SqlDataSource.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.UI.WebControls {
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.Data.Common;
|
|
using System.Data.SqlClient;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Drawing;
|
|
using System.Drawing.Design;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
using System.Web;
|
|
using System.Web.Caching;
|
|
using System.Web.UI;
|
|
using System.Web.Util;
|
|
using ConflictOptions = System.Web.UI.ConflictOptions;
|
|
|
|
|
|
/// <devdoc>
|
|
/// This class represents a datasource that uses an ADO.net connection to get
|
|
/// its data.
|
|
/// ADO.net's provider factory model is used to support all managed providers
|
|
/// registered in machine.config.
|
|
/// </devdoc>
|
|
[
|
|
DefaultEvent("Selecting"),
|
|
DefaultProperty("SelectQuery"),
|
|
Designer("System.Web.UI.Design.WebControls.SqlDataSourceDesigner, " + AssemblyRef.SystemDesign),
|
|
ParseChildren(true),
|
|
PersistChildren(false),
|
|
ToolboxBitmap(typeof(SqlDataSource)),
|
|
WebSysDescription(SR.SqlDataSource_Description),
|
|
WebSysDisplayName(SR.SqlDataSource_DisplayName)
|
|
]
|
|
public class SqlDataSource : DataSourceControl {
|
|
|
|
private const string DefaultProviderName = "System.Data.SqlClient";
|
|
private const string DefaultViewName = "DefaultView";
|
|
|
|
private DataSourceCache _cache;
|
|
private string _cachedSelectCommand;
|
|
private string _connectionString;
|
|
private SqlDataSourceMode _dataSourceMode = SqlDataSourceMode.DataSet;
|
|
private string _providerName;
|
|
private DbProviderFactory _providerFactory;
|
|
private SqlDataSourceView _view;
|
|
private ICollection _viewNames;
|
|
|
|
|
|
/// <devdoc>
|
|
/// Creates a new instance of SqlDataSource.
|
|
/// </devdoc>
|
|
public SqlDataSource() {
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Creates a new instance of SqlDataSource with a specified connection string and select command.
|
|
/// </devdoc>
|
|
public SqlDataSource(string connectionString, string selectCommand) {
|
|
_connectionString = connectionString;
|
|
|
|
// Store the select command until the default view is created
|
|
_cachedSelectCommand = selectCommand;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Creates a new instance of SqlDataSource with a specified provider name, connection string, and select command.
|
|
/// </devdoc>
|
|
public SqlDataSource(string providerName, string connectionString, string selectCommand) : this(connectionString, selectCommand) {
|
|
_providerName = providerName;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Specifies the cache settings for this data source. For the cache to
|
|
/// work, the DataSourceMode must be set to DataSet.
|
|
/// </devdoc>
|
|
internal virtual DataSourceCache Cache {
|
|
get {
|
|
if (_cache == null) {
|
|
_cache = new SqlDataSourceCache();
|
|
}
|
|
return _cache;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// The duration, in seconds, of the expiration. The expiration policy is specified by the CacheExpirationPolicy property.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(DataSourceCache.Infinite),
|
|
TypeConverterAttribute(typeof(DataSourceCacheDurationConverter)),
|
|
WebCategory("Cache"),
|
|
WebSysDescription(SR.DataSourceCache_Duration),
|
|
]
|
|
public virtual int CacheDuration {
|
|
get {
|
|
return Cache.Duration;
|
|
}
|
|
set {
|
|
Cache.Duration = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// The expiration policy of the cache. The duration for the expiration is specified by the CacheDuration property.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(DataSourceCacheExpiry.Absolute),
|
|
WebCategory("Cache"),
|
|
WebSysDescription(SR.DataSourceCache_ExpirationPolicy),
|
|
]
|
|
public virtual DataSourceCacheExpiry CacheExpirationPolicy {
|
|
get {
|
|
return Cache.ExpirationPolicy;
|
|
}
|
|
set {
|
|
Cache.ExpirationPolicy = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Indicates an arbitrary cache key to make this cache entry depend on. This allows
|
|
/// the user to further customize when this cache entry will expire.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
WebCategory("Cache"),
|
|
WebSysDescription(SR.DataSourceCache_KeyDependency),
|
|
]
|
|
public virtual string CacheKeyDependency {
|
|
get {
|
|
return Cache.KeyDependency;
|
|
}
|
|
set {
|
|
Cache.KeyDependency = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Indicates whether the Select operation will be cancelled if the value of any of the SelectParameters is null.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(true),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_CancelSelectOnNullParameter),
|
|
]
|
|
public virtual bool CancelSelectOnNullParameter {
|
|
get {
|
|
return GetView().CancelSelectOnNullParameter;
|
|
}
|
|
set {
|
|
GetView().CancelSelectOnNullParameter = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Whether commands pass old values in the parameter collection.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(ConflictOptions.OverwriteChanges),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_ConflictDetection),
|
|
]
|
|
public ConflictOptions ConflictDetection {
|
|
get {
|
|
return GetView().ConflictDetection;
|
|
}
|
|
set {
|
|
GetView().ConflictDetection = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Gets/sets the connection string for the control. This property is not stored in ViewState.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
Editor("System.Web.UI.Design.WebControls.SqlDataSourceConnectionStringEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
WebCategory("Data"),
|
|
MergableProperty(false),
|
|
WebSysDescription(SR.SqlDataSource_ConnectionString),
|
|
]
|
|
public virtual string ConnectionString {
|
|
get {
|
|
return (_connectionString == null ? String.Empty : _connectionString);
|
|
}
|
|
set {
|
|
if (ConnectionString != value) {
|
|
_connectionString = value;
|
|
RaiseDataSourceChangedEvent(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Gets/sets the data source mode for the control.
|
|
/// Only certain operations are supported depending on the data mode.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(SqlDataSourceMode.DataSet),
|
|
WebCategory("Behavior"),
|
|
WebSysDescription(SR.SqlDataSource_DataSourceMode),
|
|
]
|
|
public SqlDataSourceMode DataSourceMode {
|
|
get {
|
|
return _dataSourceMode;
|
|
}
|
|
set {
|
|
if (value < SqlDataSourceMode.DataReader || value > SqlDataSourceMode.DataSet) {
|
|
throw new ArgumentOutOfRangeException(SR.GetString(SR.SqlDataSource_InvalidMode, ID));
|
|
}
|
|
|
|
if (DataSourceMode != value) {
|
|
_dataSourceMode = value;
|
|
RaiseDataSourceChangedEvent(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// The command to execute when Delete() is called on the SqlDataSourceView.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_DeleteCommand),
|
|
]
|
|
public string DeleteCommand {
|
|
get {
|
|
return GetView().DeleteCommand;
|
|
}
|
|
set {
|
|
GetView().DeleteCommand = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// The type of the delete command (command text or stored procedure).
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(SqlDataSourceCommandType.Text),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_DeleteCommandType),
|
|
]
|
|
public SqlDataSourceCommandType DeleteCommandType {
|
|
get {
|
|
return GetView().DeleteCommandType;
|
|
}
|
|
set {
|
|
GetView().DeleteCommandType = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Collection of parameters used in Delete().
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(null),
|
|
Editor("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
MergableProperty(false),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_DeleteParameters),
|
|
]
|
|
public ParameterCollection DeleteParameters {
|
|
get {
|
|
return GetView().DeleteParameters;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Whether caching is enabled for this data source.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(false),
|
|
WebCategory("Cache"),
|
|
WebSysDescription(SR.DataSourceCache_Enabled),
|
|
]
|
|
public virtual bool EnableCaching {
|
|
get {
|
|
return Cache.Enabled;
|
|
}
|
|
set {
|
|
Cache.Enabled = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// The filter to apply when Select() is called on the SqlDataSourceView.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_FilterExpression),
|
|
]
|
|
public string FilterExpression {
|
|
get {
|
|
return GetView().FilterExpression;
|
|
}
|
|
set {
|
|
GetView().FilterExpression = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Collection of parameters used in the FilterExpression property.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(null),
|
|
Editor("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
MergableProperty(false),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_FilterParameters),
|
|
]
|
|
public ParameterCollection FilterParameters {
|
|
get {
|
|
return GetView().FilterParameters;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// The command to execute when Insert() is called on the SqlDataSourceView.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_InsertCommand),
|
|
]
|
|
public string InsertCommand {
|
|
get {
|
|
return GetView().InsertCommand;
|
|
}
|
|
set {
|
|
GetView().InsertCommand = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// The type of the insert command (command text or stored procedure).
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(SqlDataSourceCommandType.Text),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_InsertCommandType),
|
|
]
|
|
public SqlDataSourceCommandType InsertCommandType {
|
|
get {
|
|
return GetView().InsertCommandType;
|
|
}
|
|
set {
|
|
GetView().InsertCommandType = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Collection of values used in Insert().
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(null),
|
|
Editor("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
MergableProperty(false),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_InsertParameters),
|
|
]
|
|
public ParameterCollection InsertParameters {
|
|
get {
|
|
return GetView().InsertParameters;
|
|
}
|
|
}
|
|
|
|
/// <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 {
|
|
return GetView().OldValuesParameterFormatString;
|
|
}
|
|
set {
|
|
GetView().OldValuesParameterFormatString = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets/sets the ADO.net managed provider name.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
TypeConverter("System.Web.UI.Design.WebControls.DataProviderNameConverter, " + AssemblyRef.SystemDesign),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_ProviderName),
|
|
]
|
|
public virtual string ProviderName {
|
|
get {
|
|
return (_providerName == null ? String.Empty : _providerName);
|
|
}
|
|
set {
|
|
if (ProviderName != value) {
|
|
_providerFactory = null;
|
|
_providerName = value;
|
|
RaiseDataSourceChangedEvent(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// The command to execute when Select() is called on the SqlDataSourceView.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_SelectCommand),
|
|
]
|
|
public string SelectCommand {
|
|
get {
|
|
return GetView().SelectCommand;
|
|
}
|
|
set {
|
|
GetView().SelectCommand = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// The type of the select command (command text or stored procedure).
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(SqlDataSourceCommandType.Text),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_SelectCommandType),
|
|
]
|
|
public SqlDataSourceCommandType SelectCommandType {
|
|
get {
|
|
return GetView().SelectCommandType;
|
|
}
|
|
set {
|
|
GetView().SelectCommandType = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// The command to execute when Select is called on the SqlDataSourceView, requesting the total number of rows.
|
|
/// </devdoc>
|
|
/* Commented out until we add paging support back into SqlDataSource
|
|
[
|
|
DefaultValue(""),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_SelectCountCommand),
|
|
]
|
|
public string SelectCountCommand {
|
|
get {
|
|
return GetView().SelectCountCommand;
|
|
}
|
|
set {
|
|
GetView().SelectCountCommand = value;
|
|
}
|
|
}*/
|
|
|
|
|
|
/// <devdoc>
|
|
/// Collection of parameters used in Select().
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(null),
|
|
Editor("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
MergableProperty(false),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_SelectParameters),
|
|
]
|
|
public ParameterCollection SelectParameters {
|
|
get {
|
|
return GetView().SelectParameters;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// The name of the parameter in the SelectCommand that specifies the
|
|
/// sort expression. This parameter's value will be automatically set
|
|
/// at runtime with the appropriate sort expression. This is only
|
|
/// supported for stored procedure commands.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_SortParameterName),
|
|
]
|
|
public string SortParameterName {
|
|
get {
|
|
return GetView().SortParameterName;
|
|
}
|
|
set {
|
|
GetView().SortParameterName = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Gets the SQL data source cache object.
|
|
/// </devdoc>
|
|
private SqlDataSourceCache SqlDataSourceCache {
|
|
get {
|
|
SqlDataSourceCache sqlCache = Cache as SqlDataSourceCache;
|
|
if (sqlCache == null) {
|
|
throw new NotSupportedException(SR.GetString(SR.SqlDataSource_SqlCacheDependencyNotSupported, ID));
|
|
}
|
|
return sqlCache;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// A semi-colon delimited string indicating which databases to use for the dependency in the format "database1:table1;database2:table2".
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
WebCategory("Cache"),
|
|
WebSysDescription(SR.SqlDataSourceCache_SqlCacheDependency),
|
|
]
|
|
public virtual string SqlCacheDependency {
|
|
get {
|
|
return SqlDataSourceCache.SqlCacheDependency;
|
|
|
|
}
|
|
set {
|
|
SqlDataSourceCache.SqlCacheDependency = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// The command to execute when Update() is called on the SqlDataSourceView.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_UpdateCommand),
|
|
]
|
|
public string UpdateCommand {
|
|
get {
|
|
return GetView().UpdateCommand;
|
|
}
|
|
set {
|
|
GetView().UpdateCommand = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// The type of the update command (command text or stored procedure).
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(SqlDataSourceCommandType.Text),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_UpdateCommandType),
|
|
]
|
|
public SqlDataSourceCommandType UpdateCommandType {
|
|
get {
|
|
return GetView().UpdateCommandType;
|
|
}
|
|
set {
|
|
GetView().UpdateCommandType = value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Collection of parameters used in Update().
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(null),
|
|
Editor("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
MergableProperty(false),
|
|
PersistenceMode(PersistenceMode.InnerProperty),
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_UpdateParameters),
|
|
]
|
|
public ParameterCollection UpdateParameters {
|
|
get {
|
|
return GetView().UpdateParameters;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <devdoc>
|
|
/// This event is raised after the Delete operation has completed.
|
|
/// Handle this event if you need to examine the values of output parameters.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.DataSource_Deleted),
|
|
]
|
|
public event SqlDataSourceStatusEventHandler Deleted {
|
|
add {
|
|
GetView().Deleted += value;
|
|
}
|
|
remove {
|
|
GetView().Deleted -= value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// This event is raised before the Delete operation has been executed.
|
|
/// Handle this event if you want to perform additional initialization operations
|
|
/// that are specific to your application. You can also handle this event if you
|
|
/// need to validate the values of parameters or change their values.
|
|
/// When this event is raised, the database connection is not open yet, and you
|
|
/// can cancel the event by setting the Cancel property of the DataCommandEventArgs
|
|
/// to true.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.DataSource_Deleting),
|
|
]
|
|
public event SqlDataSourceCommandEventHandler Deleting {
|
|
add {
|
|
GetView().Deleting += value;
|
|
}
|
|
remove {
|
|
GetView().Deleting -= value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// This event is raised before the Filter operation takes place.
|
|
/// Handle this event if you want to perform validation operations on
|
|
/// the parameter values. This event is only raised if the FilterExpression
|
|
/// is set. If the Cancel property of the event arguments is set to true,
|
|
/// the Select operation is aborted and the operation will return null.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.DataSource_Filtering),
|
|
]
|
|
public event SqlDataSourceFilteringEventHandler Filtering {
|
|
add {
|
|
GetView().Filtering += value;
|
|
}
|
|
remove {
|
|
GetView().Filtering -= value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// This event is raised after the Insert operation has completed.
|
|
/// Handle this event if you need to examine the values of output parameters.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.DataSource_Inserted),
|
|
]
|
|
public event SqlDataSourceStatusEventHandler Inserted {
|
|
add {
|
|
GetView().Inserted += value;
|
|
}
|
|
remove {
|
|
GetView().Inserted -= value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// This event is raised before the Insert operation has been executed.
|
|
/// Handle this event if you want to perform additional initialization operations
|
|
/// that are specific to your application. You can also handle this event if you
|
|
/// need to validate the values of parameters or change their values.
|
|
/// When this event is raised, the database connection is not open yet, and you
|
|
/// can cancel the event by setting the Cancel property of the DataCommandEventArgs
|
|
/// to true.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.DataSource_Inserting),
|
|
]
|
|
public event SqlDataSourceCommandEventHandler Inserting {
|
|
add {
|
|
GetView().Inserting += value;
|
|
}
|
|
remove {
|
|
GetView().Inserting -= value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// This event is raised after the Select operation has completed.
|
|
/// Handle this event if you need to examine the values of output parameters.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_Selected),
|
|
]
|
|
public event SqlDataSourceStatusEventHandler Selected {
|
|
add {
|
|
GetView().Selected += value;
|
|
}
|
|
remove {
|
|
GetView().Selected -= value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// This event is raised before the Select operation has been executed.
|
|
/// Handle this event if you want to perform additional initialization operations
|
|
/// that are specific to your application. You can also handle this event if you
|
|
/// need to validate the values of parameters or change their values.
|
|
/// When this event is raised, the database connection is not open yet, and you
|
|
/// can cancel the event by setting the Cancel property of the DataCommandEventArgs
|
|
/// to true.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.SqlDataSource_Selecting),
|
|
]
|
|
public event SqlDataSourceSelectingEventHandler Selecting {
|
|
add {
|
|
GetView().Selecting += value;
|
|
}
|
|
remove {
|
|
GetView().Selecting -= value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// This event is raised after the Update operation has completed.
|
|
/// Handle this event if you need to examine the values of output parameters.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.DataSource_Updated),
|
|
]
|
|
public event SqlDataSourceStatusEventHandler Updated {
|
|
add {
|
|
GetView().Updated += value;
|
|
}
|
|
remove {
|
|
GetView().Updated -= value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// This event is raised before the Update operation has been executed.
|
|
/// Handle this event if you want to perform additional initialization operations
|
|
/// that are specific to your application. You can also handle this event if you
|
|
/// need to validate the values of parameters or change their values.
|
|
/// When this event is raised, the database connection is not open yet, and you
|
|
/// can cancel the event by setting the Cancel property of the DataCommandEventArgs
|
|
/// to true.
|
|
/// </devdoc>
|
|
[
|
|
WebCategory("Data"),
|
|
WebSysDescription(SR.DataSource_Updating),
|
|
]
|
|
public event SqlDataSourceCommandEventHandler Updating {
|
|
add {
|
|
GetView().Updating += value;
|
|
}
|
|
remove {
|
|
GetView().Updating -= value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Creates a unique cache key for this data source's data.
|
|
/// </devdoc>
|
|
internal string CreateCacheKey(int startRowIndex, int maximumRows) {
|
|
StringBuilder sb = CreateRawCacheKey();
|
|
|
|
sb.Append(startRowIndex.ToString(CultureInfo.InvariantCulture));
|
|
sb.Append(':');
|
|
sb.Append(maximumRows.ToString(CultureInfo.InvariantCulture));
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Creates a DbConnection to the database based on the ProviderName.
|
|
/// </devdoc>
|
|
internal DbConnection CreateConnection(string connectionString) {
|
|
DbProviderFactory factory = GetDbProviderFactorySecure();
|
|
DbConnection connection = factory.CreateConnection();
|
|
connection.ConnectionString = connectionString;
|
|
return connection;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Creates a DbCommand based on the ProviderName.
|
|
/// </devdoc>
|
|
internal DbCommand CreateCommand(string commandText, DbConnection connection) {
|
|
DbProviderFactory factory = GetDbProviderFactorySecure();
|
|
DbCommand command = factory.CreateCommand();
|
|
command.CommandText = commandText;
|
|
command.Connection = connection;
|
|
return command;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Creates an DbDataAdapter based on the ProviderName.
|
|
/// </devdoc>
|
|
internal DbDataAdapter CreateDataAdapter(DbCommand command) {
|
|
DbProviderFactory factory = GetDbProviderFactorySecure();
|
|
DbDataAdapter dataAdapter = factory.CreateDataAdapter();
|
|
dataAdapter.SelectCommand = command;
|
|
return dataAdapter;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Creates a SqlDataSourceView. Derived classes should override this if they need to return
|
|
/// custom view types.
|
|
/// </devdoc>
|
|
protected virtual SqlDataSourceView CreateDataSourceView(string viewName) {
|
|
return new SqlDataSourceView(this, viewName, Context);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Creates the cache key for the master (parent) cache entry, which holds the total row count.
|
|
/// </devdoc>
|
|
internal string CreateMasterCacheKey() {
|
|
return CreateRawCacheKey().ToString();
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Creates an IDataParameter based on the ProviderName.
|
|
/// </devdoc>
|
|
internal DbParameter CreateParameter(string parameterName, object parameterValue) {
|
|
DbProviderFactory factory = GetDbProviderFactorySecure();
|
|
DbParameter parameter = factory.CreateParameter();
|
|
parameter.ParameterName = parameterName;
|
|
parameter.Value = parameterValue;
|
|
return parameter;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Returns the string for the raw master cache key.
|
|
/// </devdoc>
|
|
[SuppressMessage("Microsoft.Usage", "CA2303:FlagTypeGetHashCode", Justification = "This is specifically on SqlDataSource type which is not a com interop type.")]
|
|
private StringBuilder CreateRawCacheKey()
|
|
{
|
|
// Note: The cache key will contain information such as server names and
|
|
// passwords, however it will be stored in the internal cache, which is
|
|
// not accessible to page developers, so it is secure.
|
|
StringBuilder sb = new StringBuilder(CacheInternal.PrefixDataSourceControl, 1024);
|
|
sb.Append(GetType().GetHashCode().ToString(CultureInfo.InvariantCulture));
|
|
|
|
sb.Append(CacheDuration.ToString(CultureInfo.InvariantCulture));
|
|
sb.Append(':');
|
|
sb.Append(((int)CacheExpirationPolicy).ToString(CultureInfo.InvariantCulture));
|
|
|
|
SqlDataSourceCache sqlCache = Cache as SqlDataSourceCache;
|
|
if (sqlCache != null) {
|
|
sb.Append(":");
|
|
sb.Append(sqlCache.SqlCacheDependency);
|
|
}
|
|
|
|
sb.Append(":");
|
|
sb.Append(ConnectionString);
|
|
sb.Append(":");
|
|
sb.Append(SelectCommand);
|
|
//sb.Append(SelectCountCommand);
|
|
|
|
// Append parameter names and values
|
|
if (SelectParameters.Count > 0) {
|
|
sb.Append("?");
|
|
IDictionary parameters = SelectParameters.GetValues(Context, this);
|
|
foreach (DictionaryEntry entry in parameters) {
|
|
sb.Append(entry.Key.ToString());
|
|
if ((entry.Value != null) && (entry.Value != DBNull.Value)) {
|
|
sb.Append("=");
|
|
sb.Append(entry.Value.ToString());
|
|
}
|
|
else {
|
|
if (entry.Value == DBNull.Value) {
|
|
sb.Append("(dbnull)");
|
|
}
|
|
else {
|
|
sb.Append("(null)");
|
|
}
|
|
}
|
|
sb.Append("&");
|
|
}
|
|
}
|
|
return sb;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Deletes rows from the data source using the parameters specified in the DeleteParameters collection.
|
|
/// </devdoc>
|
|
public int Delete() {
|
|
return GetView().Delete(null, null);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Gets the DbProviderFactory associated with the provider type specified in the ProviderName property.
|
|
/// If no provider is specified, the System.Data.SqlClient factory is used.
|
|
/// </devdoc>
|
|
protected virtual DbProviderFactory GetDbProviderFactory() {
|
|
string providerName = ProviderName;
|
|
|
|
// Default to SQL provider
|
|
if (String.IsNullOrEmpty(providerName)) {
|
|
// use DefaultProviderName instance
|
|
return SqlClientFactory.Instance;
|
|
}
|
|
else {
|
|
return DbProviderFactories.GetFactory(providerName);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Gets the DbProviderFactory and performs a security check.
|
|
/// </devdoc>
|
|
private DbProviderFactory GetDbProviderFactorySecure() {
|
|
if (_providerFactory == null) {
|
|
_providerFactory = GetDbProviderFactory();
|
|
|
|
Debug.Assert(_providerFactory != null);
|
|
|
|
if (!HttpRuntime.DisableProcessRequestInApplicationTrust) {
|
|
// Perform security check if we're not running in application trust
|
|
if (!HttpRuntime.ProcessRequestInApplicationTrust && !HttpRuntime.HasDbPermission(_providerFactory)) {
|
|
throw new HttpException(SR.GetString(SR.SqlDataSource_NoDbPermission, _providerFactory.GetType().Name, ID));
|
|
}
|
|
}
|
|
}
|
|
return _providerFactory;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Dynamically creates the default (and only) SqlDataSourceView on demand.
|
|
/// </devdoc>
|
|
private SqlDataSourceView GetView() {
|
|
if (_view == null) {
|
|
_view = CreateDataSourceView(DefaultViewName);
|
|
if (_cachedSelectCommand != null) {
|
|
// If there was a cached select command from the constructor, set it
|
|
_view.SelectCommand = _cachedSelectCommand;
|
|
}
|
|
|
|
if (IsTrackingViewState) {
|
|
((IStateManager)_view).TrackViewState();
|
|
}
|
|
}
|
|
|
|
return _view;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Gets the view associated with this connection.
|
|
/// SqlDataSource only supports a single view, so the viewName parameter is ignored.
|
|
/// </devdoc>
|
|
protected override DataSourceView GetView(string viewName) {
|
|
if (viewName == null || (viewName.Length != 0 && !String.Equals(viewName, DefaultViewName, StringComparison.OrdinalIgnoreCase))) {
|
|
throw new ArgumentException(SR.GetString(SR.DataSource_InvalidViewName, ID, DefaultViewName), "viewName");
|
|
}
|
|
|
|
return GetView();
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Returns an ICollection of the names of all the views. In this case there is only one view called "Table".
|
|
/// </devdoc>
|
|
protected override ICollection GetViewNames() {
|
|
if (_viewNames == null) {
|
|
_viewNames = new string[1] { DefaultViewName };
|
|
}
|
|
return _viewNames;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Inserts a new row with names and values specified the InsertValues collection.
|
|
/// </devdoc>
|
|
public int Insert() {
|
|
return GetView().Insert(null);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Invalidates a cache entry.
|
|
/// </devdoc>
|
|
internal void InvalidateCacheEntry() {
|
|
string key = CreateMasterCacheKey();
|
|
DataSourceCache cache = Cache;
|
|
Debug.Assert(cache != null);
|
|
cache.Invalidate(key);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Event handler for the Page's LoadComplete event.
|
|
/// Updates the parameters' values to possibly raise a DataSourceChanged event, causing bound controls to re-databind.
|
|
/// </devdoc>
|
|
private void LoadCompleteEventHandler(object sender, EventArgs e) {
|
|
SelectParameters.UpdateValues(Context, this);
|
|
FilterParameters.UpdateValues(Context, this);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Loads data from the cache.
|
|
/// </devdoc>
|
|
internal object LoadDataFromCache(int startRowIndex, int maximumRows) {
|
|
string key = CreateCacheKey(startRowIndex, maximumRows);
|
|
return Cache.LoadDataFromCache(key);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Loads data from the cache.
|
|
/// </devdoc>
|
|
internal int LoadTotalRowCountFromCache() {
|
|
string key = CreateMasterCacheKey();
|
|
object data = Cache.LoadDataFromCache(key);
|
|
if (data is int)
|
|
return (int)data;
|
|
return -1;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Loads view state.
|
|
/// </devdoc>
|
|
protected override void LoadViewState(object savedState) {
|
|
Pair myState = (Pair)savedState;
|
|
|
|
if (savedState == null) {
|
|
base.LoadViewState(null);
|
|
}
|
|
else {
|
|
base.LoadViewState(myState.First);
|
|
|
|
if (myState.Second != null) {
|
|
((IStateManager)GetView()).LoadViewState(myState.Second);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Adds LoadComplete event handler to the page.
|
|
/// </devdoc>
|
|
protected internal override void OnInit(EventArgs e) {
|
|
base.OnInit(e);
|
|
|
|
if (Page != null) {
|
|
Page.LoadComplete += new EventHandler(LoadCompleteEventHandler);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Saves paged data to cache, creating a dependency on the updated row count
|
|
/// </devdoc>
|
|
internal virtual void SaveDataToCache(int startRowIndex, int maximumRows, object data, CacheDependency dependency) {
|
|
string key = CreateCacheKey(startRowIndex, maximumRows);
|
|
string parentKey = CreateMasterCacheKey();
|
|
if (Cache.LoadDataFromCache(parentKey) == null) {
|
|
Cache.SaveDataToCache(parentKey, -1, dependency);
|
|
}
|
|
CacheDependency cacheDependency = new CacheDependency(0, new string[0], new string[] {parentKey});
|
|
Cache.SaveDataToCache(key, data, cacheDependency);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Saves the total row count to cache.
|
|
/// </devdoc>
|
|
/*internal virtual void SaveTotalRowCountToCache(int totalRowCount) {
|
|
string key = CreateMasterCacheKey();
|
|
Cache.SaveDataToCache(key, totalRowCount);
|
|
}*/
|
|
|
|
/// <devdoc>
|
|
/// Saves view state.
|
|
/// </devdoc>
|
|
protected override object SaveViewState() {
|
|
Pair myState = new Pair();
|
|
|
|
myState.First = base.SaveViewState();
|
|
|
|
if (_view != null) {
|
|
myState.Second = ((IStateManager)_view).SaveViewState();
|
|
}
|
|
|
|
if ((myState.First == null) &&
|
|
(myState.Second == null)) {
|
|
return null;
|
|
}
|
|
|
|
return myState;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Returns all the rows of the datasource.
|
|
/// Parameters are taken from the Parameters property collection.
|
|
/// If SqlDataSourceMode is set to DataSet then a DataView is returned.
|
|
/// If SqlDataSourceMode is set to DataReader then a DataReader is returned, and it must be closed when done.
|
|
/// </devdoc>
|
|
public IEnumerable Select(DataSourceSelectArguments arguments) {
|
|
return GetView().Select(arguments);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Starts tracking of view state.
|
|
/// </devdoc>
|
|
protected override void TrackViewState() {
|
|
base.TrackViewState();
|
|
|
|
if (_view != null) {
|
|
((IStateManager)_view).TrackViewState();
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Updates rows matching the parameters specified in the UpdateParameters collection with new values specified the UpdateValues collection.
|
|
/// </devdoc>
|
|
public int Update() {
|
|
return GetView().Update(null, null, null);
|
|
}
|
|
}
|
|
}
|
|
|