Configurazione dei parametri e tipi di dati di parametroConfiguring parameters and parameter data types

• 03/30/2017
• 18 minuti per la lettura
• • 
  • 
  • 

Gli oggetti comando usano i parametri per passare valori a istruzioni o stored procedure SQL, fornendo la verifica e la convalida dei tipi.Command objects use parameters to pass values to SQL statements or stored procedures, providing type checking and validation. A differenza del testo dei comandi, l'input dei parametri viene trattato come valore letterale, non come codice eseguibile.Unlike command text, parameter input is treated as a literal value, not as executable code. In questo modo è possibile difendersi da attacchi SQL injection, in cui l'autore di un attacco inserisce un comando che compromette la sicurezza del server in un'istruzione SQL.This helps guard against "SQL injection" attacks, in which an attacker inserts a command that compromises security on the server into an SQL statement.

I comandi con parametri possono anche migliorare le prestazioni di esecuzione delle query in quanto aiutano il server database a ottenere una corrispondenza accurata tra il comando in arrivo e un piano di query memorizzato nella cache appropriato.Parameterized commands can also improve query execution performance, because they help the database server accurately match the incoming command with a proper cached query plan. Per altre informazioni, vedere esecuzione prevede la memorizzazione nella cache e riutilizzo e i parametri e riutilizzo del piano esecuzione.For more information, see Execution Plan Caching and Reuse and Parameters and Execution Plan Reuse. Oltre ai vantaggi in termini di sicurezza e prestazioni, i comandi con parametri offrono un metodo pratico per organizzare i valori passati a un'origine dati.In addition to the security and performance benefits, parameterized commands provide a convenient method for organizing values passed to a data source.

Per creare un oggetto DbParameter , è possibile usare il relativo costruttore o aggiungerlo all'oggetto DbParameterCollection chiamando il metodo Add della raccolta DbParameterCollection .A DbParameter object can be created by using its constructor, or by adding it to the DbParameterCollection by calling the Add method of the DbParameterCollection collection. Il metodo Add accetta come input argomenti del costruttore o un oggetto parametro esistente, a seconda del provider di dati.The Add method will take as input either constructor arguments or an existing parameter object, depending on the data provider.

Specifica della proprietà ParameterDirectionSupplying the ParameterDirection property

Quando si aggiungono parametri, è necessario fornire una proprietà ParameterDirection per i parametri diversi da quelli di input.When adding parameters, you must supply a ParameterDirection property for parameters other than input parameters. La tabella seguente illustra i valori ParameterDirection che è possibile usare con l'enumerazione ParameterDirection .The following table shows the ParameterDirection values that you can use with the ParameterDirection enumeration.

Utilizzo dei segnaposto di parametriWorking with parameter placeholders

La sintassi per i segnaposto dei parametri varia in base all'origine dati.The syntax for parameter placeholders depends on the data source. I provider di dati .NET Framework gestiscono in modo diverso la denominazione e la specifica di parametri e segnaposto di parametri.The .NET Framework data providers handle naming and specifying parameters and parameter placeholders differently. Questa sintassi è personalizzata in base a un'origine dati specifica, come descritto nella tabella seguente.This syntax is customized to a specific data source, as described in the following table.

Specifica dei tipi di dati di parametroSpecifying parameter data types

Il tipo di dati di un parametro è specifico del provider di dati .NET Framework.The data type of a parameter is specific to the .NET Framework data provider. Che specifica il tipo converte il valore della Parameter al tipo di provider di dati .NET Framework prima di passare il valore per l'origine dati.Specifying the type converts the value of the Parameter to the .NET Framework data provider type before passing the value to the data source. È inoltre possibile specificare il tipo di un oggetto Parameter in modo generico impostando la proprietà DbType dell'oggetto Parameter su un determinato oggetto DbType.You may also specify the type of a Parameter in a generic manner by setting the DbType property of the Parameter object to a particular DbType.

