Configuration des paramètres et types de données de paramètreConfiguring parameters and parameter data types

Les objets de commande utilisent des paramètres pour passer des valeurs à des instructions SQL ou à des procédures stockées, en fournissant la vérification et la validation des types.Command objects use parameters to pass values to SQL statements or stored procedures, providing type checking and validation. Contrairement au texte de la commande, l'entrée de paramètre est traitée comme une valeur littérale et non pas comme du code exécutable.Unlike command text, parameter input is treated as a literal value, not as executable code. Cela vous permet de vous protéger des attaques « par injection de code SQL », dans lesquelles un attaquant insère une commande qui compromet la sécurité sur le serveur dans une instruction 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.

Les commandes paramétrées améliorent également les performances d'exécution des requêtes car elles permettent au serveur de base de données de faire correspondre la commande entrante avec un plan de requête mis en cache approprié.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. Pour plus d’informations, consultez l’exécution de planifier la mise en cache et réutilisation et paramètres et la réutilisation du Plan d’exécution.For more information, see Execution Plan Caching and Reuse and Parameters and Execution Plan Reuse. Outre les avantages relatifs à la sécurité et aux performances, les commandes paramétrées fournissent une méthode pratique d'organisation des valeurs passées à une source de données.In addition to the security and performance benefits, parameterized commands provide a convenient method for organizing values passed to a data source.

Un objet DbParameter peut être créé à l'aide de son constructeur ou en l'ajoutant à la propriété DbParameterCollection en appelant la méthode Add de la collection 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. La méthode Add prendra comme entrée des arguments de constructeur ou un objet Parameter existant, selon le fournisseur de données.The Add method will take as input either constructor arguments or an existing parameter object, depending on the data provider.

En fournissant la propriété ParameterDirectionSupplying the ParameterDirection property

Lorsque vous ajoutez des paramètres, vous devez fournir une propriété ParameterDirection pour les paramètres autres que les paramètres d'entrée.When adding parameters, you must supply a ParameterDirection property for parameters other than input parameters. Le tableau ci-dessous indique les valeurs ParameterDirection que vous pouvez utiliser avec l'énumération ParameterDirection .The following table shows the ParameterDirection values that you can use with the ParameterDirection enumeration.

Nom de membreMember name DescriptionDescription
Input Le paramètre est un paramètre d'entrée.The parameter is an input parameter. Il s'agit de la valeur par défaut.This is the default.
InputOutput Le paramètre peut être à la fois un paramètre d'entrée et de sortie.The parameter can perform both input and output.
Output Le paramètre est un paramètre de sortie.The parameter is an output parameter.
ReturnValue Le paramètre représente une valeur de retour d'une opération telle qu'une procédure stockée, une fonction intégrée ou une fonction définie par l'utilisateur.The parameter represents a return value from an operation such as a stored procedure, built-in function, or user-defined function.

Utilisation des espaces réservés de paramètreWorking with parameter placeholders

La syntaxe des espaces réservés des paramètres dépend de la source de données.The syntax for parameter placeholders depends on the data source. Les fournisseurs de données .NET Framework gèrent différemment la dénomination et la spécification des paramètres et des espaces réservés de paramètres.The .NET Framework data providers handle naming and specifying parameters and parameter placeholders differently. Cette syntaxe est personnalisée en fonction d'une source de données spécifique, comme le décrit le tableau ci-dessous.This syntax is customized to a specific data source, as described in the following table.

Fournisseur de donnéesData provider Syntaxe d'attribution de noms aux paramètresParameter naming syntax
System.Data.SqlClient Utilise des paramètres nommés au format @nom_paramètre.Uses named parameters in the format @parametername.
System.Data.OleDb Utilise des marqueurs de paramètres positionnels indiqués par un point d'interrogation (?).Uses positional parameter markers indicated by a question mark (?).
System.Data.Odbc Utilise des marqueurs de paramètres positionnels indiqués par un point d'interrogation (?).Uses positional parameter markers indicated by a question mark (?).
System.Data.OracleClient Utilise des paramètres nommés au format :nom_paramètre (ou nom_paramètre).Uses named parameters in the format :parmname (or parmname).

