Utilizzo dei parametri con il controllo ObjectDataSource
Aggiornamento: novembre 2007
Il controllo ObjectDataSource chiama i metodi degli oggetti business in base al nome del metodo identificato nella proprietà SelectMethod, InsertMethod, UpdateMethod o DeleteMethod e anche in base ai nomi dei parametri che costituiscono la firma del metodo dell'oggetto business. Quando si creano metodi in un oggetto business, è necessario assicurarsi che i nomi e i tipi dei parametri accettati dal metodo dell'oggetto business corrispondano ai nomi e ai tipi dei parametri passati dal controllo ObjectDataSource. L'ordine dei parametri non è importante.
Utilizzo dei parametri
Analogamente a tutti i controlli origine dati, il controllo ObjectDataSource accetta i parametri di input in fase di esecuzione e li gestisce negli insiemi di parametri. A ciascuna operazione sui dati è correlato un insieme di parametri. Per le operazioni di selezione è possibile utilizzare l'insieme SelectParameters, per gli aggiornamenti l'insieme UpdateParameters e così via.
Per ciascun parametro è possibile specificare un nome, un tipo, una direzione e un valore predefinito. Per i parametri che ottengono valori da un oggetto specifico, ad esempio un controllo, una variabile di sessione o il profilo utente, è necessario impostare proprietà aggiuntive. Un oggetto ControlParameter, ad esempio, richiede l'impostazione della proprietà ControlID per l'identificazione del controllo che accetta il valore del parametro e della proprietà PropertyName per l'identificazione della proprietà che contiene il valore del parametro. Per ulteriori informazioni, vedere Utilizzo di parametri con controlli origine dati.
Nell'esempio di codice riportato di seguito viene illustrato un metodo di selezione che può essere chiamato da un controllo ObjectDataSource. Il metodo accetta un parametro e seleziona un singolo record dall'origine dati.
<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;
}
Passaggio di parametri ai metodi Insert, Update e Delete
Il controllo ObjectDataSource determina il metodo da chiamare per un'operazione di inserimento, aggiornamento o eliminazione, rispettivamente in base agli insiemi InsertParameters, UpdateParameters e DeleteParameters. Il controllo ObjectDataSource, inoltre, crea automaticamente parametri in base ai valori passati da un controllo con associazione a dati, ad esempio GridView o FormView, che supporta le operazioni automatiche di aggiornamento, inserimento ed eliminazione. Per ulteriori informazioni, vedere Come un controllo origine dati crea parametri per campi associati a dati.
Nell'esempio di codice riportato di seguito viene illustrato un metodo che può essere chiamato da un controllo ObjectDataSource. Il metodo aggiorna le informazioni sui dipendenti nel database Northwind di esempio.
<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;
}
Nell'esempio di codice si presuppone che la proprietà ConflictDetection del controllo ObjectDataSource sia stata impostata su OverwriteChanges. Se la proprietà ConflictDetection è impostata su CompareAllValues, il metodo dell'oggetto business deve accettare parametri per i valori originali dei campi dati. È possibile differenziare i parametri relativi ai valori correnti e a quelli originali mediante la proprietà OldValuesParameterFormatString. Impostare la proprietà OldValuesParameterFormatString su un'espressione stringa utilizzata per la formattazione dei nomi per i parametri dei valori originali, in cui i caratteri {0} rappresentano il nome del campo. Se, ad esempio, si imposta la proprietà OldValuesParameterFormatString su original_{0}, il valore corrente per un campo denominato FirstName viene passato in un parametro denominato FirstName e il relativo valore originale viene passato in un parametro denominato original_FirstName.
Identificazione dei parametri per l'ordinamento e lo spostamento
Oltre a specificare gli oggetti SelectParameters per un metodo di un oggetto business Select, è possibile includere parametri per l'ordinamento e lo spostamento. In questo modo sarà possibile ordinare i dati nell'oggetto origine dati, nonché limitare i risultati restituiti dall'oggetto origine dati alla sola pagina di dati richiesta.
Identificazione di un parametro di ordinamento
È possibile specificare un parametro di ordinamento per un metodo di un oggetto business Select mediante la proprietà SortParameterName del controllo ObjectDataSource. La proprietà SortParameterName identifica il nome del parametro utilizzato per passare i nomi delle colonne di ordinamento al metodo dell'oggetto business. Il parametro è di tipo stringa.
Alcuni controlli con associazione a dati, ad esempio il controllo GridView, possono passare automaticamente parametri di ordinamento al controllo ObjectDataSource. Quando è associato al controllo ObjectDataSource, un controllo con associazione a dati che supporta l'ordinamento passa un'espressione di ordinamento che identifica le colonne di dati da utilizzare per ordinare i risultati. Il controllo GridView, ad esempio, passa valori di ordinamento nella relativa proprietà SortExpression. Il controllo ObjectDataSource imposta il valore del parametro identificato dalla proprietà SortParameterName in base all'espressione di ordinamento passata a quest'ultima. L'espressione di ordinamento è in grado di specificare più colonne. In questo caso, i nomi delle colonne sono separati da virgole. Per specificare un ordine decrescente, l'espressione di ordinamento può includere il nome di una colonna di ordinamento seguito dal modificatore DESC. Ad esempio, l'espressione di ordinamento che identifica le colonne LastName e FirstName come colonne da utilizzare per l'ordinamento è "LastName, FirstName" per l'ordine crescente e "LastName, FirstName DESC" per l'ordine decrescente.
Identificazione dei parametri di spostamento
È possibile specificare parametri aggiuntivi per un metodo Select per l'identificazione di una pagina di dati da restituire. Il controllo ObjectDataSource supporta due proprietà che identificano i parametri di spostamento:
La proprietà StartRowIndexParameterName identifica il nome di un parametro nel metodo di selezione dell'oggetto business che viene utilizzato per specificare la riga iniziale della pagina di dati.
La proprietà MaximumRowsParameterName identifica il nome di un parametro nel metodo di selezione dell'oggetto business che viene utilizzato per specificare il numero di righe della pagina di dati.
Entrambi i parametri identificati dalle proprietà StartRowIndexParameterName e MaximumRowsParameterName sono del tipo Int32.
Nell'esempio di codice riportato di seguito viene illustrato un controllo ObjectDataSource configurato per passare i parametri di ordinamento e spostamento al metodo Select dell'oggetto business specificato.
<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>
Nell'esempio di codice riportato di seguito viene illustrato il metodo dell'oggetto business Select chiamato nell'esempio precedente. Il metodo dell'oggetto business restituisce una pagina di dati dal database di esempio Northwind, disposti secondo l'ordine specificato.
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;
}
}
}
Direzione dei parametri
Per impostazione predefinita, tutti i parametri per i metodi degli oggetti business sono parametri di input. Se il metodo dell'oggetto business include un parametro out che restituisce un valore al controllo ObjectDataSource, è necessario specificare esplicitamente un parametro con una direzione, come descritto in Utilizzo di parametri con controlli origine dati.
Nell'esempio di codice riportato di seguito viene illustrato un controllo ObjectDataSource configurato per accettare un parametro di output di tipo Int32. Il parametro di output restituisce un valore di chiave primaria generato automaticamente dal metodo specificato dalla proprietà 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>
Nell'esempio di codice riportato di seguito viene illustrato il metodo dell'oggetto business Insert che restituisce il valore della chiave primaria come parametro out:
<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;
}
Tipi di dati dei parametri
Per impostazione predefinita, tutti i parametri per i metodi degli oggetti business sono tipizzati come Object. Se il metodo dell'oggetto business include parametri appartenenti a tipi diversi, è necessario specificare esplicitamente parametri fortemente tipizzati. Per informazioni dettagliate, vedere Utilizzo di parametri con controlli origine dati.
Passaggio di tipi di parametri personalizzati
La maggior parte delle firme dei metodi degli oggetti business accetta parametri di tipo String e Int32. È tuttavia possibile che venga utilizzato un metodo di oggetto business che accetta uno o più parametri tipizzati come tipo complesso o definito dall'utente. Per utilizzare tipi di parametri complessi o definiti dall'utente, è possibile utilizzare la proprietà DataObjectTypeName del controllo ObjectDataSource.
Nell'oggetto business, la creazione di metodi con lunghi elenchi di parametri che associano valori di controllo a valori dell'archivio dati secondo una relazione uno a uno può rendere il codice difficilmente riutilizzabile. Una soluzione efficace consiste nell'incapsulare i dati in una classe personalizzata, quindi passare un'istanza di tale classe come parametro. In questo modo, è possibile modificare i dati che costituiscono un'istanza della classe, ad esempio il record relativo a un dipendente, senza che sia necessario intervenire in alcun modo sulle interfacce pubbliche esposte dall'oggetto origine dati. Nell'esempio di codice riportato di seguito viene illustrata una classe denominata NorthwindExployee che definisce i dati relativi al dipendente e che può essere passata come parametro a un oggetto business.
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
Per accettare un'istanza della classe precedente come parametro, il metodo UpdateEmployeeInfo dell'oggetto business potrebbe essere definito mediante la firma seguente:
public void UpdateEmployeeInfo(NorthwindEmployee emp) {
}
Public Sub UpdateEmployeeInfo(emp As NorthwindEmployee)
End Sub
Sebbene non sia possibile impostare il Type di un parametro sul nome di una classe personalizzata, è possibile impostare la proprietà DataObjectTypeName del controllo ObjectDataSource sul nome di un tipo definito dall'utente, ad esempio la classe NorthwindEmployee, quindi passare un'istanza di tale tipo a un metodo dati di un oggetto business. Per passare oggetti definiti dall'utente a un oggetto origine dati, è necessario che siano soddisfatte le condizioni seguenti:
Il tipo definito dall'utente deve avere un costruttore predefinito che non accetta parametri.
Il tipo definito dall'utente deve definire proprietà pubbliche i cui nomi corrispondano a quelli delle voci di dizionario passate al controllo origine dati dai controlli con associazione a dati, quali GridView e DetailsView. Per informazioni su tali dizionari, vedere Utilizzo di parametri con controlli origine dati.
Le proprietà pubbliche dell'oggetto origine dati devono esporre sia la funzione di accesso get che la funzione di accesso set.
Nell'esempio riportato di seguito viene illustrato un controllo ObjectDataSource che esegue un'operazione di aggiornamento mediante la chiamata al metodo UpdateEmployeeInfo di un oggetto business denominato EmployeeLogic. Il controllo ObjectDataSource è configurato per passare un'istanza della classe NorthwindEmployee al metodo di aggiornamento.
<asp:objectdatasource
id="ObjectDataSource1"
typename="EmployeeLogic"
selectmethod="GetAllEmployees"
updatemethod="UpdateEmployeeInfo"
dataobjecttypename="NorthwindEmployee" />
In alcuni casi, il metodo dell'oggetto business avrà un elenco di parametri contenente più tipi di parametri complessi. In questo caso, è possibile utilizzare il controllo ObjectDataSource ma è necessario aggiungere i parametri al controllo ObjectDataSource a livello di codice. A tale scopo, gestire l'evento generato prima che venga eseguita l'operazione sui dati, ad esempio l'evento Inserting, Updating o Deleting, e impostare i valori nell'insieme InputParameters esposto dalla classe ObjectDataSourceMethodEventArgs.