Udostępnij za pośrednictwem

Model obiektów LINQ to SQL

W linQ to SQL model obiektów wyrażony w języku programowania dewelopera jest mapowany na model danych relacyjnej bazy danych. Operacje na danych są następnie przeprowadzane zgodnie z modelem obiektów.

W tym scenariuszu nie wydajesz poleceń bazy danych (na przykład INSERT) względem bazy danych. Zamiast tego zmieniasz wartości i wykonujesz metody w swoim modelu obiektów. Jeśli chcesz zapytać bazę danych lub przesłać do niej zmiany, LINQ to SQL tłumaczy twoje żądania na poprawne polecenia SQL i wysyła te polecenia do bazy danych.

Zrzut ekranu przedstawiający model obiektów Linq.

Najbardziej podstawowe elementy w modelu obiektów LINQ to SQL i ich relacje z elementami w modelu danych relacyjnych zostały podsumowane w poniższej tabeli:

Model Obiektowy LINQ to SQL Model danych relacyjnych
Klasa jednostki Tabela
Składowa klasy Kolumna
Stowarzyszenie Relacja klucza obcego
Metoda Procedura przechowywana lub funkcja

Uwaga / Notatka

W poniższych opisach założono, że masz podstawową wiedzę na temat modelu i reguł relacyjnych danych.

Klasy jednostek LINQ to SQL i tabele baz danych

W linQ to SQL tabela bazy danych jest reprezentowana przez klasę jednostek. Klasa obiektowa jest podobna do każdej innej klasy, którą można utworzyć, z tą różnicą, że adnotujesz klasę za pomocą specjalnych informacji, które kojarzą ją z tabelą bazy danych. Tę adnotację należy utworzyć, dodając atrybut niestandardowy (TableAttribute) do deklaracji klasy, jak w poniższym przykładzie:

Przykład

[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

W bazie danych można zapisywać tylko wystąpienia klas zadeklarowanych jako tabele (czyli klasy jednostek).

Aby uzyskać więcej informacji, zobacz sekcję Atrybut tabeli w Attribute-Based Mapowanie.

Członkowie klas LINQ to SQL oraz kolumny bazy danych

Oprócz kojarzenia klas z tabelami należy wyznaczyć pola lub właściwości reprezentujące kolumny bazy danych. W tym celu LINQ to SQL definiuje ColumnAttribute atrybut, jak w poniższym przykładzie:

Przykład

[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

Tylko pola i właściwości mapowane na kolumny są utrwalane lub pobierane z bazy danych. Te, które nie są deklarowane jako kolumny, są traktowane jako przejściowe części logiki aplikacji.

Atrybut ColumnAttribute ma różne właściwości, których można użyć do dostosowania tych elementów członkowskich reprezentujących kolumny (na przykład wyznaczenie elementu członkowskiego jako reprezentującego kolumnę klucza podstawowego). Aby uzyskać więcej informacji, zobacz sekcję "Atrybut kolumny" w Attribute-Based Mapowanie.

Skojarzenia LINQ to SQL i relacje klucza obcego z bazą danych

W linQ to SQL reprezentujesz skojarzenia bazy danych (takie jak relacje klucza obcego do klucza podstawowego AssociationAttribute ), stosując atrybut. W poniższym fragmencie kodu, klasa Order zawiera właściwość Customer z atrybutem AssociationAttribute. Ta właściwość i jej atrybut nawiązują relację między klasą Order a klasą Customer.

Poniższy przykład kodu pokazuje Customer właściwość z Order klasy.

Przykład

[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

Aby uzyskać więcej informacji, zobacz sekcję Atrybutu skojarzenia w Attribute-Based Mapowanie.

Metody LINQ to SQL oraz procedury składowane w bazie danych

LINQ to SQL obsługuje procedury składowane i funkcje zdefiniowane przez użytkownika. W LINQ to SQL mapujesz te abstrakcje zdefiniowane przez bazę danych na obiekty klienckie, aby uzyskać do nich dostęp w silnie typowany sposób z poziomu kodu klienta. Podpisy metody przypominają jak najbliżej podpisy procedur i funkcji zdefiniowanych w bazie danych. Aby odnaleźć te metody, możesz użyć funkcji IntelliSense.

Zestaw wyników zwracany przez wywołanie procedury mapowanej jest silnie typizowaną kolekcją.

LINQ to SQL mapuje procedury składowane i funkcje na metody przy użyciu atrybutów FunctionAttribute oraz ParameterAttribute. Metody reprezentujące procedury składowane różnią się od metod reprezentujących funkcje zdefiniowane przez użytkownika przez IsComposable właściwość . Jeśli ta właściwość jest ustawiona na false (wartość domyślna), metoda reprezentuje procedurę składowaną. Jeśli jest ustawiona na truewartość , metoda reprezentuje funkcję bazy danych.

Uwaga / Notatka

Jeśli używasz programu Visual Studio, możesz użyć Projektanta relacyjnego obiektów, aby utworzyć metody mapowane na procedury składowane i funkcje zdefiniowane przez użytkownika.

Przykład

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

Aby uzyskać więcej informacji, zobacz sekcje Atrybut funkcji, Atrybut procedury składowanej i Atrybut parametru Attribute-Based Mapowanie i Procedury składowane.

Zobacz także