Utilisation de paramètres avec le contrôle ObjectDataSource
Mise à jour : novembre 2007
Le contrôle ObjectDataSource appelle des méthodes d'objet métier en fonction du nom de méthode identifié dans la propriété SelectMethod, InsertMethod, UpdateMethod ou DeleteMethod et également en fonction des noms de paramètres qui constituent la signature de la méthode d'objet métier. Lorsque vous créez des méthodes dans un objet métier, vous devez veiller à ce que les noms et types des paramètres acceptés par la méthode de l'objet métier correspondent aux noms et types des paramètres passés par le contrôle ObjectDataSource. (L'ordre des paramètres n'est pas important.)
Utilisation de paramètres
À l'instar de tous les contrôles de source de données, le contrôle ObjectDataSource accepte des paramètres d'entrée au moment de l'exécution et les gère dans des collections de paramètres. Chaque opération de données possède une collection de paramètres associée. Pour les opérations de sélection, vous pouvez utiliser la collection SelectParameters, pour les mises à jour, la collection UpdateParameters, etc.
Vous pouvez spécifier un nom, un type, une direction et une valeur par défaut pour chaque paramètre. Dans le cas de paramètres qui obtiennent des valeurs d'un objet spécifique, tel qu'un contrôle, une variable de session ou le profil utilisateur, vous devez définir des propriétés supplémentaires. Par exemple, pour un objet ControlParameter, vous devez définir la propriété ControlID afin d'identifier le contrôle qui prend la valeur de paramètre et définir la propriété PropertyName pour identifier la propriété qui contient la valeur de paramètre. Pour plus d'informations, consultez Utilisation de paramètres avec des contrôles de source de données.
L'exemple de code suivant illustre une méthode Select qui peut être appelée par un contrôle ObjectDataSource. La méthode prend un paramètre et sélectionne un seul enregistrement de la source de données.
<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;
}
Transmission de paramètres à des méthodes Insert, Update et Delete
Le contrôle ObjectDataSource détermine la méthode à appeler pour une opération d'insertion, de mise à jour ou de suppression en fonction de leur collection InsertParameters, UpdateParameters ou DeleteParameters respective. En outre, le contrôle ObjectDataSource crée automatiquement des paramètres selon les valeurs passées par un contrôle lié aux données, par exemple un contrôle GridView ou FormView, qui prend en charge les opérations de mise à jour, d'insertion et de suppression automatiques. Pour plus d'informations, consultez Comment un contrôle de source de données crée des paramètres pour des champs liés aux données.
L'exemple de code suivant illustre une méthode pouvant être appelée par un contrôle ObjectDataSource. La méthode met à jour des informations sur les employés dans l'exemple de base de données 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;
}
L'exemple de code suppose que la propriété ConflictDetection du contrôle ObjectDataSource a la valeur OverwriteChanges. Si la propriété ConflictDetection a la valeur CompareAllValues, la méthode d'objet métier doit accepter des paramètres pour les valeurs d'origine des champs de données. Vous pouvez différencier les paramètres pour les valeurs d'origine et actuelles à l'aide de la propriété OldValuesParameterFormatString. Vous affectez à la propriété OldValuesParameterFormatString une expression de chaîne qui est utilisée pour mettre en forme les noms des paramètres de valeurs d'origine, les caractères {0} représentant le nom du champ. Si, par exemple, vous affectez à la propriété OldValuesParameterFormatString la valeur original_{0}, la valeur actuelle d'un champ nommé FirstName est passée dans un paramètre nommé FirstName et la valeur d'origine du champ est passée dans un paramètre nommé original_FirstName.
Identification des paramètres de tri et de page
En plus de spécifier des objets SelectParameters pour une méthode d'objet métier Select, vous pouvez inclure des paramètres de tri et de page. Cela vous permet de trier des données dans l'objet source de données et de limiter les résultats retournés par votre objet source de données à la seule page de données demandée.
Identification d'un paramètre de tri
Vous pouvez spécifier un paramètre de tri pour une méthode d'objet métier Select à l'aide de la propriété SortParameterName du contrôle ObjectDataSource. La propriété SortParameterName identifie le nom du paramètre utilisé pour passer des noms de colonnes de tri à la méthode d'objet métier. Il s'agit d'un paramètre de type String.
Certains contrôles liés aux données, tels que le contrôle GridView, peuvent passer automatiquement des paramètres de tri au contrôle ObjectDataSource. Lorsqu'un contrôle lié aux données et prenant en charge le tri, est lié au contrôle ObjectDataSource, le contrôle lié aux données passe une expression de tri qui identifie les colonnes de données à utiliser pour trier les résultats. Par exemple, le contrôle GridView passe des valeurs de tri dans sa propriété SortExpression. Le contrôle ObjectDataSource définit la valeur du paramètre identifié par la propriété SortParameterName en fonction de l'expression de tri qui lui a été passée. Lorsque l'expression de tri spécifie plusieurs colonnes, les noms de colonnes sont séparés par des virgules. Pour spécifier un tri décroissant, l'expression de tri peut inclure un nom de colonne de tri suivi du modificateur DESC. Par exemple, une expression de tri qui identifie les colonnes LastName et FirstName comme colonnes à utiliser pour le tri peut être "LastName, FirstName" pour un tri croissant et "LastName, FirstName DESC" pour un tri décroissant.
Identification des paramètres de page
Vous pouvez spécifier des paramètres supplémentaires pour une méthode Select qui identifie la page de données à retourner. Le contrôle ObjectDataSource prend en charge deux propriétés qui identifient des paramètres de page :
La propriété StartRowIndexParameterName identifie le nom d'un paramètre dans la méthode Select de l'objet métier qui est utilisé pour spécifier la ligne de début de la page de données.
La propriété MaximumRowsParameterName identifie le nom d'un paramètre dans la méthode Select de l'objet métier qui est utilisé pour spécifier le nombre de lignes dans la page de données.
Les paramètres identifiés par les propriétés StartRowIndexParameterName et MaximumRowsParameterName sont tous deux de type Int32.
L'exemple de code suivant illustre un contrôle ObjectDataSource configuré pour passer des paramètres de tri et de page à la méthode Select de l'objet métier spécifié :
<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>
L'exemple de code suivant montre la méthode d'objet métier Select appelée dans l'exemple précédent. La méthode d'objet métier retourne une page de données de l'exemple de base de données Northwind, triées dans l'ordre spécifié.
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;
}
}
}
Direction du paramètre
Par défaut, tous les paramètres des méthodes d'objet métier sont des paramètres d'entrée. Si la méthode d'objet métier inclut un paramètre de sortie qui retourne une valeur au contrôle ObjectDataSource, vous devez spécifier explicitement un paramètre avec une direction de paramètre comme décrit dans Utilisation de paramètres avec des contrôles de source de données.
L'exemple de code suivant affiche un contrôle ObjectDataSource configuré pour accepter un paramètre de sortie de type Int32. Le paramètre de sortie retourne une valeur de clé primaire générée automatiquement à partir de la méthode spécifiée par la propriété 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>
L'exemple de code suivant illustre la méthode d'objet métier Insert qui retourne la valeur de clé primaire en tant que paramètre de sortie :
<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;
}
Types de données des paramètres
Par défaut, tous les paramètres des méthodes d'objet métier sont de type Object. Si votre méthode d'objet métier inclut des paramètres de types différents, vous devez spécifier explicitement des paramètres fortement typés. Pour plus d'informations, consultez Utilisation de paramètres avec des contrôles de source de données.
Transmission de types de paramètres personnalisés
La plupart des signatures de méthode d'objet métier prennent des paramètres de type String et Int32. Toutefois, il se peut que vous utilisiez une méthode d'objet métier qui prend un ou plusieurs paramètres de type complexe ou défini par l'utilisateur. Pour manipuler des types de paramètres complexes ou définis par l'utilisateur, vous pouvez utiliser la propriété DataObjectTypeName du contrôle ObjectDataSource.
Si vous créez, dans votre objet métier, des méthodes comportant de longues listes de paramètres avec des valeurs de contrôle mappées une à une avec des valeurs de magasin de données, votre code est souvent difficilement réutilisable. Une meilleure solution consiste à encapsuler vos données dans une classe personnalisée et puis de passer une instance de la classe comme paramètre. De cette façon, les données qui constituent une instance de la classe, comme un enregistrement d'employé, peuvent changer sans nécessiter la modification des interfaces publiques exposées par l'objet source de données. L'exemple de code suivant illustre une classe nommée NorthwindExployee qui définit les données d'employé et peut être passée en tant que paramètre à un objet métier.
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
Pour accepter une instance de la classe précédente comme paramètre, la méthode UpdateEmployeeInfo de l'objet métier peut être définie à l'aide de la signature suivante :
public void UpdateEmployeeInfo(NorthwindEmployee emp) {
}
Public Sub UpdateEmployeeInfo(emp As NorthwindEmployee)
End Sub
Bien que vous ne puissiez pas affecter à la propriété Type d'un paramètre le nom d'une classe personnalisée, vous pouvez affecter à la propriété DataObjectTypeName du contrôle ObjectDataSource le nom d'un type défini par l'utilisateur et personnalisé, tel que la classe NorthwindEmployee, puis passer une instance du type à une méthode de données de l'objet métier. Pour passer des objets définis par l'utilisateur à un objet source de données, les conditions suivantes doivent être satisfaites :
Le type défini par l'utilisateur doit avoir un constructeur par défaut (un constructeur qui ne prend pas de paramètres).
Le type défini par l'utilisateur doit définir des propriétés publiques dont les noms correspondent à ceux des entrées de dictionnaire passées au contrôle de source de données à partir de contrôles liés aux données, tels que GridView et DetailsView. Pour plus d'informations sur ces dictionnaires, consultez Utilisation de paramètres avec des contrôles de source de données.
Les propriétés publiques de l'objet source de données doivent exposer des accesseurs get et set.
L'exemple suivant illustre un contrôle ObjectDataSource qui exécute une opération de mise à jour en appelant la méthode UpdateEmployeeInfo d'un objet métier nommé EmployeeLogic. Le contrôle ObjectDataSource est configuré pour passer une instance de la classe NorthwindEmployee à la méthode de mise à jour.
<asp:objectdatasource
id="ObjectDataSource1"
typename="EmployeeLogic"
selectmethod="GetAllEmployees"
updatemethod="UpdateEmployeeInfo"
dataobjecttypename="NorthwindEmployee" />
Dans certains cas, la méthode de l'objet métier possède une liste de paramètres qui contient plusieurs types de paramètre complexes. Dans ce cas, vous pouvez utiliser le contrôle ObjectDataSource, mais vous devez ajouter vos paramètres au contrôle ObjectDataSource par programme. Pour ce faire, gérez l'événement qui est déclenché avant l'exécution de l'opération de données, par exemple l'événement Inserting, Updating ou Deleting, et définissez des valeurs dans la collection InputParameters exposée par la classe ObjectDataSourceMethodEventArgs.