Data bindingData Binding

LINQ to SQLLINQ to SQL supporta l'associazione ai controlli comuni, ad esempio i controlli griglia. supports binding to common controls, such as grid controls. In particolare, LINQ to SQLLINQ to SQL definisce i modelli di base per l'associazione a una griglia dei dati e la gestione dell'associazione master-Details, sia per quanto riguarda visualizzazione e aggiornamento.Specifically, LINQ to SQLLINQ to SQL defines the basic patterns for binding to a data grid and handling master-detail binding, both with regard to display and updating.

Principio sottostanteUnderlying Principle

LINQ to SQLLINQ to SQL traduce LINQLINQ query SQL per l'esecuzione in un database. translates LINQLINQ queries to SQL for execution on a database. I risultati sono costituiti da oggetti IEnumerable fortemente tipizzati.The results are strongly typed IEnumerable. Poiché questi oggetti sono oggetti common language runtime (CLR), è possibile utilizzare l'associazione di dati di oggetti comune per visualizzare i risultati.Because these objects are ordinary common language runtime (CLR) objects, ordinary object data binding can be used to display the results. Al contrario, le operazioni di modifica (inserimenti, aggiornamenti ed eliminazioni) richiedono passaggi aggiuntivi.On the other hand, change operations (inserts, updates, and deletes) require additional steps.

OperazioneOperation

L'associazione implicita ai controlli Windows Form viene eseguita implementando IListSource.Implicitly binding to Windows Forms controls is accomplished by implementing IListSource. Origini dati generiche Table<TEntity> (Table<T> in c# o Table(Of T) in Visual Basic) e generico DataQuery sono stati aggiornati per implementare IListSource.Data sources generic Table<TEntity> (Table<T> in C# or Table(Of T) in Visual Basic) and generic DataQuery have been updated to implement IListSource. I motori di associazione dati dell'interfaccia utente (Windows Form e Windows Presentation Foundation) verificano se le relative origini dati implementano IListSource.User interface (UI) data-binding engines (Windows Forms and Windows Presentation Foundation) both test whether their data source implements IListSource. Pertanto, la scrittura di una simulazione diretta di una query a un'origine dati di un controllo in modo implicito chiamate LINQ to SQLLINQ to SQL generazione di una raccolta, come nell'esempio seguente:Therefore, writing a direct affectation of a query to a data source of a control implicitly calls LINQ to SQLLINQ to SQL collection generation, as in the following example:

DataGrid dataGrid1 = new DataGrid();
DataGrid dataGrid2 = new DataGrid();
DataGrid dataGrid3 = new DataGrid();

var custQuery =
    from cust in db.Customers
    select cust;
dataGrid1.DataSource = custQuery;
dataGrid2.DataSource = custQuery;
dataGrid2.DataMember = "Orders";

BindingSource bs = new BindingSource();
bs.DataSource = custQuery;
dataGrid3.DataSource = bs;
Dim dataGrid1 As New DataGrid()
Dim dataGrid2 As New DataGrid()
Dim dataGrid3 As New DataGrid()

Dim custQuery = _
    From cust In db.Customers _
    Select cust

dataGrid1.DataSource = custQuery
dataGrid2.DataSource = custQuery
dataGrid2.DataMember = "Orders"

Dim bs = _
    New BindingSource()
bs.DataSource = custQuery
dataGrid3.DataSource = bs

Lo stesso comportamento si verifica con Windows Presentation Foundation:The same occurs with Windows Presentation Foundation:

ListView listView1 = new ListView();
var custQuery2 =
    from cust in db.Customers
    select cust;

ListViewItem ItemsSource = new ListViewItem();
ItemsSource = (ListViewItem)custQuery2;
Dim listView1 As New ListView()
Dim custQuery2 = _
From cust In db.Customers _
Select cust

Dim ItemsSource As New ListViewItem
ItemsSource = custQuery2

Le generazioni di raccolte vengono implementate dall'oggetto generico Table<TEntity> e dall'oggetto generico DataQuery in GetList.Collection generations are implemented by generic Table<TEntity> and generic DataQuery in GetList.

Implementazione di IListSourceIListSource Implementation

