public static bool MergeDictionaries(object dataObjectType, ParameterCollection reference, IDictionary source,
IDictionary destination, IDictionary destinationCopy, IDictionary<string, Exception> validationErrors) {
if (source != null) {
foreach (DictionaryEntry de in source) {
object value = de.Value;
// search for a parameter that corresponds to this dictionary entry.
Parameter referenceParameter = null;
string parameterName = (string)de.Key;
foreach (Parameter p in reference) {
if (String.Equals(p.Name, parameterName, StringComparison.OrdinalIgnoreCase)) {
referenceParameter = p;
break;
}
}
// use the parameter for type conversion, default value and/or converting empty string to null.
if (referenceParameter != null) {
try {
value = referenceParameter.GetValue(value, true);
}
catch (Exception e) {
// catch conversion exceptions so they can be handled. Note that conversion throws various
// types of exceptions like InvalidCastException, FormatException, OverflowException, etc.
validationErrors[referenceParameter.Name] = e;
}
}
// save the value to the merged dictionaries.
destination[parameterName] = value;
if (destinationCopy != null) {
destinationCopy[parameterName] = value;
}
}
}
return validationErrors.Count == 0;
}
public SqlDataSourceRefreshSchemaForm(IServiceProvider serviceProvider, SqlDataSourceDesigner sqlDataSourceDesigner, ParameterCollection parameters) : base(serviceProvider)
{
this._sqlDataSourceDesigner = sqlDataSourceDesigner;
this._sqlDataSource = (SqlDataSource) this._sqlDataSourceDesigner.Component;
this._connectionString = this._sqlDataSourceDesigner.ConnectionString;
this._providerName = this._sqlDataSourceDesigner.ProviderName;
this._selectCommand = this._sqlDataSourceDesigner.SelectCommand;
this._selectCommandType = this._sqlDataSource.SelectCommandType;
this.InitializeComponent();
this.InitializeUI();
Array values = Enum.GetValues(typeof(TypeCode));
Array.Sort(values, new TypeCodeComparer());
foreach (TypeCode code in values)
{
((DataGridViewComboBoxColumn) this._parametersDataGridView.Columns[1]).Items.Add(code);
}
Array array = Enum.GetValues(typeof(DbType));
Array.Sort(array, new DbTypeComparer());
foreach (DbType type in array)
{
((DataGridViewComboBoxColumn) this._parametersDataGridView.Columns[2]).Items.Add(type);
}
ArrayList list = new ArrayList(parameters.Count);
foreach (Parameter parameter in parameters)
{
list.Add(new ParameterItem(parameter));
}
this._parametersDataGridView.DataSource = list;
this._commandTextBox.Text = this._selectCommand;
this._commandTextBox.Select(0, 0);
}
public IList GetTableData (string tableName, DataSourceSelectArguments args, string where, ParameterCollection whereParams)
{
if (String.Compare (tableName, "BazValidationAttributesTable", StringComparison.OrdinalIgnoreCase) == 0)
return BazValidationAttributes;
return null;
}
internal void SetCachedObject (string methodName, ParameterCollection parameters, object o)
{
if (o == null)
return;
string key = GetKeyFromParameters (methodName, parameters);
if (DataCache [key] != null)
DataCache.Remove (key);
DateTime absoluteExpiration = Cache.NoAbsoluteExpiration;
TimeSpan slidindExpiraion = Cache.NoSlidingExpiration;
if (cacheDuration > 0) {
if (cacheExpirationPolicy == DataSourceCacheExpiry.Absolute)
absoluteExpiration = DateTime.Now.AddSeconds (cacheDuration);
else
slidindExpiraion = new TimeSpan (0, 0, cacheDuration);
}
string [] dependencies;
if (cacheKeyDependency.Length > 0)
dependencies = new string [] { cacheKeyDependency };
else
dependencies = new string [] { };
DataCache.Add (key, o, new CacheDependency (new string [] { }, dependencies),
absoluteExpiration, slidindExpiraion, CacheItemPriority.Default, null);
}
/// <summary>
/// This function takes in the query that needs to be executed and returns a data reader as output
/// </summary>
/// <param name="Conn">The SQL Connection to be used</param>
/// <param name="CommType">The Command type whether it is stored procedure or a simple query</param>
/// <param name="CommString">If Stored procedure, then the name of the stored procedure, if simple query, then the query in
/// string format</param>
/// <param name="Parameters">List of parameters, if any required for Stored procedure</param>
/// <returns>SQL Data reader that is the output of the select query executed</returns>
public static SqlDataReader ExecuteDataReader(SqlConnection Conn, CommandType CommType, string CommString, ParameterCollection Parameters)
{
SqlDataReader return_sdr = null;
try
{
SqlCommand comm = new SqlCommand(CommString, Conn);
comm.CommandType = CommType;
if (Parameters != null && Parameters.Count > 0)
{
foreach (Parameter param in Parameters)
{
if (param.DefaultValue == "")
comm.Parameters.AddWithValue(param.Name, DBNull.Value);
else
comm.Parameters.AddWithValue(param.Name, param.DefaultValue);
}
}
if (Conn.State != ConnectionState.Open)
{
Conn.Open();
}
return_sdr = comm.ExecuteReader();
}
catch (SqlException sqx)
{
throw new Exception("SQLException : " + sqx.ErrorCode + Environment.NewLine + "Line Number : " + sqx.LineNumber + " Message : " + sqx.Message + Environment.NewLine + "Stack Trace :" + Environment.NewLine + sqx.StackTrace);
}
catch (Exception exp)
{
throw new Exception("Exception : " + exp.InnerException + Environment.NewLine + " Message : " + exp.Message + Environment.NewLine + "Stack Trace :" + Environment.NewLine + exp.StackTrace);
}
return return_sdr;
}
internal WebControlParameterProxy(Parameter parameter, ParameterCollection parameterCollection, EntityDataSource entityDataSource)
{
Debug.Assert(null != entityDataSource);
_parameter = parameter;
_collection = parameterCollection;
_entityDataSource = entityDataSource;
VerifyUniqueType(_parameter);
}
public static DataSet getfieldAreaTopValue(int id)
{
string sql = "GetFieldAreaTopValue";
ParameterCollection par = new ParameterCollection();
par.Add("@Id", id.ToString());
return SQLDatabaseManager.ExecuteDataSet1(sql, par);
}
Parameter _parameter; // Can be null, that's why this class doesn't subclass Parameter
internal WebControlParameterProxy(string propertyName, ParameterCollection parameterCollection, EntityDataSource entityDataSource)
{
Debug.Assert(null != entityDataSource);
Debug.Assert(!String.IsNullOrEmpty(propertyName));
_parameter = EntityDataSourceUtil.GetParameter(propertyName, parameterCollection);
_collection = parameterCollection;
_entityDataSource = entityDataSource;
VerifyUniqueType(_parameter);
}
public IList GetTableData (string tableName, DataSourceSelectArguments args, string where, ParameterCollection whereParams)
{
if (String.Compare (tableName, "EmployeeTable", StringComparison.OrdinalIgnoreCase) == 0)
return Employees;
if (String.Compare (tableName, "SeasonalEmployeeTable", StringComparison.OrdinalIgnoreCase) == 0)
return SeasonalEmployees;
if (String.Compare (tableName, "BazDataTypeDefaultTypesTable", StringComparison.OrdinalIgnoreCase) == 0)
return DefaultDataTypes;
return null;
}
private void BuildCommand(IConfigurationElement parametersSection, ParameterCollection parameters)
{
parameters.Clear();
foreach (IConfigurationElement parameterElement in parametersSection.Elements.Values)
{
Parameter commandParameter = new Parameter();
foreach (IConfigurationElement propertyElement in parameterElement.Elements.Values)
{
ReflectionServices.SetValue(commandParameter, propertyElement.GetAttributeReference("name").Value.ToString(), propertyElement.GetAttributeReference("value").Value);
}
parameters.Add(commandParameter);
}
}
public IList GetTableData (string tableName, DataSourceSelectArguments args, string where, ParameterCollection whereParams)
{
if (String.Compare (tableName, "AssociatedFooTable", StringComparison.OrdinalIgnoreCase) == 0)
return AssociatedFoo;
if (String.Compare (tableName, "AssociatedBarTable", StringComparison.OrdinalIgnoreCase) == 0)
return AssociatedBar;
if (String.Compare (tableName, "BazWithDataTypeAttributeTable", StringComparison.OrdinalIgnoreCase) == 0)
return BazWithDataTypeAttribute;
return null;
}
public SqlDataSourceParameterValueEditorForm(IServiceProvider serviceProvider, ParameterCollection parameters) : base(serviceProvider)
{
this._parameterItems = new ArrayList();
foreach (Parameter parameter in parameters)
{
this._parameterItems.Add(new ParameterItem(parameter));
}
this.InitializeComponent();
this.InitializeUI();
string[] names = Enum.GetNames(typeof(TypeCode));
Array.Sort<string>(names);
((DataGridViewComboBoxColumn) this._parametersDataGridView.Columns[1]).Items.AddRange(names);
string[] array = Enum.GetNames(typeof(DbType));
Array.Sort<string>(array);
((DataGridViewComboBoxColumn) this._parametersDataGridView.Columns[2]).Items.AddRange(array);
this._parametersDataGridView.DataSource = this._parameterItems;
}
public EntityDataSourceStatementEditorForm(System.Web.UI.Control entityDataSource, IServiceProvider serviceProvider,
bool hasAutoGen, bool isAutoGen, string propertyName, string statementLabelText, string statementAccessibleName,
string helpTopic, string statement, ParameterCollection parameters)
: base(serviceProvider)
{
_entityDataSource = entityDataSource;
InitializeComponent();
InitializeUI(propertyName, statementLabelText, statementAccessibleName);
InitializeTabIndexes();
InitializeAnchors();
_helpTopic = helpTopic;
if (!hasAutoGen)
{
HideCheckBox();
}
_parameters = parameters;
_autoGenerateCheckBox.Checked = isAutoGen;
_statementPanel.Enabled = !isAutoGen;
_statementTextBox.Text = statement;
_statementTextBox.Select(0, 0);
List<Parameter> paramList = new List<Parameter>();
foreach (Parameter p in parameters)
{
paramList.Add(p);
}
_parameterEditorUserControl.AddParameters(paramList.ToArray());
_cachedStatementText = null;
}
public IList GetTableData (string tableName, DataSourceSelectArguments args, string where, ParameterCollection whereParams)
{
return null;
}
// Updates the parameters collection associated with the specified property name
private static void SetParameters(string propertyName, EntityDataSourceDesigner designer, ParameterCollection parameters)
{
switch (propertyName)
{
case "CommandText":
designer.SetCommandParameterContents(parameters);
break;
case "OrderBy":
designer.SetOrderByParameterContents(parameters);
break;
case "Select":
designer.SetSelectParameterContents(parameters);
break;
case "Where":
designer.SetWhereParameterContents(parameters);
break;
default:
Debug.Fail("Unknown property name in EntityDataSourceStatementEditor: " + propertyName);
break;
}
}
internal void SetOwnerCollection (ParameterCollection own)
{
_owner = own;
}
private void @__BuildControl__control2(System.Web.UI.WebControls.ParameterCollection @__ctrl)
{
global::System.Web.UI.WebControls.ControlParameter @__ctrl1;
@__ctrl1 = this.@__BuildControl__control3();
@__ctrl.Add(@__ctrl1);
}
public void RaiseAjaxPostBackEvent(string eventArgument, ParameterCollection extraParams)
{
bool success = true;
string message = null;
object value = null;
try
{
if (eventArgument.IsEmpty())
{
throw new ArgumentNullException("eventArgument");
}
string data = null;
if (this.DirectConfig != null)
{
JToken serviceToken = this.DirectConfig.SelectToken("config.serviceParams");
if (serviceToken != null)
{
data = JSON.ToString(serviceToken);
}
}
switch (eventArgument)
{
case "remotevalidation":
RemoteValidationEventArgs e = new RemoteValidationEventArgs(data, extraParams);
this.RemoteValidation.OnValidation(e);
success = e.Success;
message = e.ErrorMessage;
if (e.ValueIsChanged)
{
value = e.Value;
}
break;
}
}
catch (Exception ex)
{
success = false;
message = this.IsDebugging ? ex.ToString() : ex.Message;
if (this.ResourceManager.RethrowAjaxExceptions)
{
throw;
}
}
ResourceManager.ServiceResponse = new { valid=success, message, value };
}
/// <summary>
/// myself：不用异常处理
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void SearchButton1_Click(object sender, EventArgs e)
{
//try
//{
if (SearchByXH.Text != "")
{
querry += "and [XH]= @XH";
}
if (SearchByNickName.Text != "")
{
querry += "and [User_NickName]=@UNN";
}
if (SearchByName.Text != "")
{
querry += "and [XM]=@XM";
}
if (SearchByQQ.Text != "")
{
querry += "and [User_QQ]=@UQ";
}
if (DropXY.SelectedValue != null)
{
querry += "and [YXSMC]=@XY";
}
if (DropZY.SelectedValue != null)
{
querry += "and [ZYMC]=@ZY";
}
//}
//catch
//{
// Context.Response.Write("<script>alert('出错了!')</script>");
//}
ParameterCollection co = new ParameterCollection();
co.Add("@XH", SearchByXH.Text);
co.Add("@UNN", SearchByNickName.Text);
co.Add("@XM", SearchByName.Text);
co.Add("@UQ", SearchByQQ.Text);
co.Add("@XY", DropXY.SelectedValue);
co.Add("@ZY", DropZY.SelectedValue);
Source1.SelectCommand = querry;
Repeater1.DataSource = Source1;
Repeater1.DataBind();
}
internal void SetOwner(ParameterCollection owner)
{
this._owner = owner;
}
void InitializeParameters (DbCommand command, ParameterCollection parameters, IDictionary values, IDictionary oldValues, bool parametersMayMatchOldValues)
{
IOrderedDictionary parameterValues = parameters.GetValues (context, owner);
foreach (string parameterName in parameterValues.Keys) {
Parameter p = parameters [parameterName];
object value = FindValueByName (parameterName, values, false);
string valueName = parameterName;
if (value == null)
value = FindValueByName (parameterName, oldValues, true);
if (value == null && parametersMayMatchOldValues) {
value = FindValueByName (parameterName, oldValues, false);
valueName = FormatOldParameter (parameterName);
}
if (value != null) {
object dbValue = p.ConvertValue (value);
DbParameter newParameter = CreateDbParameter (valueName, dbValue, p.Direction, p.Size);
if (!command.Parameters.Contains (newParameter.ParameterName)) {
command.Parameters.Add (newParameter);
}
}
else {
command.Parameters.Add (CreateDbParameter (p.Name, parameterValues [parameterName], p.Direction, p.Size));
}
}
if (values != null) {
foreach (DictionaryEntry de in values)
if (!command.Parameters.Contains (ParameterPrefix + (string) de.Key))
command.Parameters.Add (CreateDbParameter ((string) de.Key, de.Value));
}
if (oldValues != null) {
foreach (DictionaryEntry de in oldValues)
if (!command.Parameters.Contains (ParameterPrefix + FormatOldParameter ((string) de.Key)))
command.Parameters.Add (CreateDbParameter (FormatOldParameter ((string) de.Key), de.Value));
}
}
/// <devdoc>
/// Adds parameters to an DbCommand from an IOrderedDictionary.
/// The exclusion list contains parameter names that should not be added
/// to the command's parameter collection.
/// </devdoc>
private void AddParameters(DbCommand command, ParameterCollection reference, IDictionary parameters, IDictionary exclusionList, string oldValuesParameterFormatString) {
Debug.Assert(command != null);
IDictionary caseInsensitiveExclusionList = null;
if (exclusionList != null) {
caseInsensitiveExclusionList = new ListDictionary(StringComparer.OrdinalIgnoreCase);
foreach (DictionaryEntry de in exclusionList) {
caseInsensitiveExclusionList.Add(de.Key, de.Value);
}
}
if (parameters != null) {
string parameterPrefix = ParameterPrefix;
foreach (DictionaryEntry de in parameters) {
string rawParamName = (string)de.Key;
if ((caseInsensitiveExclusionList != null) && (caseInsensitiveExclusionList.Contains(rawParamName))) {
// If we have an exclusion list and it contains this parameter, skip it
continue;
}
string formattedParamName;
if (oldValuesParameterFormatString == null) {
formattedParamName = rawParamName;
}
else {
formattedParamName = String.Format(CultureInfo.InvariantCulture, oldValuesParameterFormatString, rawParamName);
}
object value = de.Value;
// If the reference collection contains this parameter, we will use
// the Parameter's settings to format the value
Parameter parameter = reference[formattedParamName];
if (parameter != null) {
value = parameter.GetValue(de.Value, false);
}
formattedParamName = parameterPrefix + formattedParamName;
if (command.Parameters.Contains(formattedParamName)) {
// We never overwrite an existing value with a null value
if (value != null) {
command.Parameters[formattedParamName].Value = value;
}
}
else {
// Parameter does not exist, add a new one
DbParameter dbParameter = _owner.CreateParameter(formattedParamName, value);
command.Parameters.Add(dbParameter);
}
}
}
}
/// <devdoc>
/// Initializes a DbCommand with parameters from a ParameterCollection.
/// The exclusion list contains parameter names that should not be added
/// to the command's parameter collection.
/// </devdoc>
private void InitializeParameters(DbCommand command, ParameterCollection parameters, IDictionary exclusionList) {
Debug.Assert(command != null);
Debug.Assert(parameters != null);
string parameterPrefix = ParameterPrefix;
IDictionary caseInsensitiveExclusionList = null;
if (exclusionList != null) {
caseInsensitiveExclusionList = new ListDictionary(StringComparer.OrdinalIgnoreCase);
foreach (DictionaryEntry de in exclusionList) {
caseInsensitiveExclusionList.Add(de.Key, de.Value);
}
}
IOrderedDictionary values = parameters.GetValues(_context, _owner);
for (int i = 0; i < parameters.Count; i++) {
Parameter parameter = parameters[i];
if ((caseInsensitiveExclusionList == null) || (!caseInsensitiveExclusionList.Contains(parameter.Name))) {
DbParameter dbParameter = _owner.CreateParameter(parameterPrefix + parameter.Name, values[i]);
dbParameter.Direction = parameter.Direction;
dbParameter.Size = parameter.Size;
if (parameter.DbType != DbType.Object || (parameter.Type != TypeCode.Empty && parameter.Type != TypeCode.DBNull)) {
SqlParameter sqlParameter = dbParameter as SqlParameter;
if (sqlParameter == null) {
dbParameter.DbType = parameter.GetDatabaseType();
}
else {
// In Whidbey, the DbType Date and Time members mapped to SqlDbType.DateTime since there
// were no SqlDbType equivalents. SqlDbType has since been modified to include the new
// Katmai types, including Date and Time. For backwards compatability SqlParameter's DbType
// setter doesn't support Date and Time, so the SqlDbType property should be used instead.
// Other new SqlServer 2008 types (DateTime2, DateTimeOffset) can be set using DbType.
DbType dbType = parameter.GetDatabaseType();
switch (dbType) {
case DbType.Time:
sqlParameter.SqlDbType = SqlDbType.Time;
break;
case DbType.Date:
sqlParameter.SqlDbType = SqlDbType.Date;
break;
default:
dbParameter.DbType = parameter.GetDatabaseType();
break;
}
}
}
command.Parameters.Add(dbParameter);
}
}
}
private static void ApplyParameterCollection(Row row, ParameterCollection parameters)
{
ApplyParameterCollection(row, parameters, null);
}
private static void ApplyParameterCollection(Row row, ParameterCollection parameters, string prefix)
{
if (string.IsNullOrEmpty(prefix))
prefix = "{0}";
foreach (RowCell cell in row.Cells)
{
string value = null;
if (cell.Value != null)
value = cell.Value.ToString();
if (parameters[cell.CellId] == null)
parameters.Add(cell.CellId, row.Columns[cell.CellId].DataType, value);
else
parameters[cell.CellId].DefaultValue = value;
if (parameters[String.Format("@" + prefix, cell.CellId)] == null)
parameters.Add(String.Format("@" + prefix, cell.CellId), row.Columns[cell.CellId].DataType, value);
else
parameters[String.Format("@" + prefix, cell.CellId)].DefaultValue = value;
}
}
void IAjaxPostBackEventHandler.RaiseAjaxPostBackEvent(string eventArgument, ParameterCollection extraParams)
{
string action = eventArgument;
foreach (Task task in this.Tasks)
{
if (!task.DirectEvents.Update.IsDefault && task.DirectEvents.Update.HandlerName == action)
{
task.DirectEvents.Update.OnEvent(new DirectEventArgs(extraParams));
}
}
}
ParameterCollection GetParameterCollection (ref ParameterCollection output, bool propagateTrackViewState, bool subscribeChanged)
{
if (output != null)
return output;
output = new ParameterCollection ();
if (subscribeChanged)
output.ParametersChanged += new EventHandler (ParametersChanged);
if (IsTrackingViewState && propagateTrackViewState)
((IStateManager) output).TrackViewState ();
return output;
}
private void OnOkButtonClick(object sender, EventArgs e)
{
ICollection dataSource = (ICollection) this._parametersDataGridView.DataSource;
ParameterCollection parameters = new ParameterCollection();
foreach (ParameterItem item in dataSource)
{
if (item.DbType == DbType.Object)
{
parameters.Add(new Parameter(item.Name, item.Type, item.DefaultValue));
}
else
{
parameters.Add(new Parameter(item.Name, item.DbType, item.DefaultValue));
}
}
if (this._sqlDataSourceDesigner.RefreshSchema(new DesignerDataConnection(string.Empty, this._providerName, this._connectionString), this._selectCommand, this._selectCommandType, parameters, false))
{
base.DialogResult = DialogResult.OK;
base.Close();
}
}
/// <summary>
///
/// </summary>
/// <param name="eventArgument"></param>
/// <param name="extraParams"></param>
public void RaiseAjaxPostBackEvent(string eventArgument, ParameterCollection extraParams)
{
bool success = true;
string msg = null;
StoreResponseData response = new StoreResponseData(true);
try
{
if (eventArgument.IsEmpty())
{
throw new ArgumentNullException("eventArgument");
}
//string data = null;
//JToken parametersToken = null;
//if (this.DirectConfig != null)
//{
// JToken serviceToken = this.DirectConfig.SelectToken("config.serviceParams", false);
// if (serviceToken != null)
// {
// data = JSON.ToString(serviceToken);
// }
//}
switch (eventArgument)
{
case "read":
if (this.IsBoundUsingDataSourceID)
{
Node bindNode = new Node();
this.DataBindNode(bindNode, extraParams["dataPath"]);
response.Data = bindNode.Children.ToJson();
}
else
{
NodeLoadEventArgs e = new NodeLoadEventArgs(extraParams);
this.OnReadData(e);
NodeCollection nodes = e.Nodes;
success = e.Success;
msg = e.ErrorMessage;
response.Data = nodes != null ? nodes.ToJson() : null;
}
break;
}
}
catch (Exception ex)
{
success = false;
msg = this.IsDebugging ? ex.ToString() : ex.Message;
if (this.ResourceManager.RethrowAjaxExceptions)
{
throw;
}
}
//if (success)
//{
// switch (eventArgument)
// {
// case "read":
// if (this.RequiresDataBinding)
// {
// this.DataBind();
// }
// response.Data = this.GetAjaxDataJson();
// PageProxy dsp = this.Proxy.Primary as PageProxy;
// response.Total = dsp != null ? dsp.Total : -1;
// break;
// }
//}
ResourceManager.ServiceResponse = new Response { Data = response.ToString(), Success = success, Message = msg };
}
public void InitializeParameters(ParameterCollection selectParameters)
{
Parameter[] parameterArray = new Parameter[selectParameters.Count];
selectParameters.CopyTo(parameterArray, 0);
this._parameterEditorUserControl.AddParameters(parameterArray);
}
internal void SetOwnerCollection(ParameterCollection own)
{
_owner = own;
}
/// <summary>
/// Merge the current data item fields with view parameter default values
/// </summary>
/// <param name="viewParams">default parameters</param>
/// <param name="values">new parameters for update and insert</param>
/// <param name="oldValues">old parameters for update and delete</param>
/// <param name="allwaysAddNewValues">true for insert, as current item is
/// irrelevant for insert</param>
/// <returns>merged values</returns>
IOrderedDictionary MergeParameterValues (ParameterCollection viewParams, IDictionary values, IDictionary oldValues)
{
IOrderedDictionary parametersValues = viewParams.GetValues (context, owner);
OrderedDictionary mergedValues = new OrderedDictionary (StringComparer.InvariantCultureIgnoreCase);
foreach (string parameterName in parametersValues.Keys) {
mergedValues [parameterName] = parametersValues [parameterName];
if (oldValues != null) {
object value = FindValueByName (parameterName, oldValues, true);
if (value != null) {
object dataValue = viewParams [parameterName].ConvertValue (value);
mergedValues [parameterName] = dataValue;
}
}
if (values != null) {
object value = FindValueByName (parameterName, values, false);
if (value != null) {
object dataValue = viewParams [parameterName].ConvertValue (value);
mergedValues [parameterName] = dataValue;
}
}
}
if (values != null) {
foreach (DictionaryEntry de in values)
if (FindValueByName ((string) de.Key, mergedValues, false) == null)
mergedValues [de.Key] = de.Value;
}
if (oldValues != null) {
foreach (DictionaryEntry de in oldValues) {
string oldValueKey = FormatOldParameter ((string) de.Key);
if (FindValueByName (oldValueKey, mergedValues, false) == null)
mergedValues [oldValueKey] = de.Value;
}
}
return mergedValues;
}