Procedura: eseguire il mapping di relazioni tra databaseHow to: Map Database Relationships

Qualsiasi relazione tra i dati, che rimane prevedibilmente sempre la stessa, può essere codificata come riferimenti alla proprietà nella classe di entità.You can encode as property references in your entity class any data relationships that will always be the same. Nel database di esempio Northwind, ad esempio, poiché in genere i clienti effettuano ordini, nel modello è sempre presente una relazione tra clienti e ordini.In the Northwind sample database, for example, because customers typically place orders, there is always a relationship in the model between customers and their orders.

LINQ to SQLLINQ to SQL definisce un AssociationAttribute attributo consentono di rappresentare tali relazioni. defines an AssociationAttribute attribute to help represent such relationships. Questo attributo viene usato insieme ai tipi EntitySet<TEntity> e EntityRef<TEntity> per rappresentare quello che in un database sarebbe una relazione di chiave esterna.This attribute is used together with the EntitySet<TEntity> and EntityRef<TEntity> types to represent what would be a foreign key relationship in a database. Per ulteriori informazioni, vedere la sezione relativa all'attributo Association Mapping basato sugli attributi.For more information, see the Association Attribute section of Attribute-Based Mapping.

Nota

I valori delle proprietà di archiviazione AssociationAttribute e ColumnAttribute rispettano la distinzione tra maiuscole e minuscole.AssociationAttribute and ColumnAttribute Storage property values are case sensitive. Verificare, ad esempio, che per i valori dell'attributo della proprietà AssociationAttribute.Storage venga usata la stessa combinazione di maiuscole e minuscole adoperata per i nomi di proprietà corrispondenti usati in altri punti del codice.For example, ensure that values used in the attribute for the AssociationAttribute.Storage property match the case for the corresponding property names used elsewhere in the code. Questo vale per tutti i linguaggi di programmazione .NET, anche quelli che non sono in genere tra maiuscole e minuscole, tra cui Visual Basic.This applies to all .NET programming languages, even those which are not typically case sensitive, including Visual Basic. Per altre informazioni sulla proprietà di archiviazione, vedere DataAttribute.Storage.For more information about the Storage property, see DataAttribute.Storage.

La maggior parte delle relazioni è di tipo uno-a-molti, come nell'esempio riportato più avanti in questo argomento.Most relationships are one-to-many, as in the example later in this topic. È anche possibile rappresentare relazioni uno-a-uno e molti-a-molti come segue:You can also represent one-to-one and many-to-many relationships as follows:

  • Uno-a-uno: per rappresentare questo tipo di relazione includere EntitySet<TEntity> su entrambi i lati.One-to-one: Represent this kind of relationship by including EntitySet<TEntity> on both sides.

    Si consideri ad esempio un Customer - SecurityCode creati in modo che non verrà trovato il codice di sicurezza del cliente relazione la Customer tabella ed è possibile accedervi solo da persone autorizzate.For example, consider a Customer-SecurityCode relationship, created so that the customer's security code will not be found in the Customer table and can be accessed only by authorized persons.

  • Molti-a-molti: In relazioni molti-a-molti, la chiave primaria della tabella di collegamento (denominato anche il giunzione tabella) è spesso formata da una combinazione di chiavi esterne delle altre due tabelle.Many-to-many: In many-to-many relationships, the primary key of the link table (also named the junction table) is often formed by a composite of the foreign keys from the other two tables.

    Si consideri ad esempio un Employee - Project relazione molti-a-molti con tabella di collegamento EmployeeProject.For example, consider an Employee-Project many-to-many relationship formed by using link table EmployeeProject. In LINQ to SQLLINQ to SQL è necessario che tale relazione venga modellata usando tre classi:Employee, Project e EmployeeProject.LINQ to SQLLINQ to SQL requires that such a relationship be modeled by using three classes: Employee, Project, and EmployeeProject. In questo caso la modifica della relazione tra Employee e Project può apparentemente richiedere un aggiornamento della chiave primaria di EmployeeProject.In this case, changing the relationship between an Employee and a Project can appear to require an update of the primary key EmployeeProject. In questa situazione, tuttavia, è preferibile modellare la relazione eliminando una classe EmployeeProject esistente e creando una nuova classe EmployeeProject.However, this situation is best modeled as deleting an existing EmployeeProject and the creating a new EmployeeProject.

    Nota

    Le relazioni nei database relazionali vengono in genere modellate come valori di chiave esterna che fanno riferimento a chiavi primarie in altre tabelle.Relationships in relational databases are typically modeled as foreign key values that refer to primary keys in other tables. Per spostarsi tra di esse è possibile associare in modo esplicito le due tabelle utilizzando relazionale join operazione.To navigate between them you explicitly associate the two tables by using a relational join operation.

    Gli oggetti in LINQ to SQLLINQ to SQL, d'altra parte, fanno riferimento reciproco usando riferimenti alle proprietà o raccolte di riferimenti che è possibile spostarsi utilizzando punto notazione.Objects in LINQ to SQLLINQ to SQL, on the other hand, refer to each other by using property references or collections of references that you navigate by using dot notation.