LINQ to SQLLINQ to SQL implementa IListSource in due posizioni: implements IListSource in two locations:

  • L'origine dati è un Table<TEntity>: LINQ to SQLLINQ to SQL esamina la tabella per riempire un DataBindingList insieme che mantiene un riferimento nella tabella.The data source is a Table<TEntity>: LINQ to SQLLINQ to SQL browses the table to fill a DataBindingList collection that keeps a reference on the table.

  • L'origine dati è un oggetto IQueryable<T>.The data source is an IQueryable<T>. Esistono due possibili scenari:There are two scenarios:

    • Se LINQ to SQLLINQ to SQL trova sottostante Table<TEntity> dal IQueryable<T>, l'origine consente la modifica e la situazione è analoga al primo punto.If LINQ to SQLLINQ to SQL finds the underlying Table<TEntity> from the IQueryable<T>, the source allows for edition and the situation is the same as in the first bullet point.

    • Se LINQ to SQLLINQ to SQL non è possibile trovare sottostante Table<TEntity>, l'origine non consente la modifica (ad esempio, groupby).If LINQ to SQLLINQ to SQL cannot find the underlying Table<TEntity>, the source does not allow for edition (for example, groupby). LINQ to SQLLINQ to SQL esamina la query per compilare un oggetto generico SortableBindingList, che corrisponde a un semplice BindingList<T> che implementa la funzionalità di ordinamento per le entità T di una determinata proprietà. browses the query to fill a generic SortableBindingList, which is a simple BindingList<T> that implements the sorting feature for T entities for a given property.

Raccolte specializzateSpecialized Collections

Per molte funzionalità descritte in questo documento, BindingList<T> è stato specializzato per alcune classi diverse.For many features described earlier in this document, BindingList<T> has been specialized to some different classes. Tali classi, SortableBindingList e DataBindingList, sono di tipo genericoThese classes are generic SortableBindingList and generic DataBindingList. e vengono entrambe dichiarate come interne.Both are declared as internal.

SortableBindingList genericaGeneric SortableBindingList

Questa classe eredita da BindingList<T> ed è una versione ordinabile di BindingList<T>.This class inherits from BindingList<T>, and is a sortable version of BindingList<T>. L'ordinamento è una soluzione in memoria e non effettua mai la connessione al database.Sorting is an in-memory solution and never contacts the database itself. BindingList<T> implementa IBindingList ma non supporta l'ordinamento per impostazione predefinita.BindingList<T> implements IBindingList but does not support sorting by default. Tuttavia, BindingList<T> implementa IBindingList con virtuale core metodi.However, BindingList<T> implements IBindingList with virtual core methods. È possibile eseguire facilmente l'override di questi metodi.You can easily override these methods. La classe generica SortableBindingList esegue l'override di SupportsSortingCore, SortPropertyCore, SortDirectionCore e ApplySortCore.Generic SortableBindingList overrides SupportsSortingCore, SortPropertyCore, SortDirectionCore, and ApplySortCore. ApplySortCore viene chiamato da ApplySort e ordina l'elenco di elementi T per una determinata proprietà.ApplySortCore is called by ApplySort and sorts the list of T items for a given property.

Se la proprietà non appartiene a T, viene generata un'eccezione.An exception is raised if the property does not belong to T.

Per ottenere l'ordinamento, LINQ to SQLLINQ to SQL crea un oggetto generico SortableBindingList.PropertyComparer classe che eredita dalla classe generica IComparer.Compare e implementa un operatore di confronto predefinito per un determinato tipo T, PropertyDescriptore una direzione.To achieve sorting, LINQ to SQLLINQ to SQL creates a generic SortableBindingList.PropertyComparer class that inherits from generic IComparer.Compare and implements a default comparer for a given type T, a PropertyDescriptor, and a direction. Questa classe crea dinamicamente un oggetto Comparer di T, dove T è PropertyType di PropertyDescriptor.This class dynamically creates a Comparer of T where T is the PropertyType of the PropertyDescriptor. L'operatore di confronto predefinito viene quindi recuperato dall'oggetto statico generico Comparer.Then, the default comparer is retrieved from the static generic Comparer. Usando la reflection si ottiene un'istanza predefinita.A default instance is obtained by using reflection.

