A LINQ–SQL-objektummodell
A LINQ-ban az SQL-ben a fejlesztő programozási nyelvén kifejezett objektummodell egy relációs adatbázis adatmodelljének felel meg. Az adatokon végzett műveletek ezután az objektummodellnek megfelelően zajlanak.
Ebben a forgatókönyvben nem ad ki adatbázis-parancsokat (például INSERT) az adatbázisnak. Ehelyett módosítja az értékeket, és metódusokat hajt végre az objektummodellben. Ha le szeretné kérdezni az adatbázist, vagy módosításokat szeretne küldeni, a LINQ az SQL-nek lefordítja a kéréseket a megfelelő SQL-parancsokra, és elküldi ezeket a parancsokat az adatbázisnak.
A LINQ–SQL-objektummodell legalapvetőbb elemeit és a relációs adatmodell elemeihez való viszonyukat az alábbi táblázat foglalja össze:
| LINQ–SQL-objektummodell | Relációs adatmodell |
|---|---|
| Entitásosztály | Tábla |
| Osztálytag | Oszlop |
| Association | Idegenkulcs-kapcsolat |
| Metódus | Tárolt eljárás vagy függvény |
Feljegyzés
Az alábbi leírások feltételezik, hogy alapszintű ismeretekkel rendelkezik a relációs adatmodellről és -szabályokról.
LINQ–SQL-entitásosztályok és adatbázistáblák
A LINQ-ban az SQL-ben egy adatbázistáblát egy entitásosztály jelöl. Az entitásosztályok olyanok, mint bármely más létrehozható osztály, azzal a kivétellel, hogy az osztályt egy adatbázistáblához társító speciális információk használatával jegyzeteli az osztályt. Ezt a megjegyzést úgy teheti meg, hogy hozzáad egy egyéni attribútumot (TableAttribute) az osztálydeklarációhoz, ahogyan az alábbi példában is látható:
Példa
[Table(Name = "Customers")]
public class Customerzz
{
public string CustomerID;
// ...
public string City;
}
<Table(Name:="Customers")> _
Public Class Customer
Public CustomerID As String
' ...
Public City As String
End Class
Csak táblákként deklarált osztályok (vagyis entitásosztályok) példányai menthetők az adatbázisba.
További információ: Az attribútumalapú leképezés Táblaattribútum szakasza.
LINQ–SQL-osztálytagok és adatbázisoszlopok
Az osztályok táblákkal való társítása mellett mezőket vagy tulajdonságokat is kijelölhet az adatbázisoszlopok megjelenítéséhez. Erre a célra a LINQ to SQL határozza meg az ColumnAttribute attribútumot, ahogyan az alábbi példában is látható:
Példa
[Table(Name = "Customers")]
public class Customer
{
[Column(IsPrimaryKey = true)]
public string CustomerID;
[Column]
public string City;
}
<Table(Name:="Customers")> _
Public Class Customer
<Column(IsPrimaryKey:=True)> _
Public CustomerID As String
<Column()> _
Public City As String
End Class
A rendszer csak az oszlopokhoz hozzárendelt mezőket és tulajdonságokat őrizi meg, illetve kéri le az adatbázisból. A nem oszlopként deklaráltakat az alkalmazáslogika átmeneti részeinek tekintjük.
Az ColumnAttribute attribútum számos olyan tulajdonsággal rendelkezik, amelyekkel testre szabhatja ezeket az oszlopokat képviselő tagokat (például tagokat jelölhet elsődleges kulcsoszlopként). További információ: Az attribútumalapú leképezés Oszlopattribútum szakasza.
LINQ–SQL-társítások és az adatbázis idegenkulcsú kapcsolatai
A LINQ-ban az SQL-ben az attribútum alkalmazásával AssociationAttribute az adatbázis-társításokat (például az elsődleges kulcs kapcsolataihoz tartozó idegenkulcsot) kell képviselnie. A kód következő szegmensében az Order osztály egy Customer attribútummal AssociationAttribute rendelkező tulajdonságot tartalmaz. Ez a tulajdonság és attribútuma kapcsolatot biztosít az Order osztálynak az Customer osztálysal.
Az alábbi példakód az Customer osztály tulajdonságát Order mutatja be.
Példa
[Association(Name="FK_Orders_Customers", Storage="_Customer", ThisKey="CustomerID", IsForeignKey=true)]
public Customer Customer
{
get
{
return this._Customer.Entity;
}
set
{
Customer previousValue = this._Customer.Entity;
if (((previousValue != value)
|| (this._Customer.HasLoadedOrAssignedValue == false)))
{
this.SendPropertyChanging();
if ((previousValue != null))
{
this._Customer.Entity = null;
previousValue.Orders.Remove(this);
}
this._Customer.Entity = value;
if ((value != null))
{
value.Orders.Add(this);
this._CustomerID = value.CustomerID;
}
else
{
this._CustomerID = default(string);
}
this.SendPropertyChanged("Customer");
}
}
}
<Association(Name:="FK_Orders_Customers", Storage:="_Customer", ThisKey:="CustomerID", IsForeignKey:=true)> _
Public Property Customer() As Customer
Get
Return Me._Customer.Entity
End Get
Set
Dim previousValue As Customer = Me._Customer.Entity
If (((previousValue Is value) _
= false) _
OrElse (Me._Customer.HasLoadedOrAssignedValue = false)) Then
Me.SendPropertyChanging
If ((previousValue Is Nothing) _
= false) Then
Me._Customer.Entity = Nothing
previousValue.Orders.Remove(Me)
End If
Me._Customer.Entity = value
If ((value Is Nothing) _
= false) Then
value.Orders.Add(Me)
Me._CustomerID = value.CustomerID
Else
Me._CustomerID = CType(Nothing, String)
End If
Me.SendPropertyChanged("Customer")
End If
End Set
End Property
További információt az Attribútumalapú leképezés társítási attribútum szakaszában talál.
LINQ–SQL-metódusok és adatbázis által tárolt eljárások
A LINQ–SQL támogatja a tárolt eljárásokat és a felhasználó által definiált függvényeket. A LINQ-ban az SQL-hez az adatbázis által definiált absztrakciókat ügyfélobjektumokhoz rendeli, így az ügyfélkódból szigorúan beírt módon érheti el őket. A metódus-aláírások a lehető legszorosabban hasonlítanak az adatbázisban meghatározott eljárások és függvények aláírására. Az IntelliSense segítségével felderítheti ezeket a módszereket.
A leképezett eljárás hívása által visszaadott eredményhalmaz egy erősen beírt gyűjtemény.
A LINQ–SQL a tárolt eljárásokat és függvényeket a metódusokhoz rendeli az attribútumok és ParameterAttribute az FunctionAttribute attribútumok használatával. A tárolt eljárásokat képviselő metódusokat a tulajdonság megkülönbözteti a IsComposable felhasználó által definiált függvényeket képviselő metódusoktól. Ha ez a tulajdonság (alapértelmezett) értékre false van állítva, a metódus egy tárolt eljárást jelöl. Ha be van állítva true, a metódus egy adatbázisfüggvényt jelöl.
Feljegyzés
Ha Visual Studiót használ, az Object Relational Tervező használatával létrehozhat olyan metódusokat, amelyek a tárolt eljárásokhoz és a felhasználó által definiált függvényekhez vannak leképezve.
Példa
// This is an example of a stored procedure in the Northwind
// sample database. The IsComposable property defaults to false.
[Function(Name="dbo.CustOrderHist")]
public ISingleResult<CustOrderHistResult> CustOrderHist([Parameter(Name="CustomerID", DbType="NChar(5)")] string customerID)
{
IExecuteResult result = this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod())), customerID);
return ((ISingleResult<CustOrderHistResult>)(result.ReturnValue));
}
' This is an example of a stored procedure in the Northwind
' sample database. The IsComposable property defaults to false.
<FunctionAttribute(Name:="dbo.CustOrderHist")> _
Public Function CustOrderHist(<Parameter(Name:="CustomerID", DbType:="NChar(5)")> ByVal customerID As String) As ISingleResult(Of CustOrderHistResult)
Dim result As IExecuteResult = Me.ExecuteMethodCall(Me, CType(MethodInfo.GetCurrentMethod, MethodInfo), customerID)
Return CType(result.ReturnValue, ISingleResult(Of CustOrderHistResult))
End Function
További információt az attribútumalapú leképezés és a tárolt eljárások függvényattribútumával, tárolt eljárás attribútumával és paraméterattribútumával kapcsolatos szakaszában talál.