Spécification des types de données de paramètreSpecifying parameter data types

Le type de données d’un paramètre est spécifique au fournisseur de données .NET Framework.The data type of a parameter is specific to the .NET Framework data provider. Spécification du type convertit la valeur de la Parameter pour le type de fournisseur de données .NET Framework avant de passer la valeur à la source de données.Specifying the type converts the value of the Parameter to the .NET Framework data provider type before passing the value to the data source. Vous pouvez également spécifier le type d'un Parameter de façon générique en affectant à la propriété DbType de l'objet Parameter un DbTypeparticulier.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.

Le type de fournisseur de données .NET Framework un Parameter objet est déduit du type .NET Framework de la Value de la Parameter objet, ou à partir de la DbType de la Parameter objet.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. Le tableau suivant indique le type Parameter déduit en fonction de l'objet passé comme valeur Parameter ou du DbTypespécifié.The following table shows the inferred Parameter type based on the object passed as the Parameter value or the specified DbType.

Type .NET Framework.NET Framework type DbTypeDbType SqlDbTypeSqlDbType OleDbTypeOleDbType OdbcTypeOdbcType OracleTypeOracleType
Boolean BooléenBoolean BitBit BooléenBoolean BitBit ByteByte
Byte ByteByte TinyIntTinyInt UnsignedTinyIntUnsignedTinyInt TinyIntTinyInt ByteByte
byte[]byte[] BinaireBinary VarBinary.VarBinary. Cette conversion implicite échouera si le tableau d’octets est supérieur à la taille maximale d’un VarBinary, soit 8 000 octets. Pour des tableaux d’octets supérieurs à 8 000 octets, définissez explicitement le SqlDbType.This implicit conversion will fail if the byte array is larger than the maximum size of a VarBinary, which is 8000 bytes.For byte arrays larger than 8000 bytes, explicitly set the SqlDbType. VarBinaryVarBinary BinaireBinary RawRaw
Char La déduction de SqlDbType à partir de char n'est pas prise en charge.Inferring a SqlDbType from char is not supported. CharChar CharChar ByteByte
DateTime DateTimeDateTime DateTimeDateTime DBTimeStampDBTimeStamp DateTimeDateTime DateTimeDateTime
DateTimeOffset DateTimeOffsetDateTimeOffset DateTimeOffset dans SQL Server 2008.DateTimeOffset in SQL Server 2008. La déduction de SqlDbType à partir de DateTimeOffset n'est pas prise en charge dans les versions de SQL Server antérieures à SQL Server 2008.Inferring a SqlDbType from DateTimeOffset is not supported in versions of SQL Server earlier than SQL Server 2008. DateTimeDateTime
Decimal DecimalDecimal DecimalDecimal DecimalDecimal NumériqueNumeric nombreNumber
Double DoubleDouble FloatFloat DoubleDouble DoubleDouble DoubleDouble
Single SingleSingle RealReal SingleSingle RealReal FloatFloat
Guid GUIDGuid UniqueIdentifierUniqueIdentifier GUIDGuid UniqueIdentifierUniqueIdentifier RawRaw
Int16 Int16Int16 SmallIntSmallInt SmallIntSmallInt SmallIntSmallInt Int16Int16
Int32 Int32Int32 IntInt IntInt IntInt Int32Int32
Int64 Int64Int64 BigIntBigInt BigIntBigInt BigIntBigInt NombreNumber
Object ObjectObject VarianteVariant VarianteVariant La déduction d'OdbcType à partir d'Object n'est pas prise en charge.Inferring an OdbcType from Object is not supported. BlobBlob
String ChaîneString NVarChar.NVarChar. Cette conversion implicite échouera si la chaîne est supérieure à la taille maximale de NVarChar, soit 4 000 caractères.This implicit conversion will fail if the string is larger than the maximum size of an NVarChar, which is 4000 characters. Pour les chaînes supérieures à 4 000 caractères, définissez explicitement SqlDbType.For strings larger than 4000 characters, explicitly set the SqlDbType. VarWCharVarWChar NVarCharNVarChar NVarCharNVarChar
TimeSpan réflexionTime Time dans SQL Server 2008.Time in SQL Server 2008. La déduction de SqlDbType à partir de TimeSpan n'est pas prise en charge dans les versions de SQL Server antérieures à SQL Server 2008.Inferring a SqlDbType from TimeSpan is not supported in versions of SQL Server earlier than SQL Server 2008. DBTimeDBTime réflexionTime DateTimeDateTime
UInt16 UInt16UInt16 La déduction de SqlDbType à partir de UInt16 n'est pas prise en charge.Inferring a SqlDbType from UInt16 is not supported. UnsignedSmallIntUnsignedSmallInt IntInt UInt16UInt16
UInt32 UInt32UInt32 La déduction de SqlDbType à partir de UInt32 n'est pas prise en charge.Inferring a SqlDbType from UInt32 is not supported. UnsignedIntUnsignedInt BigIntBigInt UInt32UInt32
UInt64 UInt64UInt64 La déduction de SqlDbType à partir de UInt64 n'est pas prise en charge.Inferring a SqlDbType from UInt64 is not supported. UnsignedBigIntUnsignedBigInt NumériqueNumeric nombreNumber
AnsiStringAnsiString VarCharVarChar VarCharVarChar VarCharVarChar VarCharVarChar
AnsiStringFixedLengthAnsiStringFixedLength CharChar CharChar CharChar CharChar
DeviseCurrency MoneyMoney DeviseCurrency La déduction d' OdbcType à partir de Currency n'est pas prise en charge.Inferring an OdbcType from Currency is not supported. nombreNumber
DateDate Date dans SQL Server 2008.Date in SQL Server 2008. La déduction de SqlDbType à partir de Date n'est pas prise en charge dans les versions de SQL Server antérieures à SQL Server 2008.Inferring a SqlDbType from Date is not supported in versions of SQL Server earlier than SQL Server 2008. DBDateDBDate DateDate DateTimeDateTime
SByteSByte La déduction de SqlDbType à partir de SByte n'est pas prise en charge.Inferring a SqlDbType from SByte is not supported. TinyIntTinyInt La déduction de OdbcType à partir de SByte n'est pas prise en charge.Inferring an OdbcType from SByte is not supported. SByteSByte
StringFixedLengthStringFixedLength NCharNChar WCharWChar NCharNChar NCharNChar
réflexionTime Time dans SQL Server 2008.Time in SQL Server 2008. La déduction de SqlDbType à partir de Time n'est pas prise en charge dans les versions de SQL Server antérieures à SQL Server 2008.Inferring a SqlDbType from Time is not supported in versions of SQL Server earlier than SQL Server 2008. DBTimeDBTime réflexionTime DateTimeDateTime
VarNumericVarNumeric La déduction de SqlDbType à partir de VarNumeric n'est pas prise en charge.Inferring a SqlDbType from VarNumeric is not supported. VarNumericVarNumeric La déduction de OdbcType à partir de VarNumeric n'est pas prise en charge.Inferring an OdbcType from VarNumeric is not supported. nombreNumber
type défini par l'utilisateur (objet avec SqlUserDefinedAggregateAttribute)user-defined type (an object with SqlUserDefinedAggregateAttribute Objet ou chaîne, selon le fournisseur (SqlClient retourne toujours un objet, ODBC retourne toujours une chaîne et le fournisseur de données managées OleDb l'un ou l'autre)Object or String, depending the provider (SqlClient always returns an Object, Odbc always returns a String, and the OleDb managed data provider can see either SqlDbType.Udt si SqlUserDefinedTypeAttribute est présent, sinon VariantSqlDbType.Udt if SqlUserDefinedTypeAttribute is present, otherwise Variant OleDbType.VarWChar (si la valeur est Null), sinon OleDbType.Variant.OleDbType.VarWChar (if value is null) otherwise OleDbType.Variant. OdbcType.NVarCharOdbcType.NVarChar non pris en chargenot supported

