public SqlDataSourceDataConnectionChooserPanel(SqlDataSourceDesigner sqlDataSourceDesigner, IDataEnvironment dataEnvironment) : base(sqlDataSourceDesigner) { this._sqlDataSourceDesigner = sqlDataSourceDesigner; this._sqlDataSource = (SqlDataSource) this._sqlDataSourceDesigner.Component; this._dataEnvironment = dataEnvironment; this.InitializeComponent(); this.InitializeUI(); DesignerDataConnection conn = new DesignerDataConnection(System.Design.SR.GetString("SqlDataSourceDataConnectionChooserPanel_CustomConnectionName"), this._sqlDataSource.ProviderName, this._sqlDataSource.ConnectionString); ExpressionBinding binding = this._sqlDataSource.Expressions["ConnectionString"]; if ((binding != null) && string.Equals(binding.ExpressionPrefix, "ConnectionStrings", StringComparison.OrdinalIgnoreCase)) { string expression = binding.Expression; string str2 = "." + "ConnectionString".ToLowerInvariant(); if (expression.ToLowerInvariant().EndsWith(str2, StringComparison.Ordinal)) { expression = expression.Substring(0, expression.Length - str2.Length); } ICollection connections = this._dataEnvironment.Connections; if (connections != null) { foreach (DesignerDataConnection connection2 in connections) { if (connection2.IsConfigured && string.Equals(connection2.Name, expression, StringComparison.OrdinalIgnoreCase)) { conn = connection2; break; } } } } this.SetConnectionSettings(conn); }
public SqlDataSourceOrderClause(DesignerDataConnection designerDataConnection, DesignerDataTableBase designerDataTable, System.ComponentModel.Design.Data.DesignerDataColumn designerDataColumn, bool isDescending) { this._designerDataConnection = designerDataConnection; this._designerDataTable = designerDataTable; this._designerDataColumn = designerDataColumn; this._isDescending = isDescending; }
protected override void OnPanelChanging(WizardPanelChangingEventArgs e) { base.OnPanelChanging(e); if (e.CurrentPanel == this._connectionPanel) { this._designerDataConnection = this._connectionPanel.DataConnection; } }
internal static WizardPanel CreateCommandPanel(SqlDataSourceWizardForm wizard, DesignerDataConnection dataConnection, WizardPanel nextPanel) { IDataEnvironment service = null; IServiceProvider site = wizard.SqlDataSourceDesigner.Component.Site; if (site != null) { service = (IDataEnvironment) site.GetService(typeof(IDataEnvironment)); } bool flag = false; if (service != null) { try { IDesignerDataSchema connectionSchema = service.GetConnectionSchema(dataConnection); if (connectionSchema != null) { flag = connectionSchema.SupportsSchemaClass(DesignerDataSchemaClass.Tables); if (flag) { connectionSchema.GetSchemaItems(DesignerDataSchemaClass.Tables); } else { flag = connectionSchema.SupportsSchemaClass(DesignerDataSchemaClass.Views); connectionSchema.GetSchemaItems(DesignerDataSchemaClass.Views); } } } catch (Exception exception) { UIServiceHelper.ShowError(site, exception, System.Design.SR.GetString("SqlDataSourceConnectionPanel_CouldNotGetConnectionSchema")); return null; } } if (nextPanel == null) { if (flag) { return wizard.GetConfigureSelectPanel(); } return CreateCustomCommandPanel(wizard, dataConnection); } if (flag) { if (nextPanel is SqlDataSourceConfigureSelectPanel) { return nextPanel; } return wizard.GetConfigureSelectPanel(); } if (nextPanel is SqlDataSourceCustomCommandPanel) { return nextPanel; } return CreateCustomCommandPanel(wizard, dataConnection); }
public SqlDataSourceFilterClause(DesignerDataConnection designerDataConnection, DesignerDataTableBase designerDataTable, System.ComponentModel.Design.Data.DesignerDataColumn designerDataColumn, string operatorFormat, bool isBinary, string value, System.Web.UI.WebControls.Parameter parameter) { this._designerDataConnection = designerDataConnection; this._designerDataTable = designerDataTable; this._designerDataColumn = designerDataColumn; this._isBinary = isBinary; this._operatorFormat = operatorFormat; this._value = value; this._parameter = parameter; }
protected override void SetProviderName(object instance, DesignerDataConnection connection) { SqlDataSource component = instance as SqlDataSource; if (component != null) { if (connection.IsConfigured) { ExpressionEditor expressionEditor = ExpressionEditor.GetExpressionEditor(typeof(ConnectionStringsExpressionBuilder), component.Site); if (expressionEditor != null) { string expressionPrefix = expressionEditor.ExpressionPrefix; component.Expressions.Add(new ExpressionBinding("ProviderName", typeof(string), expressionPrefix, connection.Name + ".ProviderName")); } } else { TypeDescriptor.GetProperties(component)["ProviderName"].SetValue(component, connection.ProviderName); } } }
public SqlDataSourceQueryEditorForm(IServiceProvider serviceProvider, SqlDataSourceDesigner sqlDataSourceDesigner, string providerName, string connectionString, DataSourceOperation operation, SqlDataSourceCommandType commandType, string command, IList originalParameters) : base(serviceProvider) { this._sqlDataSourceDesigner = sqlDataSourceDesigner; this.InitializeComponent(); this.InitializeUI(); if (string.IsNullOrEmpty(providerName)) { providerName = "System.Data.SqlClient"; } this._dataConnection = new DesignerDataConnection(string.Empty, providerName, connectionString); this._commandType = commandType; this._commandTextBox.Text = command; this._originalParameters = originalParameters; string str = Enum.GetName(typeof(DataSourceOperation), operation).ToUpperInvariant(); this._commandLabel.Text = System.Design.SR.GetString("SqlDataSourceQueryEditorForm_CommandLabel", new object[] { str }); ArrayList dest = new ArrayList(originalParameters.Count); sqlDataSourceDesigner.CopyList(originalParameters, dest); this._parameterEditorUserControl.AddParameters((Parameter[]) dest.ToArray(typeof(Parameter))); this._commandTextBox.Select(0, 0); switch (operation) { case DataSourceOperation.Delete: this._queryBuilderMode = QueryBuilderMode.Delete; return; case DataSourceOperation.Insert: this._queryBuilderMode = QueryBuilderMode.Insert; return; case DataSourceOperation.Select: this._queryBuilderMode = QueryBuilderMode.Select; return; case DataSourceOperation.Update: this._queryBuilderMode = QueryBuilderMode.Update; return; } }
private void SetConnectionSettings(DesignerDataConnection conn) { bool flag = this.SelectConnection(conn); string providerName = conn.ProviderName; string connectionString = conn.ConnectionString; if (!flag && ((providerName.Length > 0) || (connectionString.Length > 0))) { if (providerName.Length == 0) { providerName = "System.Data.SqlClient"; } this._connectionsComboBox.Items.Insert(0, new DataConnectionItem(new DesignerDataConnection(conn.Name, providerName, connectionString))); this._connectionsComboBox.SelectedIndex = 0; this._connectionsComboBox.InvalidateDropDownWidth(); } this._connectionStringTextBox.Text = connectionString; }
public DataConnectionItem(System.ComponentModel.Design.Data.DesignerDataConnection designerDataConnection) { this._designerDataConnection = designerDataConnection; }
private bool SelectConnection(DesignerDataConnection conn) { if (conn.IsConfigured) { foreach (DataConnectionItem item in this._connectionsComboBox.Items) { DesignerDataConnection designerDataConnection = item.DesignerDataConnection; if (designerDataConnection.IsConfigured && (designerDataConnection.Name == conn.Name)) { this._connectionsComboBox.SelectedItem = item; return true; } } } else { foreach (DataConnectionItem item2 in this._connectionsComboBox.Items) { DesignerDataConnection connection2 = item2.DesignerDataConnection; if (!connection2.IsConfigured && SqlDataSourceDesigner.ConnectionsEqual(connection2, conn)) { this._connectionsComboBox.SelectedItem = item2; return true; } } } return false; }
internal static DbConnection GetDesignTimeConnection(IServiceProvider serviceProvider, DesignerDataConnection connection) { if (serviceProvider != null) { IDataEnvironment service = (IDataEnvironment) serviceProvider.GetService(typeof(IDataEnvironment)); if (service != null) { if (string.IsNullOrEmpty(connection.ProviderName)) { connection = new DesignerDataConnection(connection.Name, "System.Data.SqlClient", connection.ConnectionString); } return service.GetDesignTimeConnection(connection); } } return null; }
public SqlDataSourceTableQuery(System.ComponentModel.Design.Data.DesignerDataConnection designerDataConnection, DesignerDataTableBase designerDataTable) { this._designerDataConnection = designerDataConnection; this._designerDataTable = designerDataTable; }
internal static string EscapeObjectName(DesignerDataConnection connection, string objectName) { string str = "["; string str2 = "]"; try { DbProviderFactory dbProviderFactory = SqlDataSourceDesigner.GetDbProviderFactory(connection.ProviderName); DbCommandBuilder builder = dbProviderFactory.CreateCommandBuilder(); if (dbProviderFactory == OracleClientFactory.Instance) { str = str2 = "\""; } builder.QuotePrefix = str; builder.QuoteSuffix = str2; return builder.QuoteIdentifier(objectName); } catch (Exception) { return (str + objectName + str2); } }
private void SaveSchema(DesignerDataConnection connection, string selectCommand, DataTable schemaTable) { base.DesignerState["DataSourceSchema"] = schemaTable; base.DesignerState["DataSourceSchemaConnectionStringHash"] = connection.ConnectionString.GetHashCode(); base.DesignerState["DataSourceSchemaProviderName"] = connection.ProviderName; base.DesignerState["DataSourceSchemaSelectMethod"] = selectCommand; }
public void SetQueries(DesignerDataConnection dataConnection, SqlDataSourceQuery selectQuery, SqlDataSourceQuery insertQuery, SqlDataSourceQuery updateQuery, SqlDataSourceQuery deleteQuery) { this._dataConnection = dataConnection; this._selectQuery = selectQuery; this._insertQuery = insertQuery; this._updateQuery = updateQuery; this._deleteQuery = deleteQuery; this._previewTextBox.Text = this._selectQuery.Command; Parameter[] array = new Parameter[this._selectQuery.Parameters.Count]; this._selectQuery.Parameters.CopyTo(array, 0); Parameter[] parameters = MergeParameters(this._parameterEditorUserControl.GetParameters(), array); this._parameterEditorUserControl.ClearParameters(); this._parameterEditorUserControl.AddParameters(parameters); }
public void Start(IWindowsFormsEditorService edSvc, ICollection connections, DesignerDataConnection currentConnection) { this._edSvc = edSvc; base.Items.Clear(); object obj2 = null; foreach (DesignerDataConnection connection in connections) { DataConnectionItem item = new DataConnectionItem(connection); if ((connection.ConnectionString == currentConnection.ConnectionString) && (connection.IsConfigured == currentConnection.IsConfigured)) { obj2 = item; } base.Items.Add(item); } base.Items.Add(new DataConnectionItem()); base.SelectedItem = obj2; }
protected virtual void SetProviderName(object instance, DesignerDataConnection connection) { }
public SqlDataSourceColumnData(DesignerDataConnection connection, DesignerDataColumn column, StringCollection usedNames) { this._connection = connection; this._column = column; this._usedNames = usedNames; }
public SqlDataSourceColumnData(DesignerDataConnection connection, DesignerDataColumn column) : this(connection, column, null) { }
public void SetConnection(DesignerDataConnection dataConnection) { this._dataConnection = dataConnection; }
protected override void OnVisibleChanged(EventArgs e) { base.OnVisibleChanged(e); if (base.Visible) { base.ParentWizard.FinishButton.Enabled = false; DesignerDataConnection designerDataConnection = ((SqlDataSourceWizardForm) base.ParentWizard).DesignerDataConnection; if (!SqlDataSourceDesigner.ConnectionsEqual(this._dataConnection, designerDataConnection)) { this._dataConnection = designerDataConnection; this._requiresRefresh = true; } if (this._requiresRefresh) { Cursor current = Cursor.Current; try { Cursor.Current = Cursors.WaitCursor; this._tablesComboBox.SelectedIndex = -1; this._tablesComboBox.Items.Clear(); IDataEnvironment dataEnvironment = ((SqlDataSourceWizardForm) base.ParentWizard).DataEnvironment; IDesignerDataSchema connectionSchema = null; if (this._dataConnection != null) { connectionSchema = dataEnvironment.GetConnectionSchema(this._dataConnection); } if (connectionSchema != null) { List<TableItem> list = new List<TableItem>(); if (connectionSchema.SupportsSchemaClass(DesignerDataSchemaClass.Tables)) { ICollection schemaItems = connectionSchema.GetSchemaItems(DesignerDataSchemaClass.Tables); if (schemaItems != null) { foreach (DesignerDataTable table in schemaItems) { if (!table.Name.ToLowerInvariant().StartsWith("AspNet_".ToLowerInvariant(), StringComparison.Ordinal)) { list.Add(new TableItem(table)); } } } } if (connectionSchema.SupportsSchemaClass(DesignerDataSchemaClass.Views)) { ICollection is3 = connectionSchema.GetSchemaItems(DesignerDataSchemaClass.Views); if (is3 != null) { foreach (DesignerDataView view in is3) { list.Add(new TableItem(view)); } } } list.Sort((Comparison<TableItem>) ((a, b) => string.Compare(a.DesignerDataTable.Name, b.DesignerDataTable.Name, StringComparison.InvariantCultureIgnoreCase))); this._tablesComboBox.Items.AddRange(list.ToArray()); this._tablesComboBox.InvalidateDropDownWidth(); } if (this._tablesComboBox.Items.Count > 0) { Hashtable tableQueryState = this._sqlDataSourceDesigner.TableQueryState; bool flag = false; if (tableQueryState != null) { flag = this.LoadTableQueryState(tableQueryState); } if (!flag) { flag = this.LoadParsedSqlState(); } if (!flag) { this._tablesComboBox.SelectedIndex = 0; SqlDataSource component = (SqlDataSource) this._sqlDataSourceDesigner.Component; bool flag2 = (((component.SelectCommand.Trim().Length > 0) || (component.InsertCommand.Trim().Length > 0)) || (component.UpdateCommand.Trim().Length > 0)) || (component.DeleteCommand.Trim().Length > 0); this._tableRadioButton.Checked = !flag2; this._customSqlRadioButton.Checked = flag2; } else { this._tableRadioButton.Checked = true; this._customSqlRadioButton.Checked = false; } this._tableRadioButton.Enabled = true; } else { this._customSqlRadioButton.Checked = true; this._tableRadioButton.Enabled = false; } this.UpdatePreview(); } finally { Cursor.Current = current; } this._requiresRefresh = false; } this.UpdateEnabledUI(); } }
private void OnQueryBuilderButtonClick(object sender, EventArgs e) { IServiceProvider site = this._sqlDataSourceDesigner.Component.Site; if ((this._dataConnection.ConnectionString != null) && (this._dataConnection.ConnectionString.Trim().Length == 0)) { UIServiceHelper.ShowError(site, System.Design.SR.GetString("SqlDataSourceCustomCommandEditor_NoConnectionString")); } else { DesignerDataConnection connection = this._dataConnection; if (string.IsNullOrEmpty(this._dataConnection.ProviderName)) { connection = new DesignerDataConnection(this._dataConnection.Name, "System.Data.SqlClient", this._dataConnection.ConnectionString, this._dataConnection.IsConfigured); } string str = this._dataEnvironment.BuildQuery(this, connection, this._editorMode, this._commandTextBox.Text); if ((str != null) && (str.Length > 0)) { this._commandTextBox.Text = str; this._commandTextBox.Focus(); this._commandTextBox.Select(0, 0); } } }
internal bool RefreshSchema(DesignerDataConnection connection, string commandText, SqlDataSourceCommandType commandType, ParameterCollection parameters, bool preferSilent) { IServiceProvider site = this.SqlDataSource.Site; DbCommand command = null; try { DbProviderFactory dbProviderFactory = GetDbProviderFactory(connection.ProviderName); DbConnection designTimeConnection = GetDesignTimeConnection(base.Component.Site, connection); if (designTimeConnection == null) { if (!preferSilent) { UIServiceHelper.ShowError(this.SqlDataSource.Site, System.Design.SR.GetString("SqlDataSourceDesigner_CouldNotCreateConnection")); } return false; } command = this.BuildSelectCommand(dbProviderFactory, designTimeConnection, commandText, parameters, commandType); DbDataAdapter adapter = CreateDataAdapter(dbProviderFactory, command); adapter.MissingSchemaAction = MissingSchemaAction.AddWithKey; DataSet dataSet = new DataSet(); adapter.FillSchema(dataSet, SchemaType.Source, "DefaultView"); DataTable schemaTable = dataSet.Tables["DefaultView"]; if (schemaTable == null) { if (!preferSilent) { UIServiceHelper.ShowError(site, System.Design.SR.GetString("SqlDataSourceDesigner_CannotGetSchema")); } return false; } this.SaveSchema(connection, commandText, schemaTable); return true; } catch (Exception exception) { if (!preferSilent) { UIServiceHelper.ShowError(site, exception, System.Design.SR.GetString("SqlDataSourceDesigner_CannotGetSchema")); } } finally { if ((command != null) && (command.Connection.State == ConnectionState.Open)) { command.Connection.Close(); } } return false; }
public override void RefreshSchema(bool preferSilent) { try { this.SuppressDataSourceEvents(); bool flag = false; IServiceProvider site = this.SqlDataSource.Site; if (!this.CanRefreshSchema) { if (!preferSilent) { UIServiceHelper.ShowError(site, System.Design.SR.GetString("SqlDataSourceDesigner_RefreshSchemaRequiresSettings")); } } else { IDataSourceViewSchema schema = this.GetView("DefaultView").Schema; bool flag2 = false; if (schema == null) { this._forceSchemaRetrieval = true; schema = this.GetView("DefaultView").Schema; this._forceSchemaRetrieval = false; flag2 = true; } DesignerDataConnection connection = new DesignerDataConnection(string.Empty, this.ProviderName, this.ConnectionString); if (preferSilent) { flag = this.RefreshSchema(connection, this.SelectCommand, this.SqlDataSource.SelectCommandType, this.SqlDataSource.SelectParameters, true); } else { Parameter[] parameterArray = this.InferParameterNames(connection, this.SelectCommand, this.SqlDataSource.SelectCommandType); if (parameterArray == null) { return; } ParameterCollection parameters = new ParameterCollection(); ParameterCollection parameters2 = new ParameterCollection(); foreach (ICloneable cloneable in this.SqlDataSource.SelectParameters) { parameters2.Add((Parameter) cloneable.Clone()); } foreach (Parameter parameter in parameterArray) { if ((parameter.Direction == ParameterDirection.Input) || (parameter.Direction == ParameterDirection.InputOutput)) { Parameter parameter2 = parameters2[parameter.Name]; if (parameter2 != null) { parameter.DefaultValue = parameter2.DefaultValue; if ((parameter.DbType == DbType.Object) && (parameter.Type == TypeCode.Empty)) { parameter.DbType = parameter2.DbType; parameter.Type = parameter2.Type; } parameters2.Remove(parameter2); } parameters.Add(parameter); } } if (parameters.Count > 0) { SqlDataSourceRefreshSchemaForm form = new SqlDataSourceRefreshSchemaForm(site, this, parameters); flag = UIServiceHelper.ShowDialog(site, form) == DialogResult.OK; } else { flag = this.RefreshSchema(connection, this.SelectCommand, this.SqlDataSource.SelectCommandType, parameters, false); } } if (flag) { IDataSourceViewSchema schema2 = this.GetView("DefaultView").Schema; if (flag2 && DataSourceDesigner.ViewSchemasEquivalent(schema, schema2)) { this.OnDataSourceChanged(EventArgs.Empty); } else if (!DataSourceDesigner.ViewSchemasEquivalent(schema, schema2)) { this.OnSchemaRefreshed(EventArgs.Empty); } } } } finally { this.ResumeDataSourceEvents(); } }
internal DataTable LoadSchema() { if (!this._forceSchemaRetrieval) { object obj2 = base.DesignerState["DataSourceSchemaConnectionStringHash"]; string str = base.DesignerState["DataSourceSchemaProviderName"] as string; string a = base.DesignerState["DataSourceSchemaSelectMethod"] as string; if (string.IsNullOrEmpty(str)) { str = "System.Data.SqlClient"; } if (string.IsNullOrEmpty(this.ConnectionString)) { return null; } DesignerDataConnection connection = new DesignerDataConnection(string.Empty, this.ProviderName, this.ConnectionString); int hashCode = connection.ConnectionString.GetHashCode(); string providerName = connection.ProviderName; string selectCommand = this.SelectCommand; if (string.IsNullOrEmpty(providerName)) { providerName = "System.Data.SqlClient"; } if (((obj2 == null) || (((int) obj2) != hashCode)) || (!string.Equals(str, providerName, StringComparison.OrdinalIgnoreCase) || !string.Equals(a, selectCommand, StringComparison.Ordinal))) { return null; } } DataTable table = base.DesignerState["DataSourceSchema"] as DataTable; if (table != null) { table.TableName = "DefaultView"; return table; } return null; }
internal static bool ConnectionsEqual(DesignerDataConnection connection1, DesignerDataConnection connection2) { if ((connection1 == null) || (connection2 == null)) { return false; } if (connection1.ConnectionString != connection2.ConnectionString) { return false; } string str = (connection1.ProviderName.Trim().Length == 0) ? "System.Data.SqlClient" : connection1.ProviderName; string str2 = (connection2.ProviderName.Trim().Length == 0) ? "System.Data.SqlClient" : connection2.ProviderName; return (str == str2); }
protected virtual void SetProviderName (object instance, DesignerDataConnection connection) { throw new NotImplementedException (); }
private void OnNewConnectionButtonClick(object sender, EventArgs e) { DesignerDataConnection conn = this._dataEnvironment.BuildConnection(this, null); if (conn != null) { if (string.Equals(conn.ProviderName, "Microsoft.SqlServerCe.Client.4.0", StringComparison.OrdinalIgnoreCase)) { conn = new DesignerDataConnection(conn.Name, "System.Data.SqlServerCe.4.0", conn.ConnectionString, conn.IsConfigured); } if (!this.SelectConnection(conn)) { DataConnectionItem item = new DataConnectionItem(conn); this._connectionsComboBox.Items.Add(item); this._connectionsComboBox.SelectedItem = item; this._connectionsComboBox.InvalidateDropDownWidth(); } } }
private static WizardPanel CreateCustomCommandPanel(SqlDataSourceWizardForm wizard, DesignerDataConnection dataConnection) { SqlDataSource component = (SqlDataSource) wizard.SqlDataSourceDesigner.Component; ArrayList dest = new ArrayList(); ArrayList list2 = new ArrayList(); ArrayList list3 = new ArrayList(); ArrayList list4 = new ArrayList(); wizard.SqlDataSourceDesigner.CopyList(component.SelectParameters, dest); wizard.SqlDataSourceDesigner.CopyList(component.InsertParameters, list2); wizard.SqlDataSourceDesigner.CopyList(component.UpdateParameters, list3); wizard.SqlDataSourceDesigner.CopyList(component.DeleteParameters, list4); SqlDataSourceCustomCommandPanel customCommandPanel = wizard.GetCustomCommandPanel(); customCommandPanel.SetQueries(dataConnection, new SqlDataSourceQuery(component.SelectCommand, component.SelectCommandType, dest), new SqlDataSourceQuery(component.InsertCommand, component.InsertCommandType, list2), new SqlDataSourceQuery(component.UpdateCommand, component.UpdateCommandType, list3), new SqlDataSourceQuery(component.DeleteCommand, component.DeleteCommandType, list4)); return customCommandPanel; }
protected internal virtual Parameter[] InferParameterNames(DesignerDataConnection connection, string commandText, SqlDataSourceCommandType commandType) { Parameter[] parameterArray2; Cursor current = Cursor.Current; try { Cursor.Current = Cursors.WaitCursor; if (commandText.Length == 0) { UIServiceHelper.ShowError(this.SqlDataSource.Site, System.Design.SR.GetString("SqlDataSourceDesigner_NoCommand")); return null; } if (commandType == SqlDataSourceCommandType.Text) { return SqlDataSourceParameterParser.ParseCommandText(connection.ProviderName, commandText); } DbProviderFactory dbProviderFactory = GetDbProviderFactory(connection.ProviderName); DbConnection designTimeConnection = null; try { designTimeConnection = GetDesignTimeConnection(base.Component.Site, connection); } catch (Exception exception) { if (designTimeConnection == null) { UIServiceHelper.ShowError(this.SqlDataSource.Site, exception, System.Design.SR.GetString("SqlDataSourceDesigner_CouldNotCreateConnection")); return null; } } if (designTimeConnection == null) { UIServiceHelper.ShowError(this.SqlDataSource.Site, System.Design.SR.GetString("SqlDataSourceDesigner_CouldNotCreateConnection")); return null; } DbCommand command = this.BuildSelectCommand(dbProviderFactory, designTimeConnection, commandText, null, commandType); command.CommandType = CommandType.StoredProcedure; try { this.DeriveParameters(connection.ProviderName, command); } catch (Exception exception2) { UIServiceHelper.ShowError(this.SqlDataSource.Site, System.Design.SR.GetString("SqlDataSourceDesigner_InferStoredProcedureError", new object[] { exception2.Message })); return null; } finally { if (command.Connection.State == ConnectionState.Open) { designTimeConnection.Close(); } } int count = command.Parameters.Count; Parameter[] parameterArray = new Parameter[count]; for (int i = 0; i < count; i++) { IDataParameter parameter = command.Parameters[i]; if (parameter != null) { string name = StripParameterPrefix(parameter.ParameterName); parameterArray[i] = CreateParameter(dbProviderFactory, name, parameter.DbType); parameterArray[i].Direction = parameter.Direction; } } parameterArray2 = parameterArray; } finally { Cursor.Current = current; } return parameterArray2; }