La classe generica SortableBindingList è anche la classe base per DataBindingList.Generic SortableBindingList is also the base class for DataBindingList. La classe generica SortableBindingList offre due metodi virtuali per sospendere o riprendere il rilevamento dell'aggiunta o rimozione di elementi.Generic SortableBindingList offers two virtual methods for suspending or resuming items add/remove tracking. Questi due metodi possono essere usati per funzionalità di base come l'ordinamento, ma saranno effettivamente implementati dalle classi superiori come DataBindingList generico.Those two methods can be used for base features such as sorting, but will really be implemented by upper classes like generic DataBindingList.

DataBindingList genericaGeneric DataBindingList

Questa classe eredita dalla classe generica SortableBindingLIst.This class inherits from generic SortableBindingLIst. La classe generica DataBindingList mantiene un riferimento all'oggetto generico Table sottostante dell'oggetto generico IQueryable usato per il riempimento iniziale della raccolta.Generic DataBindingList keeps a reference on the underlying generic Table of the generic IQueryable used for the initial filling of the collection. La classe generica DatabindingList aggiunge il rilevamento dell'aggiunta o rimozione degli elementi alla raccolta eseguendo l'override di InsertItem() e RemoveItem().Generic DatabindingList adds tracking for item add/remove to the collection by overriding InsertItem() and RemoveItem(). Implementa inoltre la funzionalità di rilevamento della sospensione o ripresa di elementi astratti per rendere condizionale il rilevamento.It also implements the abstract suspend/resume tracking feature to make tracking conditional. Questa funzionalità consente alla classe generica DataBindingList di sfruttare completamente l'uso polimorfico della funzionalità di rilevamento delle classi padre.This feature makes generic DataBindingList take advantage of all the polymorphic usage of the tracking feature of the parent classes.

Associazione a EntitySetBinding to EntitySets

L'associazione a EntitySet è un caso speciale perché EntitySet è già una raccolta che implementa IBindingList.Binding to EntitySet is a special case because EntitySet is already a collection that implements IBindingList. LINQ to SQLLINQ to SQL Aggiunge l'ordinamento e l'annullamento (ICancelAddNew) supportano. adds sorting and canceling (ICancelAddNew) support. Una classe EntitySet usa un elenco interno per archiviare entità.An EntitySet class uses an internal list to store entities. Tale elenco è una raccolta di basso livello basato su una matrice generica, la classe ItemList generica.This list is a low-level collection based on a generic array, the generic ItemList class.

Aggiunta di una funzionalità di ordinamentoAdding a Sorting Feature

Le matrici offrono un metodo di ordinamento (Array.Sort()) che può essere utilizzato con un oggetto Comparer di T. LINQ to SQLLINQ to SQL utilizza la classe generica SortableBindingList.PropertyComparer descritta in questo argomento per ottenere questo oggetto Comparer per la proprietà e la direzione di ordinamento.Arrays offer a sort method (Array.Sort()) that you can be used with a Comparer of T. LINQ to SQLLINQ to SQL uses the generic SortableBindingList.PropertyComparer class described earlier in this topic to obtain this Comparer for the property and the direction to be sorted on. Per chiamare questa funzionalità, viene aggiunto un metodo ApplySort all'oggetto generico ItemList.An ApplySort method is added to generic ItemList to call this feature.

Sul lato EntitySet è necessario dichiarare il supporto dell'ordinamento:On the EntitySet side, you now have to declare sorting support:

Quando si utilizza un BindingSource e si associa un oggetto EntitySet<TEntity > DataSource, è necessario chiamare EntitySet<Tentity >. GetNewBindingList per aggiornare BindingSource.When you use a System.Windows.Forms.BindingSource and bind an EntitySet<TEntity> to the System.Windows.Forms.BindingSource.DataSource, you must call EntitySet<Tentity>.GetNewBindingList to update BindingSource.List.

Se si utilizza un BindingSource e impostare la proprietà BindingSource. DataMember e imposta BindingSource. DataSource su una classe che contiene una proprietà denominata in BindingSource. DataMember che espone EntitySet<TEntity >, si non è necessario chiamare EntitySet<Tentity >. GetNewBindingList per aggiornare BindingSource. List ma si perderà la funzionalità di ordinamento.If you use a System.Windows.Forms.BindingSource and set the BindingSource.DataMember property and set BindingSource.DataSource to a class that has a property named in the BindingSource.DataMember that exposes the EntitySet<TEntity>, you don’t have to call EntitySet<Tentity>.GetNewBindingList to update the BindingSource.List but you lose Sorting capability.

Memorizzazione nella cacheCaching