Il tipo di provider di dati .NET Framework di un Parameter l'oggetto viene dedotto dal tipo di .NET Framework il Value del Parameter oggetto, o dal DbType del Parameter oggetto.The .NET Framework data provider type of a Parameter object is inferred from the .NET Framework type of the Value of the Parameter object, or from the DbType of the Parameter object. La tabella seguente illustra il tipo Parameter dedotto in base all'oggetto passato come valore di Parameter o all'oggetto DbTypespecificato.The following table shows the inferred Parameter type based on the object passed as the Parameter value or the specified DbType.

Informazioni sui parametriDeriving parameter information

I parametri possono anche essere derivati da una stored procedure usando la classe DbCommandBuilder .Parameters can also be derived from a stored procedure using the DbCommandBuilder class. Le classi SqlCommandBuilder e OleDbCommandBuilder forniscono un metodo statico, DeriveParameters, che popola automaticamente la raccolta di parametri di un oggetto comando con le informazioni provenienti da una stored procedure.Both the SqlCommandBuilder and OleDbCommandBuilder classes provide a static method, DeriveParameters, which automatically populates the parameters collection of a command object that uses parameter information from a stored procedure. Si noti che DeriveParameters sovrascrive qualsiasi informazione esistente sui parametri per il comando.Note that DeriveParameters overwrites any existing parameter information for the command.

Per altre informazioni, vedere generazione di comandi tramite commandbuilders.For more information, see Generating Commands with CommandBuilders.

Utilizzo di parametri con SqlCommand e una stored procedureUsing parameters with a SqlCommand and a stored procedure

Le stored procedure offrono numerosi vantaggi nelle applicazioni guidate dai dati.Stored procedures offer many advantages in data-driven applications. Usando le stored procedure, le operazioni nel database possono essere incapsulate in un unico comando, ottimizzate per migliorare le prestazioni e rese più sicure con funzioni di sicurezza aggiuntive.By using stored procedures, database operations can be encapsulated in a single command, optimized for best performance, and enhanced with additional security. Anche se una stored procedure può essere chiamata passando il nome della stored procedure seguito dagli argomenti dei parametri come istruzione SQL, tramite il Parameters raccolta di ADO.NET DbCommand consente di definire in modo più esplicito stored procedure i parametri e per accedere ai parametri di output e valori restituiti.Although a stored procedure can be called by passing the stored procedure name followed by parameter arguments as an SQL statement, by using the Parameters collection of the ADO.NET DbCommand object enables you to more explicitly define stored procedure parameters, and to access output parameters and return values.

Quando si usano parametri con SqlCommand per eseguire una stored procedure di SQL Server, i nomi dei parametri aggiunti alla raccolta Parameters devono corrispondere ai nomi dei marcatori dei parametri nella stored procedure.When using parameters with a SqlCommand to execute a SQL Server stored procedure, the names of the parameters added to the Parameters collection must match the names of the parameter markers in the stored procedure. Il Provider di dati .NET Framework per SQL Server non supporta il segnaposto punto interrogativo (?) per passare parametri a un'istruzione SQL o una stored procedure.The .NET Framework Data Provider for SQL Server does not support the question mark (?) placeholder for passing parameters to an SQL statement or a stored procedure. I parametri nella stored procedure vengono trattati come parametri denominati e vengono ricercati marcatori di parametri corrispondenti.It treats parameters in the stored procedure as named parameters and searches for matching parameter markers. Ad esempio, la stored procedure CustOrderHist è definita con un parametro denominato @CustomerID.For example, the CustOrderHist stored procedure is defined by using a parameter named @CustomerID. Quando il codice esegue la stored procedure deve usare anche un parametro denominato @CustomerID.When your code executes the stored procedure, it must also use a parameter named @CustomerID.

CREATE PROCEDURE dbo.CustOrderHist @CustomerID varchar(5)

EsempioExample

