Usando Parâmetros com o Controle ObjectDataSource
O controle ObjectDataSource chama métodos de objeto comercial com base no nome do método identificado na propriedade SelectMethod, InsertMethod, UpdateMethod ou DeleteMethod e além disso baseado nos nomes de parâmetro que compõem assinatura do método objeto comercial.Quando você cria métodos em um objeto corporativo, certifique que os nomes de parâmetro e tipos aceitos pelo método do objeto corporativo correspondam ao nomes de parâmetros e tipos que o controle ObjectDataSource passa.(A ordem dos parâmetros não é importante.)
Utilizando Parâmetros
Como todos os controles fonte de dados, o controle ObjectDataSource aceita parâmetros de entrada em tempo de execução e os gerencia em coleções de parâmetros.Cada operação de dados tem uma coleção de parâmetros relacionada.Para operações de seleção, você pode usar a coleção SelectParameters; para obter atualizações, você pode usar a coleção UpdateParameters; e assim por diante.
Você pode especificar um nome, tipo, direção, e valor padrão para cada parâmetro.Parâmetros que obtêm valores de um objeto específico, como um controle, variável de sessão, ou o perfil do usuário, exigem que você defina propriedades adicionais.Por exemplo, um objeto ControlParameter requer que você defina a propriedade ControlID para identificar o controle para tirar o valor do parâmetro e defina a propriedade PropertyName para identificar a propriedade que contém o valor do parâmetro.Para obter mais informações, consulte Usando parâmetros com controles de fonte de dados.
O exemplo de código a seguir mostra um método de seleção que pode ser chamado por um controle ObjectDataSource.O método utiliza um parâmetro e seleciona um único registro a partir de fonte de dados.
<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;
}
Passando Parâmetros para Métodos Insert, Update, e Delete
O controle ObjectDataSource determina o método para pedir uma operação de inserção, atualização ou exclusão com base nas coleções InsertParameters, UpdateParameters e DeleteParameters, respectivamente.Adicionalmente, o controle ObjectDataSource criará parâmetros automaticamente com base nos valores passados por um controle vinculado a dados (como um controle GridView ou FormView) que oferece suporte às operações de atualização automática, inserção e exclusão.Para obter mais informações, consulte Como um Controle da Fonte de Dados Cria Parâmetros para Campos Ligados a Dados.
O exemplo de código a seguir mostra um método que pode ser chamado por um controle ObjectDataSource.O método atualiza informações do funcionário no banco de dados de exemplo 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;
}
O exemplo de código pressupõe que a propriedade ConflictDetection do controle ObjectDataSource foi definida como OverwriteChanges.Se a propriedade ConflictDetection é definida como CompareAllValues, o método de objeto comercial deve aceitar parâmetros para os valores dos campos de dados originais.É possível diferenciar entre os parâmetros para valores atuais e originais usando a propriedade OldValuesParameterFormatString.Você define a propriedade OldValuesParameterFormatString como uma expressão em sequência que é utilizada para formatar os nomes de parâmetros de valor original, onde os caracteres {0} representam o nome do campo.Por exemplo, se você definir a propriedade OldValuesParameterFormatString para original_{0}, o valor atual de um campo denominado FirstName seria passado em um parâmetro chamado FirstName, e o valor original para o campo seria passado em um parâmetro chamado original_FirstName.
Identificando Parâmetros para Classificação e Paginação
Além disso, para especificar objetos SelectParameters de um método Select de objeto comercial, você pode incluir parâmetros para classificação e paginação.Isso permite a você classificar dados no objeto da fonte de dados, bem como restringir os resultados retornados pelo seu objeto da fonte de dados para somente a página solicitada de dados.
Identificando um Parâmetro de Classificação
Você pode especificar um parâmetro de classificação para um método Select de objeto comercial usando a propriedade SortParameterName do controle ObjectDataSource.A propriedade SortParameterName identifica o nome do parâmetro usado para passar classificação de nomes de coluna para o método de objeto comercial.O parâmetro é de tipo sequência de caracteres.
Certos controles ligados a dados como o controle GridView pode passar parâmetros de classificação para o controle ObjectDataSource automaticamente.Quando um controle vinculado a dados que oferece suporte a classificação é vinculado ao controle ObjectDataSource, o controle vinculado a dados passa uma expressão de classificação que identifica as colunas de dados para seres usado para classificar os resultados.Por exemplo, o controle GridView passa valores de classificação na sua propriedade SortExpression.O controle ObjectDataSource define o valor do parâmetro identificado pela propriedade SortParameterName baseado a expressão de classificação passada para ele.A expressão de classificação pode especificar mais de uma coluna; em caso afirmativo, os nomes das colunas são separados por vírgulas.Para especificar uma classificação decrescente, a expressão de classificação pode incluir um nome da coluna de classificação seguido pelo modificador DESC.Por exemplo, uma expressão de classificação que identifica as colunas LastName e FirstName como as colunas a ser usado para classificação seria "LastName, FirstName" para uma classificação crescente e "LastName, FirstName DESC" para uma classificação decrescente.
Identificando Parâmetros de Paginação
Você pode especificar parâmetros adicionais para um método Select que identifica uma página de dados a serem retornados.O controle ObjectDataSource suporta duas propriedades que identificam os parâmetros de paginação:
A propriedade StartRowIndexParameterName identifica o nome de um parâmetro no método de seleção do objeto comercial que é usado para especificar a linha de início da página de dados.
A propriedade MaximumRowsParameterName identifica o nome de um parâmetro no método de seleção do objeto comercial que é usado para especificar o número de linhas da página de dados.
Ambos os parâmetros identificados pelas propriedades StartRowIndexParameterName e MaximumRowsParameterName são do tipo Int32.
O exemplo de código a seguir mostra um controle ObjectDataSource configurado para passar parâmetros de classificação e página para o método Select do 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>
O exemplo de código a seguir mostra o método Select do objeto comercial chamado no exemplo anterior.O método do objeto corporativo retorna uma página de dados do banco de dados de exemplo Northwind, classificados na ordem especificada.
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;
}
}
}
Direção do parâmetro
Por padrão, todos os parâmetros para métodos de objeto corporativo são parâmetros de entrada.Se o método de objeto comercial inclui um parâmetro de saída que retorna um valor para o controle ObjectDataSource, você deve explicitamente especificar um parâmetro com um parâmetro direção conforme descrito em Usando parâmetros com controles de fonte de dados.
O exemplo de código a seguir mostra um controle ObjectDataSource configurado para aceitar um parâmetro de saída do tipo Int32.O parâmetro de saída retorna um valor de chave primária gerada automaticamente do método especificado pela propriedade 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>
O exemplo de código a seguir mostra o método Insert de objeto comercial que retorna o valor de chave primária como um parâmetro de saída:
<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 Dados de Parâmetros
Por padrão, todos os parâmetros para métodos de objeto comercial digitados como Object.Se o método de objeto comercial inclui parâmetros de tipos diferentes, você deve especificar explicitamente parâmetros digitados com rigidez.Para obter detalhes, consulte:Usando parâmetros com controles de fonte de dados.
Passagem de Tipos de Parâmetros Personalizados
A maioria das assinaturas de método de objeto comercial aceita parâmetros dos tipos String e Int32.No entanto, você pode estar trabalhando com um método de objeto corporativo que aceita um ou mais parâmetros como sendo um tipo complexo ou definido pelo usuário.Para trabalhar com tipos de parâmetros complexos ou definidos pelo usuário, você pode usar a propriedade DataObjectTypeName do controle ObjectDataSource.
No seu objeto corporativo, a criação de métodos com extensas listas de parâmetros que mapeiam de uma maneira um-para-um valores de controle com valores no armazenamento de dados pode resultar em código que não é facilmente reutilizável.Uma prática melhor é encapsular os dados em uma classe personalizada e em seguida passar uma instância da classe como um parâmetro.Dessa forma, os dados que constituem uma instância da classe, como um registro de funcionário, pode ser alterado sem exigir alterações nas interfaces públicas expostas pelo objeto da fonte de dados.O exemplo de código a seguir mostra uma classe chamada NorthwindExployee que define os dados de funcionários e que pode ser passada como um parâmetro para um objeto corporativo.
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 aceitar uma instância da classe anterior como um parâmetro, o método UpdateEmployeeInfo do objeto comercial pode ser definido usando a assinatura a seguir:
public void UpdateEmployeeInfo(NorthwindEmployee emp) {
}
Public Sub UpdateEmployeeInfo(emp As NorthwindEmployee)
End Sub
Embora você não possa definir o Type de um parâmetro para o nome de uma classe personalizada, você pode definir a propriedade DataObjectTypeName do controle ObjectDataSource para o nome de uma digitação personalizada definida pelo usuário, como a classe NorthwindEmployee e em seguida, passar uma instância da digitação para um método de dados de objeto comercial.Para passar objetos definidos pelo usuário para um objeto da fonte de dados, as seguintes condições devem ser atendidas:
O tipo definido pelo usuário deve ter um construtor padrão (um construtor sem parâmetros).
O tipo definido pelo usuário deve definir as propriedades públicas cujos nomes correspondam às entradas do dicionário passadas para o controle da fonte de dados de controles ligados a dados, como GridView e DetailsView.Para obter detalhes sobre esses dicionários, consulte Usando parâmetros com controles de fonte de dados.
As propriedades públicas do objeto da fonte de dados deve expor ambos os acessadores get e set.
O exemplo a seguir mostra um controle ObjectDataSource que realiza uma operação de atualização chamando o método UpdateEmployeeInfo de um objeto comercial chamado EmployeeLogic.O controle ObjectDataSource está configurado para passar uma instância da classe NorthwindEmployee para o método de atualização.
<asp:objectdatasource
id="ObjectDataSource1"
typename="EmployeeLogic"
selectmethod="GetAllEmployees"
updatemethod="UpdateEmployeeInfo"
dataobjecttypename="NorthwindEmployee" />
Em alguns casos, o método do objeto corporativo terá uma lista de parâmetros que contém vários tipos de parâmetros complexos.Nesse caso, você pode usar o controle ObjectDataSource, mas você deve adicionar os parâmetros para o controle ObjectDataSource programaticamente.Para fazer isso, manipule o evento que é gerado antes de a operação de dados ser executada, como o evento Inserting, Updating ou Deleting e defina valores na coleção InputParameters expostos pela classe ObjectDataSourceMethodEventArgs.
Consulte também
Referência
Visão geral sobre o controle de servidor Web ObjectDataSource