Utilizar parámetros con el control ObjectDataSource
Actualización: noviembre 2007
El control ObjectDataSource llama a métodos de objetos comerciales basándose en el nombre del método identificado en la propiedad SelectMethod, InsertMethod, UpdateMethod o DeleteMethod y basándose adicionalmente en los nombres de parámetros que constituyen la firma del método del objeto comercial. Al crear métodos en un objeto comercial, debe asegurarse de que los nombres y tipos de parámetros aceptados por el método del objeto comercial coincidan con los nombres y tipos de parámetros que pasa el control ObjectDataSource. (El orden de parámetros no es importante.)
Utilizar parámetros
Como todos los controles de origen de datos, el control ObjectDataSource acepta parámetros de entrada en tiempo de ejecución y los administra en colecciones de parámetros. Cada operación de datos tiene una colección de parámetros relacionada. Para las operaciones de selección, puede utilizar la colección SelectParameters y para las actualizaciones, la colección UpdateParameters, etc.
Puede especificar un nombre, tipo, dirección y valor predeterminado para cada parámetro. Los parámetros que reciben valores de un objeto concreto, como un control, variable de sesión o el perfil de usuario, exigen que se establezcan propiedades adicionales. Por ejemplo, un objeto ControlParameter requiere establecer la propiedad ControlID para identificar el control que va a tomar el valor del parámetro y establecer la propiedad PropertyName para identificar la propiedad que contiene el valor del parámetro. Para obtener más información, vea Utilizar parámetros con controles de origen de datos.
El ejemplo de código siguiente muestra un método de selección al que se puede llamar mediante un control ObjectDataSource. El método toma un parámetro y selecciona un registro único del origen de datos.
<DataObjectMethod(DataObjectMethodType.Select)> _
Public Shared Function GetEmployee(EmployeeID As Integer) As DataTable
If Not _initialized Then Initialize()
Dim conn As SqlConnection = New SqlConnection(_connectionString)
Dim da As SqlDataAdapter = _
New SqlDataAdapter("SELECT EmployeeID, LastName, FirstName, Address, City, Region, PostalCode FROM Employees WHERE EmployeeID = @EmployeeID", conn)
da.SelectCommand.Parameters.Add("@EmployeeID", SqlDbType.Int).Value = EmployeeID
Dim ds As DataSet = New DataSet()
Try
conn.Open()
da.Fill(ds, "Employees")
Catch e As SqlException
' Handle exception.
Finally
conn.Close()
End Try
If ds.Tables("Employees") IsNot Nothing Then _
Return ds.Tables("Employees")
Return Nothing
End Function
[DataObjectMethod(DataObjectMethodType.Select)]
public static DataTable GetEmployee(int EmployeeID)
{
if (!_initialized) { Initialize(); }
SqlConnection conn = new SqlConnection(_connectionString);
SqlDataAdapter da =
new SqlDataAdapter("SELECT EmployeeID, LastName, FirstName, Address, City, Region, PostalCode FROM Employees WHERE EmployeeID = @EmployeeID", conn);
da.SelectCommand.Parameters.Add("@EmployeeID", SqlDbType.Int).Value = EmployeeID;
DataSet ds = new DataSet();
try
{
conn.Open();
da.Fill(ds, "Employees");
}
catch (SqlException e)
{
// Handle exception.
}
finally
{
conn.Close();
}
if (ds.Tables["Employees"] != null)
return ds.Tables["Employees"];
return null;
}
Pasar parámetros a los métodos Insert, Update y Delete
El control ObjectDataSource determina el método para pedir una operación de inserción, actualización o eliminación basándose en las colecciones InsertParameters, UpdateParameters y DeleteParameters, respectivamente. Además, el control ObjectDataSource crea automáticamente parámetros basados en valores pasados por un control enlazado a datos (como un control GridView o FormView) que admite operaciones automáticas de actualización, inserción y eliminación. Para obtener más información, vea Cómo un control de origen de datos crea parámetros para campos enlazados a datos.
El ejemplo de código siguiente muestra un método al que se puede llamar mediante un control ObjectDataSource. El método actualiza información de empleados en la base de datos de ejemplo Northwind.
<DataObjectMethod(DataObjectMethodType.Update)> _
Public Shared Function UpdateEmployee(EmployeeID As Integer, _
FirstName As String, _
LastName As String, _
Address As String, _
City As String, _
Region As String, _
PostalCode As String) As Boolean
If String.IsNullOrEmpty(FirstName) Then _
Throw New ArgumentException("FirstName cannot be null or an empty string.")
If String.IsNullOrEmpty(LastName) Then _
Throw New ArgumentException("LastName cannot be null or an empty string.")
If Address Is Nothing Then Address = String.Empty
If City Is Nothing Then City = String.Empty
If Region Is Nothing Then Region = String.Empty
If PostalCode Is Nothing Then PostalCode = String.Empty
If Not _initialized Then Initialize()
Dim conn As SqlConnection = New SqlConnection(_connectionString)
Dim cmd As SqlCommand = New SqlCommand("UPDATE Employees " & _
" SET FirstName=@FirstName, LastName=@LastName, " & _
" Address=@Address, City=@City, Region=@Region, " & _
" PostalCode=@PostalCode " & _
" WHERE EmployeeID=@EmployeeID", conn)
cmd.Parameters.Add("@FirstName", SqlDbType.VarChar, 10).Value = FirstName
cmd.Parameters.Add("@LastName", SqlDbType.VarChar, 20).Value = LastName
cmd.Parameters.Add("@Address", SqlDbType.VarChar, 60).Value = Address
cmd.Parameters.Add("@City", SqlDbType.VarChar, 15).Value = City
cmd.Parameters.Add("@Region", SqlDbType.VarChar, 15).Value = Region
cmd.Parameters.Add("@PostalCode", SqlDbType.VarChar, 10).Value = PostalCode
cmd.Parameters.Add("@EmployeeID", SqlDbType.Int).Value = EmployeeID
Try
conn.Open()
If cmd.ExecuteNonQuery() <> 0 Then _
Return False
Catch e As SqlException
' Handle exception.
Finally
conn.Close()
End Try
Return True
End Function
[DataObjectMethod(DataObjectMethodType.Update)]
public static bool UpdateEmployee(int EmployeeID, string FirstName, string LastName,
string Address, string City, string Region, string PostalCode)
{
if (String.IsNullOrEmpty(FirstName))
throw new ArgumentException("FirstName cannot be null or an empty string.");
if (String.IsNullOrEmpty(LastName))
throw new ArgumentException("LastName cannot be null or an empty string.");
if (Address == null) { Address = String.Empty; }
if (City == null) { City = String.Empty; }
if (Region == null) { Region = String.Empty; }
if (PostalCode == null) { PostalCode = String.Empty; }
if (!_initialized) { Initialize(); }
SqlConnection conn = new SqlConnection(_connectionString);
SqlCommand cmd = new SqlCommand("UPDATE Employees " +
" SET FirstName=@FirstName, LastName=@LastName, " +
" Address=@Address, City=@City, Region=@Region, " +
" PostalCode=@PostalCode " +
" WHERE EmployeeID=@EmployeeID", conn);
cmd.Parameters.Add("@FirstName", SqlDbType.VarChar, 10).Value = FirstName;
cmd.Parameters.Add("@LastName", SqlDbType.VarChar, 20).Value = LastName;
cmd.Parameters.Add("@Address", SqlDbType.VarChar, 60).Value = Address;
cmd.Parameters.Add("@City", SqlDbType.VarChar, 15).Value = City;
cmd.Parameters.Add("@Region", SqlDbType.VarChar, 15).Value = Region;
cmd.Parameters.Add("@PostalCode", SqlDbType.VarChar, 10).Value = PostalCode;
cmd.Parameters.Add("@EmployeeID", SqlDbType.Int).Value = EmployeeID;
try
{
conn.Open();
if (cmd.ExecuteNonQuery() == 0)
return false;
}
catch (SqlException e)
{
// Handle exception.
}
finally
{
conn.Close();
}
return true;
}
El ejemplo de código supone que la propiedad ConflictDetection del control ObjectDataSource se ha establecido en OverwriteChanges. Si la propiedad ConflictDetection se establece en CompareAllValues, el método del objeto comercial debe aceptar parámetros para los valores originales de los campos de datos. Puede diferenciar entre parámetros para valores actuales y originales mediante la propiedad OldValuesParameterFormatString. Establece la propiedad OldValuesParameterFormatString en una expresión de cadena que se utiliza para dar formato a los nombres para los parámetros de valores originales, en los que los caracteres {0} representan el nombre del campo. Por ejemplo, si establece la propiedad OldValuesParameterFormatString en original_{0}, el valor actual para un campo denominado FirstName se pasaría en un parámetro llamado FirstName y el valor original para el campo se pasaría en un parámetro llamado original_FirstName.
Identificar parámetros para ordenar y paginar
Además de especificar objetos SelectParameters para un método del objeto comercial Select, puede incluir parámetros para ordenar y paginar. Esto le permite ordenar datos en el objeto del origen de datos, así como restringir los resultados devueltos del objeto del origen de datos a únicamente la página de datos solicitada.
Identificar un parámetro de ordenación
Puede especificar un parámetro de ordenación para un método del objeto comercial [F:System.ComponentModel.DataObjectMethodType.Select™] mediante la propiedad SortParameterName del control ObjectDataSource. La propiedad SortParameterName identifica el nombre del parámetro utilizado para pasar los nombres de columna de ordenación al método del objeto comercial. El parámetro es de tipo cadena.
Algunos controles enlazados a datos como el control GridView pueden pasar automáticamente parámetros de ordenación al control ObjectDataSource. Cuando un control enlazado a datos que admite la ordenación está enlazado al control ObjectDataSource, el control enlazado a datos pasa una expresión de ordenación que identifica las columnas de datos que se van a utilizar para ordenar los resultados. Por ejemplo, el control GridView pasa valores de ordenación en su propiedad SortExpression. El control ObjectDataSource establece el valor del parámetro identificado por la propiedad SortParameterName basándose en la expresión de ordenación que le han pasado. La expresión de ordenación puede especificar más de una columna; en ese caso, los nombres de columnas están separados por comas. Para especificar un orden descendente, la expresión de ordenación puede incluir un nombre de columna de ordenación seguido del modificador DESC. Por ejemplo, una expresión de ordenación que identifica las columnas LastName y FirstName como las columnas que se van a utilizar para ordenar sería "LastName, FirstName" para una ordenación ascendente y "LastName, FirstName DESC" para una ordenación descendente.
Identificar parámetros de paginación
Puede especificar parámetros adicionales para un método Select que identifica una página de datos que se va a devolver. El control ObjectDataSource admite dos propiedades que identifican los parámetros de paginación:
La propiedad StartRowIndexParameterName identifica el nombre de un parámetro en el método de selección del objeto comercial que se utiliza para especificar la fila de inicio de la página de datos.
La propiedad MaximumRowsParameterName identifica el nombre de un parámetro en el método de selección del objeto comercial que se utiliza para especificar el número de filas de la página de datos.
Ambos parámetros identificados por las propiedades StartRowIndexParameterName y MaximumRowsParameterName son de tipo Int32.
El ejemplo de código siguiente muestra un control ObjectDataSource configurado para pasar los parámetros de ordenación y paginación al método Select del objeto comercial especificado:
<asp:ObjectDataSource
ID="EmployeesObjectDataSource"
TypeName="Samples.AspNet.Controls.NorthwindEmployee"
SortParameterName="SortColumns"
EnablePaging="true"
StartRowIndexParameterName="StartRecord"
MaximumRowsParameterName="MaxRecords"
SelectMethod="GetAllEmployees" >
</asp:ObjectDataSource>
<asp:ObjectDataSource
ID="EmployeesObjectDataSource"
TypeName="Samples.AspNet.Controls.NorthwindEmployee"
SortParameterName="SortColumns"
EnablePaging="true"
StartRowIndexParameterName="StartRecord"
MaximumRowsParameterName="MaxRecords"
SelectMethod="GetAllEmployees" >
</asp:ObjectDataSource>
El ejemplo de código siguiente muestra el método del objeto comercial Select llamado en el ejemplo anterior. El método del objeto comercial devuelve una página de datos de la base de datos de ejemplo Northwind, ordenada en el orden especificado.
Public Shared Sub Initialize()
' Initialize data source. Use "Northwind" connection string from configuration.
If ConfigurationManager.ConnectionStrings("Northwind") Is Nothing OrElse _
ConfigurationManager.ConnectionStrings("Northwind").ConnectionString.Trim() = "" Then
Throw New Exception("A connection string named 'Northwind' with a valid connection string " & _
"must exist in the <connectionStrings> configuration section for the application.")
End If
_connectionString = _
ConfigurationManager.ConnectionStrings("Northwind").ConnectionString
_initialized = True
End Sub
' Select all employees.
<DataObjectMethod(DataObjectMethodType.Select, True)> _
Public Shared Function GetAllEmployees(sortColumns As String, startRecord As Integer, maxRecords As Integer) As DataTable
VerifySortColumns(sortColumns)
If Not _initialized Then Initialize()
Dim sqlCommand As String = "SELECT EmployeeID, LastName, FirstName, Address, City, Region, PostalCode FROM Employees "
If sortColumns.Trim() = "" Then
sqlCommand &= "ORDER BY EmployeeID"
Else
sqlCommand &= "ORDER BY " & sortColumns
End If
Dim conn As SqlConnection = New SqlConnection(_connectionString)
Dim da As SqlDataAdapter = New SqlDataAdapter(sqlCommand, conn)
Dim ds As DataSet = New DataSet()
Try
conn.Open()
da.Fill(ds, startRecord, maxRecords, "Employees")
Catch e As SqlException
' Handle exception.
Finally
conn.Close()
End Try
If ds.Tables("Employees") IsNot Nothing Then _
Return ds.Tables("Employees")
Return Nothing
End Function
'''''
' Verify that only valid columns are specified in the sort expression to aSub a SQL Injection attack.
Private Shared Sub VerifySortColumns(sortColumns As String)
If sortColumns.ToLowerInvariant().EndsWith(" desc") Then _
sortColumns = sortColumns.Substring(0, sortColumns.Length - 5)
Dim columnNames() As String = sortColumns.Split(",")
For Each columnName As String In columnNames
Select Case columnName.Trim().ToLowerInvariant()
Case "employeeid"
Case "lastname"
Case "firstname"
Case ""
Case Else
Throw New ArgumentException("SortColumns contains an invalid column name.")
End Select
Next
End Sub
public static void Initialize()
{
// Initialize data source. Use "Northwind" connection string from configuration.
if (ConfigurationManager.ConnectionStrings["Northwind"] == null ||
ConfigurationManager.ConnectionStrings["Northwind"].ConnectionString.Trim() == "")
{
throw new Exception("A connection string named 'Northwind' with a valid connection string " +
"must exist in the <connectionStrings> configuration section for the application.");
}
_connectionString =
ConfigurationManager.ConnectionStrings["Northwind"].ConnectionString;
_initialized = true;
}
// Select all employees.
[DataObjectMethod(DataObjectMethodType.Select, true)]
public static DataTable GetAllEmployees(string sortColumns, int startRecord, int maxRecords)
{
VerifySortColumns(sortColumns);
if (!_initialized) { Initialize(); }
string sqlCommand = "SELECT EmployeeID, LastName, FirstName, Address, City, Region, PostalCode FROM Employees ";
if (sortColumns.Trim() == "")
sqlCommand += "ORDER BY EmployeeID";
else
sqlCommand += "ORDER BY " + sortColumns;
SqlConnection conn = new SqlConnection(_connectionString);
SqlDataAdapter da = new SqlDataAdapter(sqlCommand, conn);
DataSet ds = new DataSet();
try
{
conn.Open();
da.Fill(ds, startRecord, maxRecords, "Employees");
}
catch (SqlException e)
{
// Handle exception.
}
finally
{
conn.Close();
}
if (ds.Tables["Employees"] != null)
return ds.Tables["Employees"];
return null;
}
//////////
// Verify that only valid columns are specified in the sort expression to avoid a SQL Injection attack.
private static void VerifySortColumns(string sortColumns)
{
if (sortColumns.ToLowerInvariant().EndsWith(" desc"))
sortColumns = sortColumns.Substring(0, sortColumns.Length - 5);
string[] columnNames = sortColumns.Split(',');
foreach (string columnName in columnNames)
{
switch (columnName.Trim().ToLowerInvariant())
{
case "employeeid":
break;
case "lastname":
break;
case "firstname":
break;
case "":
break;
default:
throw new ArgumentException("SortColumns contains an invalid column name.");
break;
}
}
}
Dirección de los parámetros
De manera predeterminada, todos los parámetros para los métodos de objetos comerciales son parámetros de entrada. Si el método del objeto comercial incluye un parámetro de salida que devuelve un valor al control ObjectDataSource, debe especificar explícitamente una dirección del parámetro tal como se describe en Utilizar parámetros con controles de origen de datos.
En el ejemplo de código siguiente se muestra un control ObjectDataSource configurado para que acepte un parámetro de salida de tipo Int32. El parámetro de salida devuelve un valor de clave principal automáticamente generado desde el método especificado por la propiedad InsertMethod.
<asp:ObjectDataSource
ID="EmployeeDetailsObjectDataSource"
TypeName="Samples.AspNet.Controls.NorthwindEmployee"
SelectMethod="GetEmployee"
UpdateMethod="UpdateEmployee"
DeleteMethod="DeleteEmployee"
InsertMethod="InsertEmployee"
OnInserted="EmployeeDetailsObjectDataSource_OnInserted" >
<SelectParameters>
<asp:Parameter Name="EmployeeID" />
</SelectParameters>
<InsertParameters>
<asp:Parameter Name="NewEmployeeID" Direction="Output"
Type="Int32" DefaultValue="0" />
</InsertParameters>
</asp:ObjectDataSource>
<asp:ObjectDataSource
ID="EmployeeDetailsObjectDataSource"
TypeName="Samples.AspNet.Controls.NorthwindEmployee"
SelectMethod="GetEmployee"
UpdateMethod="UpdateEmployee"
DeleteMethod="DeleteEmployee"
InsertMethod="InsertEmployee"
OnInserted="EmployeeDetailsObjectDataSource_OnInserted" >
<SelectParameters>
<asp:Parameter Name="EmployeeID" />
</SelectParameters>
<InsertParameters>
<asp:Parameter Name="NewEmployeeID" Direction="Output"
Type="Int32" DefaultValue="0" />
</InsertParameters>
</asp:ObjectDataSource>
El ejemplo de código siguiente muestra el método del objeto comercial Insert que devuelve el valor de clave principal como parámetro de salida:
<DataObjectMethod(DataObjectMethodType.Insert)> _
Public Shared Function InsertEmployee(ByRef NewEmployeeID As Integer, _
FirstName As String, _
LastName As String, _
Address As String, _
City As String, _
Region As String, _
PostalCode As String) As Boolean
If String.IsNullOrEmpty(FirstName) Then _
Throw New ArgumentException("FirstName cannot be null or an empty string.")
If String.IsNullOrEmpty(LastName) Then _
Throw New ArgumentException("LastName cannot be null or an empty string.")
If Address Is Nothing Then Address = String.Empty
If City Is Nothing Then City = String.Empty
If Region Is Nothing Then Region = String.Empty
If PostalCode Is Nothing Then PostalCode = String.Empty
If Not _initialized Then Initialize()
NewEmployeeID = -1
Dim conn As SqlConnection = New SqlConnection(_connectionString)
Dim cmd As SqlCommand = New SqlCommand("INSERT INTO Employees " & _
" (FirstName, LastName, Address, City, Region, PostalCode) " & _
" Values(@FirstName, @LastName, @Address, @City, @Region, @PostalCode) " & _
"SELECT @EmployeeID = SCOPE_IDENTITY()", conn)
cmd.Parameters.Add("@FirstName", SqlDbType.VarChar, 10).Value = FirstName
cmd.Parameters.Add("@LastName", SqlDbType.VarChar, 20).Value = LastName
cmd.Parameters.Add("@Address", SqlDbType.VarChar, 60).Value = Address
cmd.Parameters.Add("@City", SqlDbType.VarChar, 15).Value = City
cmd.Parameters.Add("@Region", SqlDbType.VarChar, 15).Value = Region
cmd.Parameters.Add("@PostalCode", SqlDbType.VarChar, 10).Value = PostalCode
Dim p As SqlParameter = cmd.Parameters.Add("@EmployeeID", SqlDbType.Int)
p.Direction = ParameterDirection.Output
Try
conn.Open()
cmd.ExecuteNonQuery()
NewEmployeeID = CInt(p.Value)
Catch e As SqlException
' Handle exception.
Finally
conn.Close()
End Try
Return True
End Function
[DataObjectMethod(DataObjectMethodType.Insert)]
public static bool InsertEmployee(out int NewEmployeeID, string FirstName, string LastName,
string Address, string City, string Region, string PostalCode)
{
if (String.IsNullOrEmpty(FirstName))
throw new ArgumentException("FirstName cannot be null or an empty string.");
if (String.IsNullOrEmpty(LastName))
throw new ArgumentException("LastName cannot be null or an empty string.");
if (Address == null) { Address = String.Empty; }
if (City == null) { City = String.Empty; }
if (Region == null) { Region = String.Empty; }
if (PostalCode == null) { PostalCode = String.Empty; }
if (!_initialized) { Initialize(); }
NewEmployeeID = -1;
SqlConnection conn = new SqlConnection(_connectionString);
SqlCommand cmd = new SqlCommand("INSERT INTO Employees " +
" (FirstName, LastName, Address, City, Region, PostalCode) " +
" Values(@FirstName, @LastName, @Address, @City, @Region, @PostalCode); " +
"SELECT @EmployeeID = SCOPE_IDENTITY()", conn);
cmd.Parameters.Add("@FirstName", SqlDbType.VarChar, 10).Value = FirstName;
cmd.Parameters.Add("@LastName", SqlDbType.VarChar, 20).Value = LastName;
cmd.Parameters.Add("@Address", SqlDbType.VarChar, 60).Value = Address;
cmd.Parameters.Add("@City", SqlDbType.VarChar, 15).Value = City;
cmd.Parameters.Add("@Region", SqlDbType.VarChar, 15).Value = Region;
cmd.Parameters.Add("@PostalCode", SqlDbType.VarChar, 10).Value = PostalCode;
SqlParameter p = cmd.Parameters.Add("@EmployeeID", SqlDbType.Int);
p.Direction = ParameterDirection.Output;
try
{
conn.Open();
cmd.ExecuteNonQuery();
NewEmployeeID = (int)p.Value;
}
catch (SqlException e)
{
// Handle exception.
}
finally
{
conn.Close();
}
return true;
}
Tipos de datos de parámetros
De manera predeterminada, todos los parámetros para los métodos de objetos comerciales son de tipo Object. Si el método del objeto comercial incluye parámetros de tipos diferentes, debe especificar explícitamente los parámetros con establecimiento inflexible de tipos. Para obtener información detallada, vea Utilizar parámetros con controles de origen de datos.
Pasar tipos de parámetros personalizados
La mayoría de las firmas de métodos de objetos comerciales toman parámetros de tipo String y Int32. Sin embargo, podría estar trabajando con un método del objeto comercial que toma uno o varios parámetros con tipos como el tipo complejo o definido por el usuario. Para trabajar con tipos de parámetros complejos o definidos por el usuario, puede utilizar la propiedad DataObjectTypeName del control ObjectDataSource.
En el objeto comercial, la creación de métodos con largas listas de parámetros que asignan valores de control uno a uno a valores almacenados de datos puede provocar que el código no sea fácilmente reutilizable. Es más recomendable encapsular los datos en una clase personalizada y, a continuación, pasar una instancia de la clase como un parámetro. De esta manera, los datos que constituyen una instancia de la clase, como un registro de empleados, pueden cambiar sin necesidad de hacer cambios en las interfaces públicas expuestas por el objeto del origen de datos. El código de ejemplo siguiente muestra una clase llamada NorthwindExployee que define los datos de empleados y que se puede pasar como parámetro a un objeto comercial.
public class NorthwindEmployee {
public NorthwindEmployee() { }
private int _empId;
private string _firstName;
public int EmpId {
get { return _empId; }
set { _empId = value; }
}
public string FirstName {
get { return _firstName; }
set { _firstName = value; }
}
// Additional code for the class.
}
Public Class NorthwindEmployee
Public Sub New()
End Sub
Private _empId As String
Public Property EmpId() As Integer
Get
Return _empId
End Get
Set
_empId = value
End Set
End Property
Private _firstName As String
Public Property FirstName() As String
Get
Return _firstName
End Get
Set
_firstName = value
End Set
End Property
' Additional code for the class.
End Class
Para aceptar una instancia de la clase anterior como parámetro, el método UpdateEmployeeInfo del objeto comercial se podría definir mediante la firma siguiente:
public void UpdateEmployeeInfo(NorthwindEmployee emp) {
}
Public Sub UpdateEmployeeInfo(emp As NorthwindEmployee)
End Sub
Aunque no puede establecer Type de un parámetro en el nombre de una clase personalizada, puede establecer la propiedad DataObjectTypeName del control ObjectDataSource en el nombre de un tipo personalizado definido por el usuario, como la clase NorthwindEmployee, y pasar una instancia del tipo a un método de datos del objeto comercial. Para pasar objetos definidos por el usuario a un objeto del origen de datos, se deben cumplir las condiciones siguientes:
El tipo definido por el usuario debe tener un constructor predeterminado (un constructor que no toma ningún parámetro).
El tipo definido por el usuario debe definir las propiedades públicas cuyos nombres coincidan con los de las entradas del directorio pasadas al control del origen de datos desde los controles enlazados a datos como GridView y DetailsView. Para obtener información detallada sobre estos diccionarios, vea Utilizar parámetros con controles de origen de datos.
Las propiedades públicas del objeto del origen de datos deben exponer los dos descriptores get y set.
El ejemplo siguiente muestra un control ObjectDataSource que realiza una operación de actualización llamando al método UpdateEmployeeInfo de un objeto comercial denominado EmployeeLogic. El control ObjectDataSource se configura para pasar una instancia de la clase NorthwindEmployee al método de actualización.
<asp:objectdatasource
id="ObjectDataSource1"
typename="EmployeeLogic"
selectmethod="GetAllEmployees"
updatemethod="UpdateEmployeeInfo"
dataobjecttypename="NorthwindEmployee" />
En algunos casos, el método del objeto comercial tendrá una lista de parámetros que contiene varios tipos de parámetros complejos. En ese caso, puede utilizar el control ObjectDataSource pero debe agregar parámetros mediante programación al control ObjectDataSource. Para ello, controle el evento que se produce antes de realizar la operación de datos, como el evento Inserting, Updating o Deleting, y establezca los valores en la colección InputParameters expuesta por la clase ObjectDataSourceMethodEventArgs.