LINQ to SQLLINQ to SQL le query implementano GetList. queries implement GetList. Quando la classe BindingSource di Windows Form individua questa interfaccia, chiama GetList() tre volte per una sola connessione.When the Windows Forms BindingSource class meets this interface, it calls GetList() threes time for a single connection. Per risolvere questo problema, LINQ to SQLLINQ to SQL implementa una cache per ogni istanza per archiviare e restituire sempre la stessa raccolta generata.To work around this situation, LINQ to SQLLINQ to SQL implements a cache per instance to store and always return the same generated collection.

AnnullamentoCancellation

IBindingList definisce un metodo AddNew usato dai controlli per creare un nuovo elemento da una raccolta associata.IBindingList defines an AddNew method that is used by controls to create a new item from a bound collection. Il controllo DataGridView mostra molto chiaramente questa funzionalità quando nell'intestazione dell'ultima riga visibile è presente un asterisco.The DataGridView control shows this feature very well when the last visible row contains a star in its header. L'asterisco indica che è possibile aggiungere un nuovo elemento.The star shows you that you can add a new item.

Oltre a questa funzionalità, una raccolta consente di implementare ICancelAddNew.In addition to this feature, a collection can also implement ICancelAddNew. Tale funzionalità consente ai controlli di annullare o di convalidare che il nuovo elemento modificato è stato o meno convalidato.This feature allows for the controls to cancel or validate that the new edited item has been validated or not.

ICancelAddNew viene implementato in tutte le raccolte LINQ to SQLLINQ to SQL con associazione a dati (SortableBindingList e EntitySet generici).ICancelAddNew is implemented in all LINQ to SQLLINQ to SQL databound collections (generic SortableBindingList and generic EntitySet). In entrambe le implementazioni il codice viene eseguito come segue:In both implementations the code performs as follows:

  • Consente l'inserimento e la successiva rimozione di elementi dalla raccolta.Lets items be inserted and then removed from the collection.

  • Non tiene traccia delle modifiche finché non ne viene eseguito il commit dall'interfaccia utente.Does not track changes as long as the UI does not commit the edition.

  • Non tiene traccia delle modifiche se queste vengono annullate (CancelNew).Does not track changes as long as the edition is canceled (CancelNew).

  • Consente di registrare quando viene eseguito il commit della modifica (EndNew).Allows tracking when the edition is committed (EndNew).

  • Consente alla raccolta di comportarsi normalmente se il nuovo elemento non proviene da AddNew.Lets the collection behave normally if the new item does not come from AddNew.

Risoluzione dei problemiTroubleshooting

Questa sezione descrive alcuni elementi che potrebbero facilitare la risoluzione dei problemi relativi alle applicazioni LINQ to SQLLINQ to SQL con data binding.This section calls out several items that might help troubleshoot your LINQ to SQLLINQ to SQL data binding applications.

  • È necessario usare proprietà; non è sufficiente usare solo campi.You must use properties; using only fields is not sufficient. Questo tipo di uso è obbligatorio in Windows Form.Windows Forms require this usage.

  • Per impostazione predefinita, image, varbinary, e timestamp tipi di database di cui è stato eseguito il mapping a una matrice di byte.By default, image, varbinary, and timestamp database types map to byte array. Poiché ToString() non è supportato in questo scenario, questi oggetti non possono essere visualizzati.Because ToString() is not supported in this scenario, these objects cannot be displayed.

  • Il mapping a una chiave primaria di un membro di classe dispone di un metodo set, ma LINQ to SQLLINQ to SQL non supporta la modifica di identità dell'oggetto.A class member mapped to a primary key has a setter, but LINQ to SQLLINQ to SQL does not support object identity change. Non è quindi possibile aggiornare la chiave primaria/univoca usata per il mapping nel database.Therefore, the primary/unique key that is used in mapping cannot be updated in the database. Una modifica nella griglia genera un'eccezione quando si chiama SubmitChanges.A change in the grid causes an exception when you call SubmitChanges.

  • Se un'entità è associata in due griglie separate, ad esempio una di dettaglio e una master, un'operazione Delete nella griglia master non viene propagata alla griglia di dettaglio.If an entity is bound in two separate grids (for example, one master and another detail), a Delete in the master grid is not propagated to the detail grid.

Vedere ancheSee Also

Informazioni di baseBackground Information