EsempioExample

Nell'esempio uno-a-molti seguente, alla classe Customer è associata una proprietà che dichiara la relazione tra clienti e ordini.In the following one-to-many example, the Customer class has a property that declares the relationship between customers and their orders. La proprietà Orders è di tipo EntitySet<TEntity>.The Orders property is of type EntitySet<TEntity>. Questo tipo significa che si tratta di una relazione uno-a-molti (un cliente a molti ordini).This type signifies that this relationship is one-to-many (one customer to many orders). La proprietà OtherKey viene usata per descrivere come viene eseguita questa associazione, ovvero specificando il nome della proprietà nella classe correlata che dovrà essere confrontata con questa.The OtherKey property is used to describe how this association is accomplished, namely, by specifying the name of the property in the related class to be compared with this one. In questo esempio, il CustomerID proprietà verrà confrontata, come un database join verrebbe confrontato il valore di tale colonna.In this example, the CustomerID property is compared, just as a database join would compare that column value.

Nota

Se si utilizza Visual Studio, è possibile utilizzare il Object Relational DesignerObject Relational Designer per creare un'associazione tra classi.If you are using Visual Studio, you can use the Object Relational DesignerObject Relational Designer to create an association between classes.

[Table(Name = "Customers")]
public partial class Customer
{
    [Column(IsPrimaryKey = true)]
    public string CustomerID;
    // ...
    private EntitySet<Order> _Orders;
    [Association(Storage = "_Orders", OtherKey = "CustomerID")]
    public EntitySet<Order> Orders
    {
        get { return this._Orders; }
        set { this._Orders.Assign(value); }
    }
}
<Table(Name:="Customers")> _
Public Class Customer
    <Column(IsPrimaryKey:=True)> _
Public CustomerID As String
    ' ...
    Private _Orders As EntitySet(Of Order)
    <Association(Storage:="_Orders", OtherKey:="CustomerID")> _
    Public Property Orders() As EntitySet(Of Order)
        Get
            Return Me._Orders
        End Get
        Set(ByVal value As EntitySet(Of Order))
            Me._Orders.Assign(value)
        End Set
    End Property
End Class

EsempioExample

È anche possibile invertire la situazione.You can also reverse the situation. Anziché usare la classe Customer per descrivere l'associazione tra clienti e ordini, è possibile usare la classe Order.Instead of using the Customer class to describe the association between customers and orders, you can use the Order class. La classe Order usa il tipo EntityRef<TEntity> per descrivere la relazione con la classe Customer, come nell'esempio di codice seguente.The Order class uses the EntityRef<TEntity> type to describe the relationship back to the customer, as in the following code example.

Nota

Il EntityRef<TEntity> classe supporta il caricamento posticipato.The EntityRef<TEntity> class supports deferred loading. Per ulteriori informazioni, vedere posticipata e il caricamento immediato.For more information, see Deferred versus Immediate Loading.

[Table(Name = "Orders")]
public class Order
{
    [Column(IsPrimaryKey = true)]
    public int OrderID;
    [Column]
    public string CustomerID;
    private EntityRef<Customer> _Customer;
    [Association(Storage = "_Customer", ThisKey = "CustomerID")]
    public Customer Customer
    {
        get { return this._Customer.Entity; }
        set { this._Customer.Entity = value; }
    }
}
<Table(Name:="Orders")> _
Public Class Order
    <Column(IsPrimaryKey:=True)> _
    Public OrderID As Integer
    <Column()> _
    Public CustomerID As String
    Private _Customer As EntityRef(Of Customer)
    <Association(Storage:="Customer", ThisKey:="CustomerID")> _
    Public Property Customer() As Customer
        Get
            Return Me._Customer.Entity
        End Get
        Set(ByVal value As Customer)
            Me._Customer.Entity = value
        End Set
    End Property
End Class

Vedere ancheSee Also

Procedura: personalizzare classi di entità mediante l'Editor del codiceHow to: Customize Entity Classes by Using the Code Editor
Modello a oggetti LINQ to SQLThe LINQ to SQL Object Model