Configurar parámetros y tipos de datos de parámetroConfiguring parameters and parameter data types

Los objetos de comando usan parámetros para pasar valores a instrucciones SQL o procedimientos almacenados que permiten realizar operaciones de comprobación de tipos y validación.Command objects use parameters to pass values to SQL statements or stored procedures, providing type checking and validation. A diferencia del texto de comando, la entrada de parámetros se trata como un valor literal, y no como código ejecutable.Unlike command text, parameter input is treated as a literal value, not as executable code. De esta forma, se protege contra ataques por "inyección de código SQL", en los que un atacante inserta un comando que pone en peligro la seguridad del servidor en una instrucción 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.

Los comandos parametrizados también pueden mejorar el rendimiento de ejecución de la consulta, ya que ayudan al servidor de bases de datos a que haga coincidir precisamente el comando entrante con un plan de consulta almacenado en caché adecuado.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. Para obtener más información, consulte Plan de almacenamiento en caché en ejecución y volver a utilizar y parámetros y reutilización de Plan de ejecución.For more information, see Execution Plan Caching and Reuse and Parameters and Execution Plan Reuse. Además de las ventajas en la seguridad y el rendimiento, los comandos con parámetros proporcionan un método práctico para organizar los valores que se pasan a un origen de datos.In addition to the security and performance benefits, parameterized commands provide a convenient method for organizing values passed to a data source.

Para crear un objeto DbParameter , se puede usar su constructor o bien se puede agregar a DbParameterCollection mediante una llamada al método Add de la colección 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. El método Add acepta como entrada argumentos del constructor o cualquier objeto de parámetro ya existente, en función del proveedor de datos.The Add method will take as input either constructor arguments or an existing parameter object, depending on the data provider.

Proporcionar la propiedad ParameterDirectionSupplying the ParameterDirection property

Cuando se agregan parámetros distintos de los parámetros de entrada, se debe proporcionar una propiedad ParameterDirection .When adding parameters, you must supply a ParameterDirection property for parameters other than input parameters. En la tabla siguiente se muestran los valores de ParameterDirection que se pueden usar con la enumeración ParameterDirection .The following table shows the ParameterDirection values that you can use with the ParameterDirection enumeration.

Nombre de miembroMember name DescripciónDescription
Input Se trata de un parámetro de entrada.The parameter is an input parameter. Este es el valor predeterminado.This is the default.
InputOutput El parámetro se puede comportar tanto de entrada como de salida.The parameter can perform both input and output.
Output Se trata de un parámetro de salida.The parameter is an output parameter.
ReturnValue El parámetro representa un valor devuelto de una operación como, por ejemplo, un procedimiento almacenado, una función integrada o una función definida por el usuario.The parameter represents a return value from an operation such as a stored procedure, built-in function, or user-defined function.

Trabajar con los marcadores de posiciónWorking with parameter placeholders

La sintaxis de los marcadores de posición de parámetros depende del origen de datos.The syntax for parameter placeholders depends on the data source. Los proveedores de datos .NET Framework administran la asignación de nombres y la especificación de parámetros y marcadores de posición de parámetros de diferente forma.The .NET Framework data providers handle naming and specifying parameters and parameter placeholders differently. Esta sintaxis se personaliza para un origen de datos específico, como se describe en la tabla siguiente.This syntax is customized to a specific data source, as described in the following table.

Proveedor de datosData provider Sintaxis de nomenclatura de parámetrosParameter naming syntax
System.Data.SqlClient Usa parámetros con nombre, con el formato @nombreDeParámetro.Uses named parameters in the format @parametername.
System.Data.OleDb Usa marcadores de parámetro de posición, indicados por un signo de interrogación (?).Uses positional parameter markers indicated by a question mark (?).
System.Data.Odbc Usa marcadores de parámetro de posición, indicados por un signo de interrogación (?).Uses positional parameter markers indicated by a question mark (?).
System.Data.OracleClient Usa parámetros con nombre, con el formato :nombreDeParámetro (o nombreDeParámetro).Uses named parameters in the format :parmname (or parmname).

Especificar tipos de datos de parámetroSpecifying parameter data types

El tipo de datos de un parámetro es específico del proveedor de datos de .NET Framework.The data type of a parameter is specific to the .NET Framework data provider. Especificar el tipo convierte el valor de la Parameter para el tipo de proveedor de datos de .NET Framework antes de pasar el valor al origen de datos.Specifying the type converts the value of the Parameter to the .NET Framework data provider type before passing the value to the data source. Si lo desea, puede especificar el tipo de un objeto Parameter de forma genérica estableciendo la propiedad DbType del objeto Parameter en un DbTypedeterminado.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.

