Elementele de bază ale legării de date în WPF. Legarea datelor la interfața cu utilizatorul. Utilizarea șabloanelor de date ierarhice

Programare

Unul dintre punctele cheie în dezvoltare xaml aplicațiile orientate este să folosească legături ( Legături). Legare- Acest mediator(intermediar), cu ajutorul căruia valorile proprietăților sunt sincronizate între obiectele înrudite.

Este de remarcat faptul că nu este evident, dar nuanță importantă: Deși legarea face referire cumva la obiectele care interacționează, nu le împiedică să fie colectate de gunoi!

Moștenirea dintr-o clasă Legare permis, dar din motive de siguranță a codului, anulează metoda FurnizațiValoare, care este legat de logica principală de funcționare, nu este permisă. Acest lucru determină cumva dezvoltatorii să folosească modelul Convertor, care este strâns împletită cu tema legărilor.

Legăturile sunt un instrument foarte puternic, dar în unele cazuri declarația lor devine pronunțată și incomod pentru utilizarea obișnuită, de exemplu, pentru localizare. În acest articol ne vom uita la o metodă simplă și elegantă care face codul mult mai curat și mai frumos.

Declara legături în xaml permis în două moduri:

Evident, prima metodă nu pare foarte concisă, dar a doua, bazată pe utilizare extensii de markup, este folosit cel mai des. Pe platformă WPF există posibilitatea de a crea extensii de markup personalizate. De exemplu, sunt convenabile de utilizat pentru localizare.

În cel mai simplu caz, trebuie să moșteniți din clasă MarkupExtensionși implementați metoda FurnizațiValoare, în care să obțineți valoarea dorită folosind tasta.

Dar această implementare nu acceptă schimb cald limbaj în timpul execuției programului. Pentru a face această îmbunătățire, este necesar, în primul rând, să stocați o referință la elementul de interfață localizat și, în al doilea rând, ceea ce este mai puțin evident, să aveți cumva în aplicație o referință la instanța clasei în sine. Localizarea, pentru a-l proteja de colectarea gunoiului și, în al treilea rând, este necesar să implementați corect abonamentul și dezabonarea de la evenimentul de schimbare a limbii.

Dacă faceți aceste lucruri greșit, aveți garanția că veți obține scurgeri de memorie dacă vizualizările sunt create și distruse dinamic în timp ce aplicația rulează, ceea ce este cazul în multe cazuri. Adică, adăugarea s-ar părea că nu este cea mai mare functie complexa, va trebui să vă ocupați de subiecte non-triviale verigi slabeȘi abonamente slabe la evenimente. Și codul nu va fi foarte simplu.

Mai mult, pe xaml-platforme Windows Phone, Magazin Windows Și Xamarin.Forms nu există nicio modalitate de a crea extensii de markup personalizate, ceea ce aduce în discuție ideea utilizării legăturilor ca extensii de markup …

Să nu ne batem prin tufiș, iată de ce avem nevoie:

