Dela via

LINQ-till-SQL-objektmodellen

  • Artikel

I LINQ till SQL mappas en objektmodell som uttrycks i utvecklarens programmeringsspråk till datamodellen för en relationsdatabas. Åtgärder på data utförs sedan enligt objektmodellen.

I det här scenariot utfärdar du inte databaskommandon (till exempel INSERT) till databasen. I stället ändrar du värden och kör metoder i objektmodellen. När du vill köra frågor mot databasen eller skicka ändringarna översätter LINQ till SQL dina begäranden till rätt SQL-kommandon och skickar dessa kommandon till databasen.

Screenshot that shows the Linq Object Model.

De mest grundläggande elementen i LINQ-till SQL-objektmodellen och deras relation till element i relationsdatamodellen sammanfattas i följande tabell:

LINQ till SQL-objektmodell Relationsdatamodell
Entitetsklass Register
Klassmedlem Column
Koppling Sekundärnyckelrelation
Metod Lagrad procedur eller funktion

Kommentar

Följande beskrivningar förutsätter att du har grundläggande kunskaper om relationsdatamodellen och reglerna.

LINQ till SQL-entitetsklasser och databastabeller

I LINQ till SQL representeras en databastabell av en entitetsklass. En entitetsklass är som alla andra klasser som du kan skapa, förutom att du kommenterar klassen med hjälp av särskild information som associerar klassen med en databastabell. Du gör den här kommentaren genom att lägga till ett anpassat attribut (TableAttribute) i din klassdeklaration, som i följande exempel:

Exempel

[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

Endast instanser av klasser som deklarerats som tabeller (dvs. entitetsklasser) kan sparas i databasen.

Mer information finns i avsnittet Tabellattribut i Attributbaserad mappning.

LINQ till SQL-klassmedlemmar och databaskolumner

Förutom att associera klasser med tabeller anger du fält eller egenskaper som ska representera databaskolumner. För detta ändamål definierar ColumnAttribute LINQ till SQL attributet, som i följande exempel:

Exempel

[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

Endast fält och egenskaper som mappas till kolumner sparas eller hämtas från databasen. De som inte deklareras som kolumner betraktas som tillfälliga delar av programlogik.

Attributet ColumnAttribute har en mängd olika egenskaper som du kan använda för att anpassa dessa medlemmar som representerar kolumner (till exempel att utse en medlem som representerar en primär nyckelkolumn). Mer information finns i avsnittet Kolumnattribut i Attributbaserad mappning.

LINQ till SQL-associationer och databas med sekundärnyckelrelationer

I LINQ till SQL representerar du databasassociationer (till exempel sekundärnyckel till primärnyckelrelationer) genom att använda AssociationAttribute attributet. I följande kodsegment Order innehåller klassen en Customer egenskap som har ett AssociationAttribute attribut. Den här egenskapen och dess attribut ger Order klassen en relation till Customer klassen.

I följande kodexempel visas egenskapen Customer från Order klassen.

Exempel

[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

Mer information finns i avsnittet Associationsattribut i Attributbaserad mappning.

LINQ till SQL-metoder och databas lagrade procedurer

LINQ till SQL stöder lagrade procedurer och användardefinierade funktioner. I LINQ till SQL mappar du dessa databasdefinierade abstraktioner till klientobjekt så att du kan komma åt dem på ett starkt skrivet sätt från klientkoden. Metodsignaturerna liknar så nära som möjligt signaturerna för de procedurer och funktioner som definieras i databasen. Du kan använda IntelliSense för att identifiera dessa metoder.

En resultatuppsättning som returneras av ett anrop till en mappad procedur är en starkt skriven samling.

LINQ till SQL mappar lagrade procedurer och funktioner till metoder med hjälp av attributen FunctionAttribute och ParameterAttribute . Metoder som representerar lagrade procedurer skiljer sig från de som representerar användardefinierade funktioner av IsComposable egenskapen. Om den här egenskapen är inställd på false (standard) representerar metoden en lagrad procedur. Om den är inställd på truerepresenterar metoden en databasfunktion.

Kommentar

Om du använder Visual Studio kan du använda Objektrelationsdesignern för att skapa metoder som mappats till lagrade procedurer och användardefinierade funktioner.

Exempel

// 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

Mer information finns i avsnitten Funktionsattribut, Lagrat procedurattribut och Parameterattribut i Attributbaserad mappning och lagrade procedurer.

Se även