El tipo de proveedor de datos de .NET Framework de un Parameter objeto se deriva del tipo de .NET Framework de la Value de la Parameter objeto, o desde el DbType de la Parameter objeto.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. En la siguiente tabla se muestra el tipo deducido de Parameter en función del objeto que se ha pasado como valor Parameter o del DbTypeespecificado.The following table shows the inferred Parameter type based on the object passed as the Parameter value or the specified DbType.

Tipo de .NET Framework.NET Framework type DbTypeDbType SqlDbTypeSqlDbType OleDbTypeOleDbType OdbcTypeOdbcType OracleTypeOracleType
Boolean BooleanoBoolean BitBit BooleanoBoolean BitBit ByteByte
Byte ByteByte TinyIntTinyInt UnsignedTinyIntUnsignedTinyInt TinyIntTinyInt ByteByte
byte[]byte[] BinaryBinary VarBinary.VarBinary. Esta conversión implícita generará un error si la matriz de bytes es mayor que el tamaño máximo de un tipo VarBinary, que es de 8000 bytes. Para las matrices de bytes más de 8.000 bytes, establezca explícitamente la 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 BinaryBinary RawRaw
Char No se admite la deducción de un tipo SqlDbType a partir de char.Inferring a SqlDbType from char is not supported. CharChar CharChar ByteByte
DateTime DateTimeDateTime DateTimeDateTime DBTimeStampDBTimeStamp DateTimeDateTime DateTimeDateTime
DateTimeOffset DateTimeOffsetDateTimeOffset DateTimeOffset en SQL Server 2008.DateTimeOffset in SQL Server 2008. La deducción de un elemento SqlDbType a partir de DateTimeOffset no se admite en versiones de SQL Server anteriores a 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éricaNumeric númeroNumber
Double DobleDouble FloatFloat DobleDouble DobleDouble DobleDouble
Single SingleSingle RealReal SingleSingle RealReal FloatFloat
Guid GUIDGuid UniqueIdentifierUniqueIdentifier GuidGuid UniqueIdentifierUniqueIdentifier RawRaw
Int16 Int16Int16 SmallIntSmallInt SmallIntSmallInt SmallIntSmallInt Int16Int16
Int32 Int32Int32 Valor int.Int Valor int.Int Valor int.Int Int32Int32
Int64 Int64Int64 BigIntBigInt BigIntBigInt BigIntBigInt NúmeroNumber
Object ObjectObject VarianteVariant VarianteVariant No se admite la deducción de un tipo OdbcType a partir de Object.Inferring an OdbcType from Object is not supported. BlobBlob
String StringString NVarChar.NVarChar. Esta conversión implícita generará un error en el caso de que la cadena tenga un tamaño superior al tamaño máximo de un tipo NVarChar, que es de 4.000 caracteres.This implicit conversion will fail if the string is larger than the maximum size of an NVarChar, which is 4000 characters. En cadenas con más de 4.000 caracteres, establezca de forma explícita el tipo SqlDbType.For strings larger than 4000 characters, explicitly set the SqlDbType. VarWCharVarWChar NVarCharNVarChar NVarCharNVarChar
TimeSpan TiempoTime Time en SQL Server 2008.Time in SQL Server 2008. La deducción de un elemento SqlDbType a partir de TimeSpan no se admite en versiones de SQL Server anteriores a SQL Server 2008.Inferring a SqlDbType from TimeSpan is not supported in versions of SQL Server earlier than SQL Server 2008. DBTimeDBTime TiempoTime DateTimeDateTime
UInt16 UInt16UInt16 No se admite la deducción de un tipo SqlDbType a partir de UInt16.Inferring a SqlDbType from UInt16 is not supported. UnsignedSmallIntUnsignedSmallInt Valor int.Int UInt16UInt16
UInt32 UInt32UInt32 No se admite la deducción de un tipo SqlDbType a partir de UInt32.Inferring a SqlDbType from UInt32 is not supported. UnsignedIntUnsignedInt BigIntBigInt UInt32UInt32
UInt64 UInt64UInt64 No se admite la deducción de un tipo SqlDbType a partir de UInt64.Inferring a SqlDbType from UInt64 is not supported. UnsignedBigIntUnsignedBigInt NuméricaNumeric númeroNumber
AnsiStringAnsiString VarCharVarChar VarCharVarChar VarCharVarChar VarCharVarChar
AnsiStringFixedLengthAnsiStringFixedLength CharChar CharChar CharChar CharChar
MonedaCurrency MoneyMoney MonedaCurrency No es posible deducir el valor de OdbcType a partir de Currency .Inferring an OdbcType from Currency is not supported. númeroNumber
FechaDate Date en SQL Server 2008.Date in SQL Server 2008. La deducción de un elemento SqlDbType a partir de Date no se admite en versiones de SQL Server anteriores a SQL Server 2008.Inferring a SqlDbType from Date is not supported in versions of SQL Server earlier than SQL Server 2008. DBDateDBDate FechaDate DateTimeDateTime
SByteSByte No se admite la deducción de un elemento SqlDbType a partir de SByte.Inferring a SqlDbType from SByte is not supported. TinyIntTinyInt No se admite la deducción de un tipo OdbcType a partir de SByte.Inferring an OdbcType from SByte is not supported. SByteSByte
StringFixedLengthStringFixedLength NCharNChar WCharWChar NCharNChar NCharNChar
TiempoTime Time en SQL Server 2008.Time in SQL Server 2008. La deducción de un elemento SqlDbType a partir de Time no se admite en versiones de SQL Server anteriores a SQL Server 2008.Inferring a SqlDbType from Time is not supported in versions of SQL Server earlier than SQL Server 2008. DBTimeDBTime TiempoTime DateTimeDateTime
VarNumericVarNumeric No se admite la deducción de un elemento SqlDbType a partir de VarNumeric.Inferring a SqlDbType from VarNumeric is not supported. VarNumericVarNumeric No se admite la deducción de un tipo OdbcType a partir de VarNumeric.Inferring an OdbcType from VarNumeric is not supported. númeroNumber
tipo definido por el usuario (un objeto con SqlUserDefinedAggregateAttributeuser-defined type (an object with SqlUserDefinedAggregateAttribute Object o String según el proveedor (SqlClient siempre devuelve Object, ODBC siempre devuelve String y el proveedor de datos administrados OleDb puede ver ambos)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á presente; de lo contrario, Variant.SqlDbType.Udt if SqlUserDefinedTypeAttribute is present, otherwise Variant OleDbType.VarWChar (si el valor es NULL); de lo contrario, OleDbType.Variant.OleDbType.VarWChar (if value is null) otherwise OleDbType.Variant. OdbcType.NVarCharOdbcType.NVarChar no admitidonot supported

Nota

Las conversiones de valores de tipo decimal en otros tipos de valor son conversiones de restricción que redondean el valor decimal al valor entero más próximo a cero.Conversions from decimal to other types are narrowing conversions that round the decimal value to the nearest integer value toward zero. Si el resultado de la conversión no puede representarse en el tipo de destino, se produce OverflowException .If the result of the conversion is not representable in the destination type, an OverflowException is thrown.

Nota

Cuando se envía un valor de parámetro null al servidor, debe especificar DBNull, no 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). El valor nulo en el sistema es un objeto vacío que no tiene ningún valor.The null value in the system is an empty object that has no value. Para representar los valores nulos, se usaDBNull .DBNull is used to represent null values. Para obtener más información sobre valores nulos de base de datos, consulte Handling Null Values.For more information about database nulls, see Handling Null Values.

Derivar información de parámetrosDeriving parameter information

Los parámetros también se pueden derivar de un procedimiento almacenado mediante la clase DbCommandBuilder .Parameters can also be derived from a stored procedure using the DbCommandBuilder class. Las clases SqlCommandBuilder y OleDbCommandBuilder proporcionan un método estático, DeriveParameters, que rellena automáticamente la colección de parámetros de un objeto de comando que usa información de parámetros procedente de un procedimiento almacenado.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. Tenga en cuenta que DeriveParameters sobrescribirá toda la información de parámetros existente en el comando.Note that DeriveParameters overwrites any existing parameter information for the command.

Nota

La derivación de información de parámetros afecta al rendimiento, ya que precisa un viaje adicional de ida y vuelta (round trip) al origen de datos para recuperar la información.Deriving parameter information incurs a performance penalty because it requires an additional round trip to the data source to retrieve the information. Si la información de los parámetros se conoce en tiempo de diseño, se puede mejorar el rendimiento de la aplicación si se establecen los parámetros con los valores correspondientes de forma explícita.If parameter information is known at design time, you can improve the performance of your application by setting the parameters explicitly.

Para obtener más información, consulte generar comandos con objetos CommandBuilder.For more information, see Generating Commands with CommandBuilders.

Usar parámetros con SqlCommand y un procedimiento almacenadoUsing parameters with a SqlCommand and a stored procedure

Los procedimientos almacenados ofrecen numerosas ventajas en el caso de aplicaciones que procesan datos.Stored procedures offer many advantages in data-driven applications. Mediante el uso de procedimientos almacenados, las operaciones de bases de datos se pueden encapsular en un solo comando, optimizar para lograr el mejor rendimiento, y mejorar con seguridad adicional.By using stored procedures, database operations can be encapsulated in a single command, optimized for best performance, and enhanced with additional security. Aunque se puede llamar a un procedimiento almacenado pasando el nombre de procedimiento almacenado, seguido de argumentos de parámetro como una instrucción SQL, utilizando el Parameters colección de ADO.NET DbCommand objeto le permite definir más explícitamente el procedimiento almacenado los parámetros así como para tener acceso a los parámetros de salida y valores devueltos.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.

Nota

Las instrucciones con parámetros se ejecutan en el servidor utilizando sp_executesql, ; esto permite volver a utilizar el plan de consultas.Parameterized statements are executed on the server by using sp_executesql, which allows for query plan reuse. Los cursores o las variables locales del lote de sp_executesql no son visibles para el lote que llama a sp_executesql.Local cursors or variables in the sp_executesql batch are not visible to the batch that calls sp_executesql. Los cambios en el contexto de base de datos solo se mantienen hasta el final de la instrucción sp_executesql .Changes in database context last only to the end of the sp_executesql statement. Para obtener más información, consulte sp_executesql (Transact-SQL).For more information, see sp_executesql (Transact-SQL).

Cuando se usan parámetros con SqlCommand para ejecutar un procedimiento almacenado de SQL Server, los nombres de los parámetros agregados a la colección Parameters deben coincidir con los nombres de los marcadores de parámetro del procedimiento almacenado.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. El proveedor de datos de .NET Framework para SQL Server no es compatible con el marcador de posición de signo de interrogación (?) para pasar parámetros a una instrucción SQL o un procedimiento almacenado.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. Este proveedor trata los parámetros del procedimiento almacenado como parámetros con nombre y busca marcadores de parámetros coincidentes.It treats parameters in the stored procedure as named parameters and searches for matching parameter markers. Por ejemplo, el procedimiento almacenado CustOrderHist se define usando un parámetro denominado @CustomerID.For example, the CustOrderHist stored procedure is defined by using a parameter named @CustomerID. Cuando el código ejecuta el procedimiento almacenado, también debe usar un parámetro denominado @CustomerID.When your code executes the stored procedure, it must also use a parameter named @CustomerID.

CREATE PROCEDURE dbo.CustOrderHist @CustomerID varchar(5)

EjemploExample

En este ejemplo se muestra cómo llamar a un procedimiento almacenado de SQL Server en la base de datos de ejemplo Northwind .This example demonstrates how to call a SQL Server stored procedure in the Northwind sample database. El nombre del procedimiento almacenado es dbo.SalesByCategory e incluye un parámetro de entrada denominado @CategoryName con el tipo de datos 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). El código crea una nueva clase SqlConnection dentro de un bloque en uso, de forma que la conexión se cierre cuando finalice el procedimiento.The code creates a new SqlConnection inside a using block so that the connection is disposed when the procedure ends. Se crean los objetos SqlCommand y SqlParameter , y se establecen sus propiedades.The SqlCommand and SqlParameter objects are created, and their properties set. SqlDataReader ejecuta SqlCommand y devuelve el conjunto de resultados del procedimiento almacenado, mostrándolos en la ventana de consola.A SqlDataReader executes the SqlCommand and returns the result set from the stored procedure, displaying the output in the console window.