Clasa abstractă publică BindingExtension: Binding, IValueConverter ( protejat BindingExtension() ( Sursă = Convertor = aceasta; ) BindingExtension (sursă obiect) protejat (sursă obiect) // setează Sursa la null pentru utilizarea DataContext ( Sursă = sursă; Convertor = aceasta; ) BindingExtension (Sursă Relativă) protejată relativeSource) ( RelativeSource = relativeSource; Converter = this; ) obiect abstract Conversie(valoare obiect, Tip targetType, parametru obiect, cultură CultureInfo, obiect virtual public ConvertBack(valoare obiect, Tip targetType, parametru obiect, cultură CultureInfo) (aruncă nou); NotImplementedException();
Este de remarcat faptul că legarea este un convertor în sine. Ca rezultat, obținem un comportament foarte asemănător cu cel al moștenirii de la o clasă MarkupExtension, dar, în plus, Rămâne posibil să se utilizeze mecanisme standard de control al colectării gunoiului!

Acum, logica pentru localizarea arată nu ar putea fi mai simplă:

Clasă parțială publică Localizare: Base.BindingExtension ( public static readonly Manager ActiveManager = nou Manager(); public Localizing() ( Sursă = ActiveManager; Path = new PropertyPath("Source"); ) public Localizing (cheie șir) ( Cheie = cheie ; Sursă = ActiveManager Cale = new PropertyPath("Source" șir public Key ( get; set; ) public override object Convert(valoare obiect, Type target parameter, CultureInfo culture) ( var key = Key; var resourceManager = valoare ca ResourceManager; var localizedValue = resourceManager == null || string.IsNullOrEmpty(key) ? ":" + key + ":" : (resourceManager.GetString(key) ?? ":" + key + ":"); returnează localizedValue;
Clasa parțială publică Localizare ( Manager de clasă publică: INotifyPropertyChanged ( private ResourceManager _source; public ResourceManager Source ( get ( return _source; ) set ( _source = valoare; PropertyChanged(this, new PropertyChangedEventArgs("Source"))); ) ) șir public Get( cheie șir, șirFormat șir = nul) ( if (_source == null || string.IsNullOrWhiteSpace(key)) cheie return; var localizedValue = _source.GetString(key) ?? ":" + key + ":"; return șir .IsNullOrEmpty(stringFormat) ? localizedValue: string.Format(stringFormat, localizedValue eveniment public PropertyChangedEventHandler PropertyChanged = (sender, args) => ( ) );
Este ușor să adăugați posibilitatea de a schimba majusculele literelor:

Clasă parțială publică Localizare: Base.BindingExtension ( enumerare publică Case ( Implicit, Inferioară, Superioară ) public static readonly Manager ActiveManager = nou Manager(); public Localizing() ( Sursă = ActiveManager; Cale = nou PropertyPath("Sursa"); ) public Localizing(string key) ( Cheie = cheie; Sursă = ActiveManager; Path = new PropertyPath("Source"); ) public șir Cheie ( get; set; ) public Cases Case ( get; set; ) public override string ToString() ( returnează Convert(ActiveManager.Source, null, Key, Thread.CurrentThread.CurrentCulture) ca șir ?? șir.Empty; ) public override object Convert (valoare obiect, Tip targetType, parametru obiect, cultură CultureInfo) ( var key = Key; var resourceManager = valoare ca ResourceManager var localizedValue = resourceManager == null || string.IsNullOrEmpty(key) ? "); comutator (Case) (case Cases.Lower: return localizedValue.ToLower(); case Cases.Upper: return localizedValue.ToUpper(); implicit: return localizedValue; ) ) )
ÎN xamlÎnregistrarea pare convenabilă și frumoasă, dar există câteva limitări ale parserelor de marcare pe diferite platforme:

Pentru a scăpa de WPF din prefixul cerut m: trebuie să plasați extensia de marcare într-un ansamblu separat și în Proprietăți/AssemblyInfo.cs specifica urmatoarele directive:

Pentru a ajusta numele prefixului la Windows Phone sau Magazin:

Folosind extensii de legare ( Extensii de legare) pe WPF nu exclude extensiile obișnuite de markup, dar în unele cazuri este chiar mai sigur și varianta simpla. De asemenea, toate acestea nu se limitează doar la localizare, ci sunt potrivite pentru multe alte scopuri...

Abordarea demonstrată este utilizată pe scară largă în bibliotecă

Ultima actualizare: 02/07/2016

În WPF, legarea este Unealtă puternică programare, fără de care nici o singură aplicație serioasă nu poate face.

Legarea implică interacțiunea a două obiecte: o sursă și o destinație. Obiectul destinație creează o legătură cu o anumită proprietate a obiectului sursă. Dacă obiectul sursă este modificat, obiectul destinație va fi și el modificat. De exemplu, cea mai simpla forma folosind legarea:

Pentru a defini o legătură, o expresie ca:

(Binding ElementName=Sursă nume_obiect, Cale=Sursă obiect_proprietate)

Adică, în acest caz, elementul TextBox este sursa, iar TextBlock este destinația legării. Proprietate Element Text TextBlock este legat de proprietatea Text a elementului TextBox. Ca urmare, atunci când introduceți un câmp de text, modificările în blocul de text vor avea loc sincron.

Lucrul cu Binding în C#

Obiectul cheie la crearea unei legături este obiectul System.Windows.Data.Binding. Folosind acest obiect putem obține legarea deja existentă pentru element:

Binding binding = BindingOperations.GetBinding(myTextBlock, TextBlock.TextProperty);

În acest caz, obținem o legare pentru proprietatea de dependență TextProperty a elementului myTextBlock.

De asemenea, puteți seta legarea în întregime în codul C#:

Public MainWindow() ( InitializeComponent(); Binding binding = new Binding(); binding.ElementName = "myTextBox"; // element sursă binding.Path = new PropertyPath("Text"); // proprietate element sursă myTextBlock. SetBinding( TextBlock.TextProperty, binding); // setarea legării pentru elementul receptor)

Dacă în viitor nu mai avem nevoie de o legare, putem folosi clasa BindingOperations și metodele sale ClearBinding() (elimină o legare) și ClearAllBindings() (elimină toate legăturile pentru un anumit element).

BindingOperations.ClearBinding(myTextBlock, TextBlock.TextProperty);

BindingOperations.ClearAllBindings(myTextBlock);

Câteva proprietăți ale clasei Binding:

ElementName : numele elementului la care este creată legătura

IsAsync: dacă este setat la True, folosește modul asincron pentru a primi date de la obiect. Setarea implicită este False

Mod: modul snap

TargetNullValue : Setează valoarea implicită dacă proprietatea legată a sursei de legare are valoare nulă

RelativeSource: creează o legătură relativă la obiectul curent

Sursă: indică obiectul sursă dacă nu este un control.

XPath : utilizat în locul proprietății cale pentru a specifica calea către datele XML

Moduri Snap

Proprietatea Mode a unui obiect Binding, care reprezintă modul de legare, poate lua următoarele valori:

OneWay: Proprietatea obiectului destinație este modificată după ce proprietatea obiectului sursă este modificată.

OneTime: proprietatea obiectului destinație este setată la proprietatea obiectului sursă o singură dată. Modificările ulterioare ale sursei nu au niciun efect asupra obiectului destinație.

TwoWay: Atât obiectele aplicație, cât și obiectele sursă pot schimba proprietățile legate reciproc.

OneWayToSource: obiectul destinație în care este declarată legarea modifică obiectul sursă.

Implicit : implicit (dacă proprietatea TextBox.Text se modifică, aceasta are valoarea TwoWay, în caz contrar OneWay).

Aplicarea modului snap:

Actualizare obligatorie. UpdateSourceTrigger

Legarea unidirecțională de la sursă la receptor schimbă proprietatea receptorului aproape instantaneu. Dar dacă folosim legarea bidirecțională în cazul câmpurilor de text (ca în exemplul de mai sus), atunci când destinația se schimbă, proprietatea sursă nu se schimbă instantaneu. Deci, în exemplul de mai sus, pentru ca câmpul de text sursă să se schimbe, trebuie să schimbăm focalizarea de la câmp de text-receptor Și în acest caz, intră în joc proprietatea UpdateSourceTrigger a clasei Binding, care specifică modul în care va avea loc actualizarea. Această proprietate ia una dintre valorile de enumerare UpdateSourceTrigger:

PropertyChanged: sursa de legare este actualizată imediat după actualizarea proprietății din receptor

LostFocus: sursa de ancorare este actualizată numai după ce receptorul își pierde focalizarea

Explicit: sursa nu este actualizată până când metoda BindingExpression.UpdateSource() nu este apelată

Implicit: Valoare implicită. Pentru majoritatea proprietăților, aceasta este PropertyChanged . Și pentru proprietatea Text a elementului TextBox, această valoare este LostFocus

În acest caz despre care vorbim despre actualizarea sursei de legare după schimbarea destinației în modurile OneWayToSource sau TwoWay. Adică, pentru ca ambele câmpuri de text care sunt conectate prin modul TwoWay să fie actualizate instantaneu după schimbarea unuia dintre ele, trebuie să folosim valoarea UpdateSourceTrigger.PropertyChanged:

Proprietatea sursă

Proprietatea Sursă vă permite să setați o legare chiar și pentru obiecte care nu sunt controale WPF. De exemplu, să definim clasa Telefon:

Class Phone ( șir public Titlu ( get; set; ) public șir Companie ( get; set; ) public int Preț ( get; set; ) )

Acum să creăm un obiect din această clasă și să definim o legătură cu acesta:

Proprietatea TargetNullValue

În cazul în care o proprietate din sursa de legare are brusc valoarea nulă, adică nu este setată, putem seta o valoare implicită. De exemplu:

În acest caz, resursa nexusPhone nu are setată o proprietate Titlu, astfel încât blocul de text va scoate valoarea implicită specificată în parametrul TargetNullValue.

Proprietatea RelativeSource

Proprietatea RelativeSource vă permite să setați o legătură relativă la un element sursă care are un fel de relație cu elementul destinație. De exemplu, elementul sursă poate fi unul dintre containerele exterioare pentru elementul destinație. Sau sursa și destinația pot fi același element.

Pentru a seta această proprietate, utilizați obiectul RelativeSource cu același nume. Acest obiect are o proprietate Mode, care specifică metoda de legare. Este nevoie de una dintre valorile de enumerare RelativeSourceMode:

Self: legarea se realizează la o proprietate a aceluiași element. Adică, elementul sursă al legării este în același timp și receptorul legării.

FindAncestor: legarea este efectuată la proprietatea elementului container.

De exemplu, combinați legarea sursă și destinație în elementul în sine:

Aici textul și culoarea de fundal a casetei de text sunt legate printr-o legare bidirecțională. Drept urmare, putem vedea pe teren valoare numerica culoare, schimbați-o și fundalul câmpului se va schimba odată cu acesta.

Legarea la proprietățile containerului:

Când utilizați modul FindAncestor, adică legarea la un container, trebuie să specificați și parametrul AncestorType și să îi transmiteți tipul de container sub forma expresiei AncestorType=(x:Type Container_element_type) . În acest caz, am putea selecta orice container din arborele elementelor ca container în special, în acest caz, pe lângă Grid, un astfel de container este și elementul Window;

Proprietatea DataContext

Obiectul FrameworkElement de la care moștenesc controalele are o proprietate DataContext interesantă. Vă permite să setați un context de date pentru un element și elementele sale imbricate. Elementele imbricate pot folosi apoi obiectul Binding pentru a se lega de proprietăți specifice ale contextului respectiv. De exemplu, să folosim clasa Phone definită anterior și să creăm un context de date dintr-un obiect din această clasă:

În acest fel, setăm proprietatea DataContext la o resursă dinamică sau statică. Apoi ne legăm de această resursă.

Adnotare: ÎN aceasta sectiune acoperă conceptele de bază ale legării de date în WPF. O serie de exemple demonstrează aspectele de bază ale legarii elementelor de interfață la obiecte WPF vizuale și non-vizuale. Subiecte mai avansate, cum ar fi legarea elementelor de interfață WPF la obiecte personalizate și colecții de date tipizate, obiecte framework ADO.NET și șabloane, vor fi tratate mai târziu.

Partea I

Dispoziții generale

Toate programele necesare pentru realizarea acestei lucrări se găsesc în catalogul atașat.

Legarea datelor este un mecanism pentru extragerea informațiilor din obiecte în elemente de interfață pentru afișare și invers - împingerea informațiilor din comenzi în obiecte. Legarea datelor vă permite să faceți puțin sau deloc codificare. Aceasta este o tehnică relativ veche, dar WPF a primit o dezvoltare ulterioară și are specificul său. Toată complexitatea legării de suport este asigurată de clasele bibliotecii și de runtime. Legarea acoperă o gamă largă de sarcini: de la conectarea elementelor simple de interfață între ele până la conectarea unei baze de date la forme personalizate de interacțiune cu datele.

Legarea datelor implică întotdeauna două părți: sursa și receptorul (elementul țintă) a informațiilor. Legarea datelor poate oferi o comunicare unidirecțională sau bidirecțională a proprietăților obiectului înrudit. Cel mai adesea, se folosește legarea unidirecțională, al cărei scop este extragerea informațiilor dintr-o sursă și afișarea acesteia pe un receptor. Dar, în unele cazuri, diferențele dintre sursă și receptor sunt șterse și uneori chiar și rolurile lor sunt inversate - receptorul începe să furnizeze date sursei.

Sintaxa de legare a datelor, ca și în cazul resurselor, are și două opțiuni: extensii de markupȘi elemente de proprietate, dar diferă în detalii. Elementul cheie al legării pentru orice opțiune este definirea unui obiect Binding din spațiul de nume System.Windows.Data. Acest element este întotdeauna setat pe partea receptor a legării, cu excepția modului=OneWayToSource . Receptorul trebuie să fie derivat din clasa DependencyObject, iar proprietatea care poate fi legată (proprietatea țintă) trebuie să fie proprietatea dependenței. Încorporată în proprietățile de dependență este capacitatea de a trimite sau de a primi notificări de modificare.

Există mult mai puține cerințe pentru sursa obligatorie. Proprietatea sursă care este legată nu trebuie să fie proprietate dependentă. Principalul lucru este că sursa are un eveniment de alertă care indică o modificare a proprietății legate. Sursa obligatorie poate fi orice proprietate publică, inclusiv proprietăți ale altor controale, obiecte runtime de limbaj comun, elemente XAML, seturi de date ADO.NET, fragmente XML etc. Pentru a aplica corect legarea la obiecte complexe Tehnologia de date WPF oferă două clase specializate - XmlDataProvider și ObjectDataProvider.

Proprietățile de dependență sunt de asemenea numite anexat. În versiune XAML, destinate pentru WPF, proprietățile atașate funcționează numai dacă atât tipul în care este definită proprietatea, cât și tipul la care este atașată moștenesc clasa DependencyObject. Utilizarea proprietăților de dependență de limbă XAML are capacitatea de a extinde tipurile folosind proprietățile oferite de alte tipuri. Când este utilizată în marcajul de sintaxă a elementului de proprietate, proprietatea atașată este întotdeauna precedată de numele tipului care o furnizează, chiar dacă proprietatea este utilizată ca atribut.

Fixați indicații

Tipul de legare al unui element Binding este determinat de proprietatea sa Mode, care poate lua una dintre valorile de enumerare BindingMode din spațiul de nume System.Windows.Data:

Mod implicit- este setat implicit și depinde de tipul de proprietate care este legată pe partea receptorului (proprietatea țintă). Acționează ca un mod de legare TwoWay pentru proprietățile care sunt editabile în interfața cu utilizatorul, cum ar fi TextBox.Text sau CheckBox.Checked, sau ca mod de legare OneWay pentru alte proprietăți. Pentru a evita să vă bazați pe setările implicite, ar trebui să faceți o regulă să setați întotdeauna în mod explicit parametrul direcției de fixare.
O dată- legarea inițială unidirecțională, când valoarea proprietății țintă este setată la valoarea sursei o singură dată: în timpul inițializării, înlocuire software obiect sursă legat la unul nou, când proprietatea DataContext se modifică sau ca rezultat al unui apel de metodă programatică BindingExpression.UpdateTarget(). Alte notificări primite despre modificări din partea sursă nu vor fi luate în considerare de către destinatar
Sens unic- legare unidirecțională, unde proprietatea țintă este actualizată atunci când proprietatea sursă se modifică. De fiecare dată când există o schimbare în partea sursă, fluxul de date este direcționat de la sursă la țintă.
OneWayToSource- organizează o legare unidirecțională, ca OneWay, doar expresia de legare este plasată în sursă. Acest truc poate fi util atunci când proprietatea destinație care este legată nu este o proprietate de dependență, dar proprietatea sursă moștenește încă din clasa DependencyObject.
Două sensuri- legare bidirecțională, unde proprietatea țintă este actualizată când proprietatea sursă se modifică și proprietatea sursă este actualizată când proprietatea țintă se modifică. Cu alte cuvinte, modul de legare TwoWay trimite date de la sursă la țintă, iar dacă valoarea unei proprietăți a țintei se modifică, datele sunt trimise înapoi de la țintă la sursă

Exercițiul 1: Legarea elementului de element

În acest exercițiu, ne vom uita la crearea unui canal de comunicare între proprietățile de dependență ale elementelor vizuale ale interfeței de utilizare WPF folosind o serie de exemple.

Acum ați creat pagini cu drepturi depline pentru aplicația dvs. Acum probabil că veți dori să le completați cu diverse date.

În această parte veți învăța:

Cum să legați datele la interfața cu utilizatorul.
Cum vă poate ajuta Visual Studio să creați legături de date.
Cum să afișați datele într-o listă.
Cum să faceți față unor scenarii obligatorii mai complexe.

Legarea datelor la interfața cu utilizatorul

Aplicația Fuel Tracker are trei pagini de date. Datele sunt stocate în principal în trei clase. Următoarea imagine arată paginile și clasele asociate acestora.

Legarea datelor este de obicei folosită pentru afișarea datelor. Legarea datelor oferă posibilitatea de a conecta o interfață de utilizator la o sursă de date. Când sunt create legături și sursa de date se modifică, elementele UI care sunt legate la sursa de date reflectă modificările automat. De asemenea, modificările făcute de utilizator la un element UI sunt reflectate în sursa de date. De exemplu, dacă utilizatorul modifică o valoare într-un TextBox, sursa de date corespunzătoare se va actualiza automat pentru a reflecta acele modificări.

Următorul fragment de cod XAML ilustrează sintaxa care este utilizată pentru a lega proprietatea Text a unui control TextBox la proprietatea Name a obiectului sursă.

< TextBox x:Name ="NameTextBox" Text ="(Nume obligatoriu, Mod=Due sensuri)" />

Următoarea imagine prezintă un exemplu de astfel de legare.

Fiecare legare are o proprietate Mode, care determină cum și când datele sunt actualizate. Legarea OneWay înseamnă că elementul UI țintă este actualizat dacă sursa se modifică. Legarea în două sensuri înseamnă că atât ținta, cât și sursa sunt actualizate dacă oricare dintre ele se modifică. Dacă utilizați legături OneWay sau TwoWay, atunci pentru ca legarea să fie notificată cu privire la modificările aduse obiectului sursă, trebuie să implementați interfața INotifyPropertyChanged. Această interfață va fi discutată mai detaliat în partea următoare, „Crearea claselor de date”.

Specificați un obiect sursă setând proprietatea DataContext. Dacă utilizați un control ListBox, trebuie să specificați obiectul sursă setând proprietatea ItemsSource. Următorul exemplu arată cum să setați proprietatea DataContext a unui panou CarHeader la un obiect sursă preluat dintr-o proprietate statică.

CarHeader.DataContext = CarDataStore.Car;

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

Proprietatea DataContext vă permite să setați o legare standard pentru un întreg element UI, inclusiv toate elementele sale secundare. În unele cazuri, veți găsi mai convenabil să setați proprietatea DataContext pentru întreaga pagină, iar în altele, veți găsi mai convenabil să o setați individual pentru fiecare element din pagină. Setarea DataContext la fiecare nivel XAML suprascrie orice setări la un nivel superior. În plus, puteți suprascrie orice setare DataContext pentru legături individuale, setând proprietatea sursă.

De exemplu, în aplicația Fuel Tracker, fiecare pagină setează DataContext la o valoare diferită. Totuși, pe pagină FillupPage DataContext la nivel de pagină este înlocuit pentru panoul care afișează numele și fotografia mașinii. Următoarea imagine arată setările de context de date pentru aplicația Fuel Tracker.

Utilizarea generatorului de legături de date

Visual Studio include un generator de legături de date pentru a vă ajuta să creați legături de date în XAML. Deși generatorul de legături de date poate oferi îmbunătățiri de performanță, nu acceptă toate scenariile posibile. De exemplu, nu acceptă legarea la elementele indexate și nu recunoaște legăturile create în cod. Prin urmare, în unele cazuri va trebui să specificați manual legăturile de date.

Afișarea datelor într-o listă

Afișarea unei colecții de elemente dintr-o listă este una dintre sarcinile principale ale telefonului dvs. Pentru a afișa o colecție de articole dintr-o listă folosind legarea de date, trebuie să faceți următoarele:

Adăugați ListBox la aplicația dvs.
Specificați sursa de date pentru ListBox legând colecția la proprietatea ItemsSource.
Pentru a personaliza aspectul fiecărui element dintr-un ListBox, adăugați un șablon de date pentru ListBox.
În șablonul de date, legați elementele ListBox la proprietățile Item Collection.

Următoarea imagine arată legăturile pentru ListBox pe pagina de rezumat al aplicației Fuel Tracker.

Următorul XAML arată cum au fost specificate legăturile pentru ListBox.

< ListBox ItemContainerStyle ="(StaticResource ListBoxStyle)"

ItemsSource="(Istoric de completare de legare)"

Height="380" HorizontalAlignment="Left" Margin="5.25,0.0"

VerticalAlignment="Top" Width="444" >

< ListBox.ItemTemplate >

< DataTemplate >

< StackPanel Orientation ="Horizontal" >

< TextBlock Style

Text ="(Data de legare, Convertor=(StaticResource StringFormatter), ConverterParameter=\(0:d\) )"

Width="105" TextWrapping="Wrap" />

< TextBlock Style ="(Stil de rezumat al resurselor statice)"

Text ="(Binding FuelQuantity)" TextWrapping ="Wrap" />

< TextBlock Style ="(Stil de rezumat al resurselor statice)"

Text ="(Binding DistanceDriven)" TextWrapping ="Wrap" />

< TextBlock Style ="(Stil de rezumat al resurselor statice)"

Text ="(Binding PricePerFuelUnit, Converter=(StaticResource StringFormatter), ConverterParameter=\(0:c\), ConverterCulture=en-US)" />

< TextBlock Style ="(Stil de rezumat al resurselor statice)"

Text ="(Binding FuelEfficiency, Converter=(StaticResource StringFormatter), ConverterParameter=\(0:F\))" TextWrapping ="Wrap" />

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

În XAML anterior, proprietatea ListBox.ItemsSource este legată de Car.FillupHistory astfel încât fiecare obiect A completaîn colecția de istorie va apărea ca un articol separat în ListBox. Elementul DataTemplate definește aspectul fiecărui element și conține mai multe elemente TextBlock, fiecare dintre acestea fiind legat de o proprietate de clasă A completa.

Acest XAML va funcționa numai atunci când obiectul Mașină este mai întâi asociat cu pagina, așa cum se arată în următorul cod din SummaryPage.xaml.cs.

acest .DataContext = CarDataStore.Car;

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

Sfat pentru îmbunătățirea performanței:
Dacă derularea în ListBox nu pare lină și receptivă, încercați aceste sfaturi:

Simplificați elementele din ListBox.
Încărcați imagini în fundal.
Utilizați virtualizarea datelor.
Rețineți utilizarea DeferredLoadListBox sau LazyListBox.
Nu utilizați liste imbricate.

Căi de legare complexe

Pe lângă flexibilitatea setării proprietății DataContext la orice nivel (permițându-vă să suprascrieți setările la un nivel superior), puteți specifica și căi de legare complexe pentru a explora proprietățile de referință, cum ar fi Car.FillupHistory. De exemplu, următorul XAML din SummaryPage.xaml demonstrează legarea proprietăților Umplere.Eficiența combustibilului primul articol din colecția de istorie a benzinăriilor.

< TextBlock Text ="(Legarea FillupHistory.FuelEfficiency, Converter=(StaticResource StringFormatter), ConverterParameter=\(0:F\))" />

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

Următoarea imagine arată legăturile din SummaryPage.xaml și arată cum legăturile și șabloanele de date complexe vă permit să legați controale la diferite proprietăți ale diferitelor obiecte, chiar dacă toate aparțin aceluiași DataContext.

Dreptunghiurile verzi din ecranul Pivot din stânga arată comenzile care sunt fixate folosind căi complexe. Aceste căi încep de la primul element (index 0) din colecție Car.FillupHistoryși se încheie cu diferite proprietăți de clasă A completa. De exemplu, câmpul Current MPG folosește calea de legare FillupHistory.FuelEfficiency. Dacă includeți setarea DataContext a paginii în această cale, întreaga cale de legare va arăta astfel: CarDataStore.Car.FillupHistory.FuelEfficiency.

Etichete:

windows phone 7
crearea unei aplicații
de la început până la sfârșit

Adaugă etichete