Notes

Les conversions du type decimal vers d'autres types sont des conversions restrictives qui arrondissent la valeur décimale à la valeur entière la plus proche de zéro.Conversions from decimal to other types are narrowing conversions that round the decimal value to the nearest integer value toward zero. Si le résultat de la conversion ne peut pas être représenté dans le type de destination, un OverflowException est levé.If the result of the conversion is not representable in the destination type, an OverflowException is thrown.

Notes

Lorsque vous envoyez une valeur de paramètre null au serveur, vous devez spécifier DBNull, et non null (Nothing en Visual Basic).When you send a null parameter value to the server, you must specify DBNull, not null (Nothing in Visual Basic). Dans le système, la valeur null désigne un objet vide qui ne possède pas de valeur.The null value in the system is an empty object that has no value. DBNull est utilisé pour représenter des valeurs null.DBNull is used to represent null values. Pour plus d’informations sur les valeurs Null de base de données, consultez Handling Null Values.For more information about database nulls, see Handling Null Values.

Dérivation des informations sur les paramètresDeriving parameter information

Les paramètres peuvent aussi être dérivés d'une procédure stockée à l'aide de la classe DbCommandBuilder .Parameters can also be derived from a stored procedure using the DbCommandBuilder class. Les classes SqlCommandBuilder et OleDbCommandBuilder fournissent une méthode statique, DeriveParameters, qui remplit automatiquement la collection de paramètres d'un objet Command qui utilise les informations sur les paramètres provenant d'une procédure stockée.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. Notez que DeriveParameters remplace toutes les informations existantes sur les paramètres pour la commande.Note that DeriveParameters overwrites any existing parameter information for the command.

