Objektový model LINQ to SQL

V LINQ to SQL je objektový model vyjádřený v programovacím jazyce vývojáře mapován na datový model relační databáze. Operace s daty se pak provádějí podle objektového modelu.

V tomto scénáři nesdělíte databázové příkazy (například INSERT) do databáze. Místo toho změníte hodnoty a spustíte metody v rámci objektového modelu. Pokud chcete dotazovat databázi nebo ji odeslat, LINQ to SQL přeloží vaše požadavky na správné příkazy SQL a odešle tyto příkazy do databáze.

Nejdůležitější prvky objektového modelu LINQ to SQL a jejich vztah k prvkům v relačním datovém modelu jsou shrnuty v následující tabulce:

Objektový model LINQ to SQL	Relační datový model
Třída entity	Table
Člen třídy	Column
Přidružení	Vztah cizího klíče
metoda	Uložená procedura nebo funkce

Poznámka:

Následující popis předpokládá, že máte základní znalosti relačního datového modelu a pravidel.

TŘÍDY entit LINQ to SQL a databázové tabulky

V LINQ to SQL je tabulka databáze reprezentována třídou entity. Třída entity je podobná jakékoli jiné třídě, kterou můžete vytvořit s tím rozdílem, že třídu označíte pomocí speciálních informací, které třídu přidruží k databázové tabulce. Tuto poznámku vytvoříte přidáním vlastního atributu (TableAttribute) do deklarace třídy, jak je znázorněno v následujícím příkladu:

Příklad

[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

Do databáze lze uložit pouze instance tříd deklarovaných jako tabulky (tj. třídy entit).

Další informace naleznete v části Atribut tabulky mapování na základě atributů.

LinQ to SQL – členy tříd a databázové sloupce

Kromě přidružení tříd k tabulkám určíte pole nebo vlastnosti, které budou představovat sloupce databáze. Pro tento účel linQ to SQL definuje ColumnAttribute atribut, jako v následujícím příkladu:

Příklad

[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

Pouze pole a vlastnosti mapované na sloupce se uchovávají nebo načítají z databáze. Ty, které nejsou deklarovány jako sloupce, se považují za přechodné části logiky aplikace.

Atribut ColumnAttribute má řadu vlastností, které můžete použít k přizpůsobení těchto členů, které představují sloupce (například určení člena jako reprezentace sloupce primárního klíče). Další informace najdete v části Atribut sloupce mapování na základě atributů.

Relace LINQ to SQL a relace cizích klíčů databáze

V LINQ to SQL představujete přidružení databáze (například vztahy cizího klíče k primárnímu klíči) použitím atributu AssociationAttribute . V následujícím segmentu kódu Order třída obsahuje Customer vlastnost, která má AssociationAttribute atribut. Tato vlastnost a její atribut poskytují Order třídu se vztahem ke Customer třídě.

Následující příklad kódu ukazuje Customer vlastnost z Order třídy.

Příklad

[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

Další informace naleznete v části Atribut přidružení mapování na základě atributů.

Metody LINQ to SQL a uložené procedury databáze

LINQ to SQL podporuje uložené procedury a uživatelem definované funkce. V LINQ to SQL namapujete tyto abstrakce definované databází na klientské objekty, abyste k nim měli přístup silně napsaným způsobem z klientského kódu. Podpisy metody se podobají co nejblíže podpisům procedur a funkcí definovaných v databázi. Tyto metody můžete zjistit pomocí technologie IntelliSense.

Sada výsledků vrácená voláním mapované procedury je kolekce silného typu.

LINQ to SQL mapuje uložené procedury a funkce na metody pomocí FunctionAttribute atributů.ParameterAttribute Metody představující uložené procedury jsou odlišeny od těch, které představují uživatelem definované funkce vlastností IsComposable . Pokud je tato vlastnost nastavena ( false výchozí), metoda představuje uloženou proceduru. Pokud je nastavena na true, metoda představuje databázovou funkci.

Poznámka:

Pokud používáte Visual Studio, můžete pomocí Návrhář relací objektů vytvořit metody mapované na uložené procedury a uživatelem definované funkce.

Příklad

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

Další informace naleznete v části Atribut funkce, Uložená procedura Atribut a Atribut parametru mapování a uložené procedury.

Viz také

• Mapování na základě atributů
• Základní informace