Nota

En lugar de crear objetos SqlCommand y SqlParameter y, a continuación, establecer propiedades en instrucciones independientes, puede usar uno de los constructores sobrecargados para establecer varias propiedades en una única instrucción.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

Usar parámetros con OleDbCommand o con OdbcCommandUsing parameters with an OleDbCommand or OdbcCommand

Cuando se usan parámetros con OleDbCommand o con OdbcCommand, el orden de los parámetros agregados a la colección Parameters debe coincidir con el de los parámetros definidos en el procedimiento almacenado.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. El proveedor de datos de .NET Framework para OLE DB y el proveedor de datos de .NET Framework para ODBC consideran los parámetros de un procedimiento almacenado como marcadores de posición y aplican los valores de parámetros en orden.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. Además, los parámetros de valores devueltos deben ser los primeros que se agreguen a la colección Parameters .In addition, return value parameters must be the first parameters added to the Parameters collection.

El proveedor de datos de .NET Framework para OLE DB y el proveedor de datos de .NET Framework para ODBC no admiten parámetros con nombre para pasar parámetros a una instrucción SQL o un procedimiento almacenado.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. En este caso, se debe utilizar el marcador de posición de signo interrogación de cierre (?), como se muestra en el ejemplo siguiente.In this case, you must use the question mark (?) placeholder, as in the following example.

SELECT * FROM Customers WHERE CustomerID = ?

Por eso, el orden en que se agregan los objetos Parameter a la colección Parameters debe coincidir exactamente con la posición delAs a result, the order in which Parameter objects are added to the Parameters collection must directly correspond to the position of the ? marcador de posición de interrogación de cierre correspondiente al parámetro.placeholder for the parameter.

Ejemplo de 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;

Ejemplo de 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;

Vea tambiénSee also