306 lines
9.9 KiB
C#
306 lines
9.9 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="ParameterCollection.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.ComponentModel.Design;
|
|
using System.Data;
|
|
using System.Drawing.Design;
|
|
using System.Globalization;
|
|
using System.Reflection;
|
|
using System.Web.UI;
|
|
using System.Web.UI.WebControls;
|
|
using System.Web.Util;
|
|
|
|
|
|
/// <devdoc>
|
|
/// A state managed collection of Parameter objects.
|
|
/// These are used in many DataSourceControls to filter queries.
|
|
/// </devdoc>
|
|
[
|
|
Editor("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
|
|
]
|
|
public class ParameterCollection : StateManagedCollection {
|
|
|
|
private EventHandler _parametersChangedHandler;
|
|
|
|
private static readonly Type[] knownTypes = new Type[] {
|
|
typeof(ControlParameter),
|
|
typeof(CookieParameter),
|
|
typeof(FormParameter),
|
|
typeof(Parameter),
|
|
typeof(QueryStringParameter),
|
|
typeof(SessionParameter),
|
|
typeof(ProfileParameter),
|
|
};
|
|
|
|
|
|
/// <devdoc>
|
|
/// Returns the Parameter at a given index.
|
|
/// </devdoc>
|
|
public Parameter this[int index] {
|
|
get {
|
|
return (Parameter)((IList)this)[index];
|
|
}
|
|
set {
|
|
((IList)this)[index] = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Returns the Parameter with a given name.
|
|
/// </devdoc>
|
|
public Parameter this[string name] {
|
|
get {
|
|
int parameterIndex = GetParameterIndex(name);
|
|
if (parameterIndex == -1) {
|
|
return null;
|
|
}
|
|
return this[parameterIndex];
|
|
}
|
|
set {
|
|
int parameterIndex = GetParameterIndex(name);
|
|
if (parameterIndex == -1) {
|
|
Add(value);
|
|
}
|
|
else {
|
|
this[parameterIndex] = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Occurs when any of the Parameter objects in the collection change or when the collection itself changes.
|
|
/// </devdoc>
|
|
public event EventHandler ParametersChanged {
|
|
add {
|
|
_parametersChangedHandler = (EventHandler)Delegate.Combine(_parametersChangedHandler, value);
|
|
}
|
|
remove {
|
|
_parametersChangedHandler = (EventHandler)Delegate.Remove(_parametersChangedHandler, value);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Adds a Parameter to the collection.
|
|
/// </devdoc>
|
|
public int Add(Parameter parameter) {
|
|
return ((IList)this).Add(parameter);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Adds a Parameter to the collection with a specified name and value.
|
|
/// </devdoc>
|
|
public int Add(string name, string value) {
|
|
return ((IList)this).Add(new Parameter(name, TypeCode.Empty, value));
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Adds a Parameter to the collection with a specified name, type, and value.
|
|
/// </devdoc>
|
|
public int Add(string name, TypeCode type, string value) {
|
|
return ((IList)this).Add(new Parameter(name, type, value));
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Adds a Parameter to the collection with a specified name, database type, and value.
|
|
/// </devdoc>
|
|
public int Add(string name, DbType dbType, string value) {
|
|
return ((IList)this).Add(new Parameter(name, dbType, value));
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Used by Parameters to raise the ParametersChanged event.
|
|
/// </devdoc>
|
|
internal void CallOnParametersChanged() {
|
|
OnParametersChanged(EventArgs.Empty);
|
|
}
|
|
|
|
public bool Contains(Parameter parameter) {
|
|
return ((IList)this).Contains(parameter);
|
|
}
|
|
|
|
|
|
public void CopyTo(Parameter[] parameterArray, int index) {
|
|
base.CopyTo(parameterArray, index);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Creates a known type of Parameter.
|
|
/// </devdoc>
|
|
protected override object CreateKnownType(int index) {
|
|
switch (index) {
|
|
case 0:
|
|
return new ControlParameter();
|
|
case 1:
|
|
return new CookieParameter();
|
|
case 2:
|
|
return new FormParameter();
|
|
case 3:
|
|
return new Parameter();
|
|
case 4:
|
|
return new QueryStringParameter();
|
|
case 5:
|
|
return new SessionParameter();
|
|
case 6:
|
|
return new ProfileParameter();
|
|
default:
|
|
throw new ArgumentOutOfRangeException("index");
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Returns an ArrayList of known Parameter types.
|
|
/// </devdoc>
|
|
protected override Type[] GetKnownTypes() {
|
|
return knownTypes;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Returns the index of a parameter by name.
|
|
/// </devdoc>
|
|
private int GetParameterIndex(string name) {
|
|
for (int i = 0; i < Count; i++) {
|
|
if (String.Equals(this[i].Name, name, StringComparison.OrdinalIgnoreCase)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Returns an IDictionary containing Name / Value pairs of all the parameters.
|
|
/// </devdoc>
|
|
public IOrderedDictionary GetValues(HttpContext context, Control control) {
|
|
UpdateValues(context, control);
|
|
|
|
// Create dictionary
|
|
IOrderedDictionary valueDictionary = new OrderedDictionary();
|
|
|
|
// Add Parameters
|
|
foreach (Parameter param in this) {
|
|
// For the OrderedDictionary, every parameter must have a unique name, so in some cases we have to alter them.
|
|
string uniqueName = param.Name;
|
|
int count = 1;
|
|
while (valueDictionary.Contains(uniqueName)) {
|
|
uniqueName = param.Name + count.ToString(CultureInfo.InvariantCulture);
|
|
count++;
|
|
}
|
|
valueDictionary.Add(uniqueName, param.ParameterValue);
|
|
}
|
|
|
|
return valueDictionary;
|
|
}
|
|
|
|
public int IndexOf(Parameter parameter) {
|
|
return ((IList)this).IndexOf(parameter);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Inserts a Parameter into the collection.
|
|
/// </devdoc>
|
|
public void Insert(int index, Parameter parameter) {
|
|
((IList)this).Insert(index, parameter);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Called when the Clear() method is complete.
|
|
/// </devdoc>
|
|
protected override void OnClearComplete() {
|
|
base.OnClearComplete();
|
|
|
|
OnParametersChanged(EventArgs.Empty);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Called when the Insert() method is starting.
|
|
/// Adds an event handler to listen to the Parameter's ParameterChanged event.
|
|
/// </devdoc>
|
|
protected override void OnInsert(int index, object value) {
|
|
base.OnInsert(index, value);
|
|
|
|
// Set owner (we are guaranteed that it is a Parameter
|
|
// in OnValidate).
|
|
((Parameter)value).SetOwner(this);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Called when the Insert() method is complete.
|
|
/// </devdoc>
|
|
protected override void OnInsertComplete(int index, object value) {
|
|
base.OnInsertComplete(index, value);
|
|
|
|
OnParametersChanged(EventArgs.Empty);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Raises the ParametersChanged event.
|
|
/// </devdoc>
|
|
protected virtual void OnParametersChanged(EventArgs e) {
|
|
if (_parametersChangedHandler != null) {
|
|
_parametersChangedHandler(this, e);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Called when the Remove() method is complete.
|
|
/// </devdoc>
|
|
protected override void OnRemoveComplete(int index, object value) {
|
|
base.OnRemoveComplete(index, value);
|
|
|
|
// Clear owner
|
|
((Parameter)value).SetOwner(null);
|
|
|
|
OnParametersChanged(EventArgs.Empty);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Validates that an object is a Parameter.
|
|
/// </devdoc>
|
|
protected override void OnValidate(object o) {
|
|
base.OnValidate(o);
|
|
|
|
if (!(o is Parameter))
|
|
throw new ArgumentException(SR.GetString(SR.ParameterCollection_NotParameter), "o");
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Removes a Parameter from the collection.
|
|
/// </devdoc>
|
|
public void Remove(Parameter parameter) {
|
|
((IList)this).Remove(parameter);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Removes a Parameter from the collection at a given index.
|
|
/// </devdoc>
|
|
public void RemoveAt(int index) {
|
|
((IList)this).RemoveAt(index);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Marks a Parameter as dirty so that it will record its entire state into view state.
|
|
/// </devdoc>
|
|
protected override void SetDirtyObject(object o) {
|
|
((Parameter)o).SetDirty();
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Updates all parameter values to possibly raise a ParametersChanged event.
|
|
/// </devdoc>
|
|
public void UpdateValues(HttpContext context, Control control) {
|
|
foreach (Parameter param in this) {
|
|
param.UpdateValue(context, control);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|