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
664 lines
22 KiB
C#
664 lines
22 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="Parameter.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;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
|
|
|
|
/// <devdoc>
|
|
/// Represents a parameter to a DataSourceControl.
|
|
/// Parameters can be session variables, web request parameters, or of custom types.
|
|
/// </devdoc>
|
|
[
|
|
DefaultProperty("DefaultValue"),
|
|
]
|
|
public class Parameter : ICloneable, IStateManager {
|
|
|
|
private ParameterCollection _owner;
|
|
private bool _tracking;
|
|
private StateBag _viewState;
|
|
|
|
|
|
|
|
/// <devdoc>
|
|
/// Creates an instance of the Parameter class.
|
|
/// </devdoc>
|
|
public Parameter() {
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Creates an instance of the Parameter class with the specified parameter name.
|
|
/// </devdoc>
|
|
public Parameter(string name) {
|
|
Name = name;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Creates an instance of the Parameter class with the specified parameter name and db type.
|
|
/// </devdoc>
|
|
public Parameter(string name, DbType dbType) {
|
|
Name = name;
|
|
DbType = dbType;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Creates an instance of the Parameter class with the specified parameter name, db type, and default value.
|
|
/// </devdoc>
|
|
public Parameter(string name, DbType dbType, string defaultValue) {
|
|
Name = name;
|
|
DbType = dbType;
|
|
DefaultValue = defaultValue;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Creates an instance of the Parameter class with the specified parameter name and type.
|
|
/// </devdoc>
|
|
public Parameter(string name, TypeCode type) {
|
|
Name = name;
|
|
Type = type;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Creates an instance of the Parameter class with the specified parameter name, type, and default value.
|
|
/// </devdoc>
|
|
public Parameter(string name, TypeCode type, string defaultValue) {
|
|
Name = name;
|
|
Type = type;
|
|
DefaultValue = defaultValue;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Used to clone a parameter.
|
|
/// </devdoc>
|
|
protected Parameter(Parameter original) {
|
|
DefaultValue = original.DefaultValue;
|
|
Direction = original.Direction;
|
|
Name = original.Name;
|
|
ConvertEmptyStringToNull = original.ConvertEmptyStringToNull;
|
|
Size = original.Size;
|
|
Type = original.Type;
|
|
DbType = original.DbType;
|
|
}
|
|
|
|
|
|
|
|
/// <devdoc>
|
|
/// Indicates whether the Parameter is tracking view state.
|
|
/// </devdoc>
|
|
protected bool IsTrackingViewState {
|
|
get {
|
|
return _tracking;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets/sets the db type of the parameter's value.
|
|
/// When DbType is DbType.Object, the Type property will be used instead
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(DbType.Object),
|
|
WebCategory("Parameter"),
|
|
WebSysDescription(SR.Parameter_DbType),
|
|
]
|
|
public DbType DbType {
|
|
get {
|
|
object o = ViewState["DbType"];
|
|
if (o == null)
|
|
return DbType.Object;
|
|
return (DbType)o;
|
|
}
|
|
set {
|
|
if (value < DbType.AnsiString || value > DbType.DateTimeOffset) {
|
|
throw new ArgumentOutOfRangeException("value");
|
|
}
|
|
if (DbType != value) {
|
|
ViewState["DbType"] = value;
|
|
OnParameterChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// The default value to use in GetValue() if it cannot obtain a value.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(null),
|
|
WebCategory("Parameter"),
|
|
WebSysDescription(SR.Parameter_DefaultValue),
|
|
]
|
|
public string DefaultValue {
|
|
get {
|
|
object o = ViewState["DefaultValue"];
|
|
return (o as string);
|
|
}
|
|
set {
|
|
if (DefaultValue != value) {
|
|
ViewState["DefaultValue"] = value;
|
|
OnParameterChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets/sets the direction of the parameter.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(ParameterDirection.Input),
|
|
WebCategory("Parameter"),
|
|
WebSysDescription(SR.Parameter_Direction),
|
|
]
|
|
public ParameterDirection Direction {
|
|
get {
|
|
object o = ViewState["Direction"];
|
|
if (o == null)
|
|
return ParameterDirection.Input;
|
|
return (ParameterDirection)o;
|
|
}
|
|
set {
|
|
if (Direction != value) {
|
|
ViewState["Direction"] = value;
|
|
OnParameterChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets/sets the name of the parameter.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
WebCategory("Parameter"),
|
|
WebSysDescription(SR.Parameter_Name),
|
|
]
|
|
public string Name {
|
|
get {
|
|
object o = ViewState["Name"];
|
|
if (o == null)
|
|
return String.Empty;
|
|
return (string)o;
|
|
}
|
|
set {
|
|
if (Name != value) {
|
|
ViewState["Name"] = value;
|
|
OnParameterChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Returns the value of parameter after converting it to the proper type.
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
]
|
|
internal object ParameterValue {
|
|
get {
|
|
return GetValue(ViewState["ParameterValue"], false);
|
|
}
|
|
}
|
|
|
|
public DbType GetDatabaseType() {
|
|
DbType dbType = DbType;
|
|
if (dbType == DbType.Object) {
|
|
return ConvertTypeCodeToDbType(Type);
|
|
}
|
|
if (Type != TypeCode.Empty) {
|
|
throw new InvalidOperationException(SR.GetString(SR.Parameter_TypeNotSupported, Name));
|
|
}
|
|
return dbType;
|
|
}
|
|
|
|
internal object GetValue(object value, bool ignoreNullableTypeChanges) {
|
|
DbType dbType = DbType;
|
|
if (dbType == DbType.Object) {
|
|
return GetValue(value, DefaultValue, Type, ConvertEmptyStringToNull, ignoreNullableTypeChanges);
|
|
}
|
|
if (Type != TypeCode.Empty) {
|
|
throw new InvalidOperationException(SR.GetString(SR.Parameter_TypeNotSupported, Name));
|
|
}
|
|
return GetValue(value, DefaultValue, dbType, ConvertEmptyStringToNull, ignoreNullableTypeChanges);
|
|
}
|
|
|
|
internal static object GetValue(object value, string defaultValue, DbType dbType, bool convertEmptyStringToNull,
|
|
bool ignoreNullableTypeChanges) {
|
|
|
|
// use the TypeCode conversion logic for Whidbey types.
|
|
if ((dbType != DbType.DateTimeOffset) && (dbType != DbType.Time) && (dbType != DbType.Guid)) {
|
|
TypeCode type = ConvertDbTypeToTypeCode(dbType);
|
|
return GetValue(value, defaultValue, type, convertEmptyStringToNull, ignoreNullableTypeChanges);
|
|
}
|
|
|
|
value = HandleNullValue(value, defaultValue, convertEmptyStringToNull);
|
|
if (value == null) {
|
|
return null;
|
|
}
|
|
|
|
// For ObjectDataSource we special-case Nullable<T> and do nothing because these
|
|
// types will get converted when we actually call the method.
|
|
if (ignoreNullableTypeChanges && IsNullableType(value.GetType())) {
|
|
return value;
|
|
}
|
|
|
|
if (dbType == DbType.DateTimeOffset) {
|
|
if (value is DateTimeOffset) {
|
|
return value;
|
|
}
|
|
return DateTimeOffset.Parse(value.ToString(), CultureInfo.CurrentCulture);
|
|
}
|
|
else if (dbType == DbType.Time) {
|
|
if (value is TimeSpan) {
|
|
return value;
|
|
}
|
|
return TimeSpan.Parse(value.ToString(), CultureInfo.CurrentCulture);
|
|
}
|
|
else if (dbType == DbType.Guid) {
|
|
if (value is Guid) {
|
|
return value;
|
|
}
|
|
return new Guid(value.ToString());
|
|
}
|
|
|
|
Debug.Fail("Should never reach this point.");
|
|
return null;
|
|
}
|
|
|
|
internal static object GetValue(object value, string defaultValue, TypeCode type, bool convertEmptyStringToNull, bool ignoreNullableTypeChanges) {
|
|
// Convert.ChangeType() throws if you attempt to convert to DBNull, so we have to special case it.
|
|
if (type == TypeCode.DBNull) {
|
|
return DBNull.Value;
|
|
}
|
|
|
|
value = HandleNullValue(value, defaultValue, convertEmptyStringToNull);
|
|
if (value == null) {
|
|
return null;
|
|
}
|
|
|
|
if (type == TypeCode.Object || type == TypeCode.Empty) {
|
|
return value;
|
|
}
|
|
|
|
// For ObjectDataSource we special-case Nullable<T> and do nothing because these
|
|
// types will get converted when we actually call the method.
|
|
if (ignoreNullableTypeChanges && IsNullableType(value.GetType())) {
|
|
return value;
|
|
}
|
|
return value = Convert.ChangeType(value, type, CultureInfo.CurrentCulture);;
|
|
}
|
|
|
|
private static object HandleNullValue(object value, string defaultValue, bool convertEmptyStringToNull) {
|
|
// Get the value and convert it to the default value if it is null
|
|
if (convertEmptyStringToNull) {
|
|
string stringValue = value as string;
|
|
if ((stringValue != null) && (stringValue.Length == 0)) {
|
|
value = null;
|
|
}
|
|
}
|
|
if (value == null) {
|
|
// Attempt to use the default value, but if it is null too, just return null immediately
|
|
if (convertEmptyStringToNull && String.IsNullOrEmpty(defaultValue)) {
|
|
defaultValue = null;
|
|
}
|
|
if (defaultValue == null) {
|
|
return null;
|
|
}
|
|
value = defaultValue;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
private static bool IsNullableType(Type type) {
|
|
return type.IsGenericType && (type.GetGenericTypeDefinition() == typeof(Nullable<>));
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Gets/sets the size of the parameter.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(0),
|
|
WebCategory("Parameter"),
|
|
WebSysDescription(SR.Parameter_Size),
|
|
]
|
|
public int Size {
|
|
get {
|
|
object o = ViewState["Size"];
|
|
if (o == null)
|
|
return 0;
|
|
return (int)o;
|
|
}
|
|
set {
|
|
if (Size != value) {
|
|
ViewState["Size"] = value;
|
|
OnParameterChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets/sets the type of the parameter's value.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(TypeCode.Empty),
|
|
WebCategory("Parameter"),
|
|
WebSysDescription(SR.Parameter_Type),
|
|
]
|
|
public TypeCode Type {
|
|
get {
|
|
object o = ViewState["Type"];
|
|
if (o == null)
|
|
return TypeCode.Empty;
|
|
return (TypeCode)o;
|
|
}
|
|
set {
|
|
if (value < TypeCode.Empty || value > TypeCode.String) {
|
|
throw new ArgumentOutOfRangeException("value");
|
|
}
|
|
|
|
if (Type != value) {
|
|
ViewState["Type"] = value;
|
|
OnParameterChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Gets/sets whether an empty string should be treated as a null value. If this property is set to true
|
|
/// and the value is an empty string, the default value will be used.
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(true),
|
|
WebCategory("Parameter"),
|
|
WebSysDescription(SR.Parameter_ConvertEmptyStringToNull),
|
|
]
|
|
public bool ConvertEmptyStringToNull {
|
|
get {
|
|
object o = ViewState["ConvertEmptyStringToNull"];
|
|
if (o == null)
|
|
return true;
|
|
return (bool)o;
|
|
}
|
|
set {
|
|
if (ConvertEmptyStringToNull != value) {
|
|
ViewState["ConvertEmptyStringToNull"] = value;
|
|
OnParameterChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Indicates a dictionary of state information that allows you to save and restore
|
|
/// the state of a Parameter across multiple requests for the same page.
|
|
/// </devdoc>
|
|
[
|
|
Browsable(false),
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
]
|
|
protected StateBag ViewState {
|
|
get {
|
|
if (_viewState == null) {
|
|
_viewState = new StateBag();
|
|
if (_tracking)
|
|
_viewState.TrackViewState();
|
|
}
|
|
|
|
return _viewState;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <devdoc>
|
|
/// Creates a new Parameter that is a copy of this Parameter.
|
|
/// </devdoc>
|
|
protected virtual Parameter Clone() {
|
|
return new Parameter(this);
|
|
}
|
|
|
|
|
|
public static TypeCode ConvertDbTypeToTypeCode(DbType dbType) {
|
|
switch (dbType) {
|
|
case DbType.AnsiString:
|
|
case DbType.AnsiStringFixedLength:
|
|
case DbType.String:
|
|
case DbType.StringFixedLength:
|
|
return TypeCode.String;
|
|
case DbType.Boolean:
|
|
return TypeCode.Boolean;
|
|
case DbType.Byte:
|
|
return TypeCode.Byte;
|
|
case DbType.VarNumeric: // ???
|
|
case DbType.Currency:
|
|
case DbType.Decimal:
|
|
return TypeCode.Decimal;
|
|
case DbType.Date:
|
|
case DbType.DateTime:
|
|
case DbType.DateTime2: // new Katmai type
|
|
case DbType.Time: // new Katmai type - no TypeCode for TimeSpan
|
|
return TypeCode.DateTime;
|
|
case DbType.Double:
|
|
return TypeCode.Double;
|
|
case DbType.Int16:
|
|
return TypeCode.Int16;
|
|
case DbType.Int32:
|
|
return TypeCode.Int32;
|
|
case DbType.Int64:
|
|
return TypeCode.Int64;
|
|
case DbType.SByte:
|
|
return TypeCode.SByte;
|
|
case DbType.Single:
|
|
return TypeCode.Single;
|
|
case DbType.UInt16:
|
|
return TypeCode.UInt16;
|
|
case DbType.UInt32:
|
|
return TypeCode.UInt32;
|
|
case DbType.UInt64:
|
|
return TypeCode.UInt64;
|
|
case DbType.Guid: // ???
|
|
case DbType.Binary:
|
|
case DbType.Object:
|
|
case DbType.DateTimeOffset: // new Katmai type - no TypeCode for DateTimeOffset
|
|
default:
|
|
return TypeCode.Object;
|
|
}
|
|
}
|
|
|
|
|
|
public static DbType ConvertTypeCodeToDbType(TypeCode typeCode) {
|
|
// no TypeCode equivalent for TimeSpan or DateTimeOffset
|
|
switch (typeCode) {
|
|
case TypeCode.Boolean:
|
|
return DbType.Boolean;
|
|
case TypeCode.Byte:
|
|
return DbType.Byte;
|
|
case TypeCode.Char:
|
|
return DbType.StringFixedLength; // ???
|
|
case TypeCode.DateTime: // Used for Date, DateTime and DateTime2 DbTypes
|
|
return DbType.DateTime;
|
|
case TypeCode.Decimal:
|
|
return DbType.Decimal;
|
|
case TypeCode.Double:
|
|
return DbType.Double;
|
|
case TypeCode.Int16:
|
|
return DbType.Int16;
|
|
case TypeCode.Int32:
|
|
return DbType.Int32;
|
|
case TypeCode.Int64:
|
|
return DbType.Int64;
|
|
case TypeCode.SByte:
|
|
return DbType.SByte;
|
|
case TypeCode.Single:
|
|
return DbType.Single;
|
|
case TypeCode.String:
|
|
return DbType.String;
|
|
case TypeCode.UInt16:
|
|
return DbType.UInt16;
|
|
case TypeCode.UInt32:
|
|
return DbType.UInt32;
|
|
case TypeCode.UInt64:
|
|
return DbType.UInt64;
|
|
case TypeCode.DBNull:
|
|
case TypeCode.Empty:
|
|
case TypeCode.Object:
|
|
default:
|
|
return DbType.Object;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Evaluates the parameter and returns the new value.
|
|
/// The control parameter is used to access the page's framework.
|
|
/// By default it returns the null, implying that the DefaultValue will
|
|
/// be the value.
|
|
/// </devdoc>
|
|
protected internal virtual object Evaluate(HttpContext context, Control control) {
|
|
return null;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Loads view state.
|
|
/// </devdoc>
|
|
protected virtual void LoadViewState(object savedState) {
|
|
if (savedState != null) {
|
|
ViewState.LoadViewState(savedState);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Raises the ParameterChanged event. This notifies a listener that it should re-evaluate the value.
|
|
/// </devdoc>
|
|
protected void OnParameterChanged() {
|
|
if (_owner != null) {
|
|
_owner.CallOnParametersChanged();
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Saves view state.
|
|
/// </devdoc>
|
|
protected virtual object SaveViewState() {
|
|
return (_viewState != null) ? _viewState.SaveViewState() : null;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Tells the Parameter to record its entire state into view state.
|
|
/// </devdoc>
|
|
protected internal virtual void SetDirty() {
|
|
ViewState.SetDirty(true);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Tells the Parameter the collection it belongs to
|
|
/// </devdoc>
|
|
internal void SetOwner(ParameterCollection owner) {
|
|
_owner = owner;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Converts the Parameter to a string value.
|
|
/// </devdoc>
|
|
public override string ToString() {
|
|
return this.Name;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Tells the Parameter to start tracking property changes.
|
|
/// </devdoc>
|
|
protected virtual void TrackViewState() {
|
|
_tracking = true;
|
|
|
|
if (_viewState != null) {
|
|
_viewState.TrackViewState();
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Updates the value of parameter.
|
|
/// If the value changed, this will raise the ParametersChanged event of the ParameterCollection it belongs to.
|
|
/// The control parameter is used to access the page's framework.
|
|
/// </devdoc>
|
|
internal void UpdateValue(HttpContext context, Control control) {
|
|
object oldValue = ViewState["ParameterValue"];
|
|
object newValue = Evaluate(context, control);
|
|
|
|
ViewState["ParameterValue"] = newValue;
|
|
|
|
// If you have chains of dependency, like one control with a control parameter on another, and then a third with a control
|
|
// parameter on the second, the order in which the evaluations take place is non-deterministic and may create incorrect
|
|
// evaluation of parameters because all our evaluation happens during LoadComplete. The correct solution is to call DataBind
|
|
// on the third control when the second control's selected value changes. Hacky, but we don't support specifying dependency
|
|
// chains on data sources.
|
|
if ((newValue == null && oldValue != null) || (newValue != null && !newValue.Equals(oldValue))) {
|
|
OnParameterChanged();
|
|
}
|
|
}
|
|
|
|
|
|
#region Implementation of ICloneable
|
|
|
|
/// <internalonly/>
|
|
object ICloneable.Clone() {
|
|
return Clone();
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region Implementation of IStateManager
|
|
|
|
/// <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
|
|
}
|
|
}
|
|
|
|
|