Notes

La dérivation des informations de paramètre entraîne une baisse des performances car elle requiert un aller-retour supplémentaire vers la source de données pour extraire les informations.Deriving parameter information incurs a performance penalty because it requires an additional round trip to the data source to retrieve the information. Si les informations sur les paramètres sont connues au moment du design, vous pouvez améliorer la performance de votre application en définissant les paramètres de manière explicite.If parameter information is known at design time, you can improve the performance of your application by setting the parameters explicitly.

Pour plus d’informations, consultez générant des commandes avec CommandBuilders.For more information, see Generating Commands with CommandBuilders.

Utilisation de paramètres avec un objet SqlCommand ou une procédure stockéeUsing parameters with a SqlCommand and a stored procedure

Les procédures stockées offrent de nombreux avantages dans les applications pilotées par des données.Stored procedures offer many advantages in data-driven applications. En utilisant les procédures stockées, les opérations de base de données peuvent être encapsulées dans une commande unique, optimisées pour de meilleures performances et améliorées grâce à une sécurité supplémentaire.By using stored procedures, database operations can be encapsulated in a single command, optimized for best performance, and enhanced with additional security. Bien qu’une procédure stockée peut être appelée en passant le nom de procédure stockée suivi d’arguments de paramètre comme instruction SQL, à l’aide de la Parameters collection d’ADO.NET DbCommand objet vous permet de définir plus explicitement de procédure stockée paramètres, ainsi que pour accéder aux paramètres de sortie et valeurs de retour.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.

Notes

Les instructions paramétrées sont exécutées sur le serveur à l'aide de sp_executesql, , ce qui permet la réutilisation des plans de requête.Parameterized statements are executed on the server by using sp_executesql, which allows for query plan reuse. Les curseurs ou variables locaux dans le lot sp_executesql ne sont pas visibles pour le lot qui appelle sp_executesql.Local cursors or variables in the sp_executesql batch are not visible to the batch that calls sp_executesql. Les modifications dans le contexte de la base de données durent uniquement jusqu'à la fin de l'instruction sp_executesql .Changes in database context last only to the end of the sp_executesql statement. Pour plus d’informations, consultez sp_executesql (Transact-SQL).For more information, see sp_executesql (Transact-SQL).