In questo esempio viene illustrato come chiamare una stored procedure di SQL Server nel database di esempio Northwind .This example demonstrates how to call a SQL Server stored procedure in the Northwind sample database. Il nome della stored procedure è dbo.SalesByCategory e accetta un parametro di input denominato @CategoryName con un tipo di dati nvarchar(15).The name of the stored procedure is dbo.SalesByCategory and it has an input parameter named @CategoryName with a data type of nvarchar(15). Nel codice viene creato un nuovo oggetto SqlConnection all'interno di un blocco using, in modo che la connessione venga eliminata al termine della procedura.The code creates a new SqlConnection inside a using block so that the connection is disposed when the procedure ends. Vengono creati gli oggetti SqlCommand e SqlParameter e vengono impostate le relative proprietà.The SqlCommand and SqlParameter objects are created, and their properties set. Un oggetto SqlDataReader esegue SqlCommand e restituisce il set di risultati dalla stored procedure, visualizzando l'output nella finestra della console.A SqlDataReader executes the SqlCommand and returns the result set from the stored procedure, displaying the output in the console window.

static void GetSalesByCategory(string connectionString,
    string categoryName)
{
    using (SqlConnection connection = new SqlConnection(connectionString))
    {
        // Create the command and set its properties.
        SqlCommand command = new SqlCommand();
        command.Connection = connection;
        command.CommandText = "SalesByCategory";
        command.CommandType = CommandType.StoredProcedure;

        // Add the input parameter and set its properties.
        SqlParameter parameter = new SqlParameter();
        parameter.ParameterName = "@CategoryName";
        parameter.SqlDbType = SqlDbType.NVarChar;
        parameter.Direction = ParameterDirection.Input;
        parameter.Value = categoryName;

        // Add the parameter to the Parameters collection. 
        command.Parameters.Add(parameter);

        // Open the connection and execute the reader.
        connection.Open();
        using (SqlDataReader reader = command.ExecuteReader())
        {
            if (reader.HasRows)
            {
                while (reader.Read())
                {
                    Console.WriteLine("{0}: {1:C}", reader[0], reader[1]);
                }
            }
            else
            {
                Console.WriteLine("No rows found.");
            }
            reader.Close();
        }
    }
}

Shared Sub GetSalesByCategory(ByVal connectionString As String, _
    ByVal categoryName As String)

    Using connection As New SqlConnection(connectionString)

        ' Create the command and set its properties.
        Dim command As SqlCommand = New SqlCommand()
        command.Connection = connection
        command.CommandText = "SalesByCategory"
        command.CommandType = CommandType.StoredProcedure

        ' Add the input parameter and set its properties.
        Dim parameter As New SqlParameter()
        parameter.ParameterName = "@CategoryName"
        parameter.SqlDbType = SqlDbType.NVarChar
        parameter.Direction = ParameterDirection.Input
        parameter.Value = categoryName

        ' Add the parameter to the Parameters collection.
        command.Parameters.Add(parameter)

        ' Open the connection and execute the reader.
        connection.Open()
        Using reader As SqlDataReader = command.ExecuteReader()

            If reader.HasRows Then
                Do While reader.Read()
                    Console.WriteLine("{0}: {1:C}", _
                      reader(0), reader(1))
                Loop
            Else
                Console.WriteLine("No rows returned.")
            End If
        End Using
    End Using
End Sub

Utilizzo di parametri con OleDbCommand o OdbcCommandUsing parameters with an OleDbCommand or OdbcCommand

Quando si usano parametri con OleDbCommand o OdbcCommand, l'ordine dei parametri aggiunti alla raccolta Parameters deve corrispondere all'ordine dei parametri definiti nella stored procedure.When using parameters with an OleDbCommand or OdbcCommand, the order of the parameters added to the Parameters collection must match the order of the parameters defined in your stored procedure. Il Provider di dati .NET Framework per OLE DB e Provider di dati .NET Framework per ODBC i parametri di una stored procedure come segnaposto e applicare i valori dei parametri nell'ordine.The .NET Framework Data Provider for OLE DB and .NET Framework Data Provider for ODBC treat parameters in a stored procedure as placeholders and apply parameter values in order. Inoltre, i parametri dei valori restituiti devono essere i primi parametri aggiunti alla raccolta Parameters .In addition, return value parameters must be the first parameters added to the Parameters collection.