Lorsque vous utilisez des paramètres avec un objet SqlCommand pour exécuter une procédure stockée SQL Server, les noms des paramètres ajoutés à la collection Parameters doivent correspondre à ceux des marqueurs de paramètres dans la procédure stockée.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. Le fournisseur de données .NET Framework pour SQL Server ne prend pas en charge l’espace réservé de point d’interrogation ( ?) pour passer des paramètres à une instruction SQL ou une procédure stockée.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. Il traite les paramètres de la procédure stockée comme des paramètres nommés et recherche les marqueurs de paramètres correspondants.It treats parameters in the stored procedure as named parameters and searches for matching parameter markers. Par exemple, la procédure stockée CustOrderHist est définie à l'aide d'un paramètre nommé @CustomerID.For example, the CustOrderHist stored procedure is defined by using a parameter named @CustomerID. Lorsque votre code exécute la procédure stockée, il doit également utiliser un paramètre nommé @CustomerID.When your code executes the stored procedure, it must also use a parameter named @CustomerID.

CREATE PROCEDURE dbo.CustOrderHist @CustomerID varchar(5)

ExempleExample

Cet exemple montre comment appeler une procédure stockée SQL Server dans l'exemple de base de données Northwind .This example demonstrates how to call a SQL Server stored procedure in the Northwind sample database. Le nom de la procédure stockée est dbo.SalesByCategory et il possède un paramètre d'entrée nommé @CategoryName avec un type de données 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). Le code crée un nouveau SqlConnection à l'intérieur d'un bloc using pour que la connexion soit libérée une fois la procédure terminée.The code creates a new SqlConnection inside a using block so that the connection is disposed when the procedure ends. Les objets SqlCommand et SqlParameter sont créés et leurs propriétés sont définies.The SqlCommand and SqlParameter objects are created, and their properties set. Un SqlDataReader exécute SqlCommand et retourne le jeu de résultats provenant de la procédure stockée, en affichant la sortie dans la fenêtre de console.A SqlDataReader executes the SqlCommand and returns the result set from the stored procedure, displaying the output in the console window.

Notes

Au lieu de créer les objets SqlCommand et SqlParameter puis de définir les propriétés dans des instructions distinctes, vous pouvez choisir d'utiliser l'un des constructeurs surchargés pour définir plusieurs propriétés dans une instruction unique.Instead of creating SqlCommand and SqlParameter objects and then setting properties in separate statements, you can instead elect to use one of the overloaded constructors to set multiple properties in a single statement.

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

Utilisation de paramètres avec OleDbCommand ou OdbcCommandUsing parameters with an OleDbCommand or OdbcCommand

Lorsque vous utilisez des paramètres avec un objet OleDbCommand ou OdbcCommand, l'ordre des paramètres ajoutés à la collection Parameters doit correspondre à celui des paramètres définis dans votre procédure stockée.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. Le fournisseur de données .NET Framework pour OLE DB et le fournisseur de données .NET Framework pour ODBC traitent les paramètres d’une procédure stockée en tant qu’espaces réservés et appliquent des valeurs de paramètre dans l’ordre.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. En outre, les paramètres des valeurs de retour doivent être les premiers paramètres ajoutés à la collection Parameters .In addition, return value parameters must be the first parameters added to the Parameters collection.

Le fournisseur de données .NET Framework pour OLE DB et le fournisseur de données .NET Framework pour ODBC ne gèrent pas les paramètres nommés pour passer des paramètres à une instruction SQL ou une procédure stockée.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. Dans ce cas, vous devez utiliser l'espace réservé de point d'interrogation (?), comme dans l'exemple suivant.In this case, you must use the question mark (?) placeholder, as in the following example.

SELECT * FROM Customers WHERE CustomerID = ?

En conséquence, l'ordre dans lequel les objets Parameter sont ajoutés à la collection Parameters doit directement correspondre à la position de l'espace réservé ?As a result, the order in which Parameter objects are added to the Parameters collection must directly correspond to the position of the ? pour le paramètre.placeholder for the parameter.

Exemple 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;

Exemple 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;

Voir aussiSee also