Il Provider di dati .NET Framework per OLE DB e Provider di dati .NET Framework per ODBC non supportano i parametri denominati per passare parametri a un'istruzione SQL o una stored procedure.The .NET Framework Data Provider for OLE DB and .NET Framework Data Provider for ODBC do not support named parameters for passing parameters to an SQL statement or a stored procedure. In questo caso è necessario usare il punto interrogativo (?) come segnaposto, come nell'esempio seguente.In this case, you must use the question mark (?) placeholder, as in the following example.

SELECT * FROM Customers WHERE CustomerID = ?

Di conseguenza, l'ordine in cui vengono aggiunti gli oggetti Parameter alla raccolta Parameters deve corrispondere esattamente alla posizione del segnaposto punto interrogativo (?)As a result, the order in which Parameter objects are added to the Parameters collection must directly correspond to the position of the ? usato per il parametro.placeholder for the parameter.

Esempio di OleDbOleDb Example

Dim command As OleDbCommand = New OleDbCommand( _
  "SampleProc", connection)
command.CommandType = CommandType.StoredProcedure

Dim parameter As OleDbParameter = command.Parameters.Add( _
  "RETURN_VALUE", OleDbType.Integer)
parameter.Direction = ParameterDirection.ReturnValue

parameter = command.Parameters.Add( _
  "@InputParm", OleDbType.VarChar, 12)
parameter.Value = "Sample Value"

parameter = command.Parameters.Add( _
  "@OutputParm", OleDbType.VarChar, 28)
parameter.Direction = ParameterDirection.Output

OleDbCommand command = new OleDbCommand("SampleProc", connection);
command.CommandType = CommandType.StoredProcedure;

OleDbParameter parameter = command.Parameters.Add(
  "RETURN_VALUE", OleDbType.Integer);
parameter.Direction = ParameterDirection.ReturnValue;

parameter = command.Parameters.Add(
  "@InputParm", OleDbType.VarChar, 12);
parameter.Value = "Sample Value";

parameter = command.Parameters.Add(
  "@OutputParm", OleDbType.VarChar, 28);
parameter.Direction = ParameterDirection.Output;

Esempio di OdbcOdbc Example

Dim command As OdbcCommand = New OdbcCommand( _
  "{ ? = CALL SampleProc(?, ?) }", connection)
command.CommandType = CommandType.StoredProcedure

Dim parameter As OdbcParameter = command.Parameters.Add("RETURN_VALUE", OdbcType.Int)
parameter.Direction = ParameterDirection.ReturnValue

parameter = command.Parameters.Add( _
  "@InputParm", OdbcType.VarChar, 12)
parameter.Value = "Sample Value"

parameter = command.Parameters.Add( _
  "@OutputParm", OdbcType.VarChar, 28)
parameter.Direction = ParameterDirection.Output

OdbcCommand command = new OdbcCommand( _
  "{ ? = CALL SampleProc(?, ?) }", connection);
command.CommandType = CommandType.StoredProcedure;

OdbcParameter parameter = command.Parameters.Add( _
  "RETURN_VALUE", OdbcType.Int);
parameter.Direction = ParameterDirection.ReturnValue;

parameter = command.Parameters.Add( _
  "@InputParm", OdbcType.VarChar, 12);
parameter.Value = "Sample Value";

parameter = command.Parameters.Add( _
  "@OutputParm", OdbcType.VarChar, 28);
parameter.Direction = ParameterDirection.Output;

Vedere ancheSee also

• Comandi e parametriCommands and Parameters
• Parametri DataAdapterDataAdapter Parameters
• Mapping dei tipi di dati in ADO.NETData Type Mappings in ADO.NET
• Panoramica di ADO.NETADO.NET Overview