Følgende eksempelkode definerer en animasjon:
< Storyboard x: Name = "Animasjon "> < DoubleAnimation Storyboard.TargetName = "RectangleElement" Storyboard.TargetProperty = "bredde" From = "200" Å = "400" Varighet = "0:00:04" /> < /Storyboard >

De to første egenskaper er arvet fra Storyboard kontroll: Storyboard.TargetName brukes til å sette navnet på kontroll vi kommer til å animere, mens Storyboard.TargetProperty er eiendommen der verdien vi kommer til å endre seg i løpet animasjonen
<. p> Deretter definerer vi animasjonen atferd: den opprinnelige verdien (Fra eiendommen), sluttverdien (Til-eiendom) og (Varighet eiendom) varigheten. Oppførselen definert i forrige prøven animerer et rektangel kontroll ved å øke sin bredde fra 200 til 400 over 4 sekunder

Vi kan også styre animasjonen dypere ved å bruke UsingKeyFrames variant tilgjengelig for alle animasjonstype.

< Storyboard x: Name = "Animasjon" > < DoubleAnimationUsingKeyFrames Storyboard.TargetName = "RectangleElement" Storyboard.TargetProperty = "bredde" > < LinearDoubleKeyFrame KeyTime = "0:00:00" Value = "200" /> < LinearDoubleKeyFrame KeyTime = "0:00:02" Value = "250" /> < LinearDoubleKeyFrame KeyTime = "0:00:04" Value = "500" /> < /DoubleAnimationUsingKeyFrames > < /Storyboard >

Denne måten du klarer å styre animasjonen er timing. I forrige prøven, er animasjonen type det samme (det er en DoubleAnimation), men vi er i stand til å stille, for en bestemt tid, som er verdien til å søke hjelp av LinearDoubleKeyFrame lappen.

I forrige prøven, bredde rektangulære kontrollen er satt til 200 ved begynnelsen. Så, etter to sekunder, det øker til 250 og etter fire sekunder, er det satt til 500.

Lettelser Animasjoner

En annen måte å lage animasjoner er å bruke matematiske formler som er i stand til å anvende en realistisk oppførsel til et objekt, som spretter, eller akselerasjon og retardasjon. Du kan oppnå samme resultat ved å bruke nøkkelbilder, men det vil kreve mye arbeid. Av denne grunn tilbyr animasjonsrammeverk et sett med forhåndsdefinerte lettelser funksjoner som enkelt kan brukes på en animasjon.

For å legge til en lettere funksjon, du trenger bare å sette EasingFunction tilhører en animasjon, som vist i følgende eksempel:
< Storyboard x: Name = "EasingAnimation" > < PointAnimation Fra = "0.0" Å = "0, 200" Varighet = "00: 00: 3" Storyboard.TargetName = "Circle" Storyboard.TargetProperty = "Center" > < PointAnimation.EasingFunction > < BounceEase Avvisninger = "2" EasingMode = "EaseOut" /> < /PointAnimation.EasingFunction> < /PointAnimation > < /Storyboard >

Etter at du har definert en vanlig animasjon (i eksempelet er det en PointAnimation som beveger en ellipse objekt fra koordinater (0, 0) til (0, 200)), du kan stille EasingFunction eiendom med en av de tilgjengelige lettelser funksjoner. Dette eksemplet viser hvordan du bruker BounceEase funksjonen, som kan brukes til å søke en sprettende effekt til objektet (antall avvisninger utført er spesifisert med Avvisninger eiendom)

Andre tilgjengelige lettelser funksjoner er:.


BackEase, som trekker bevegelse av animasjonen litt før den starter.

CircleEase, som gjelder en sirkulær funksjon til akselerasjon animasjon.

ElasticEase, noe som skaper en animasjon som ligner en oscillerende våren.

Den offisielle MSDN dokumentasjon har en komplett liste over tilgjengelige lettelser funksjoner.

Slik styrer Animasjoner

Animasjoner blir behandlet som ressurser. De kan defineres som lokale ressurser, side ressurser, eller programressurser. I motsetning til tradisjonelle ressurser, Storyboard kontroller identifisert av x: Navn eiendom, som en vanlig kontroll

Eksemplet nedenfor viser en animasjon som er angitt som en side ressurs:
< telefon.: PhoneApplicationPage.Resources > < Storyboard x: Name = "Animasjon" > < DoubleAnimation Storyboard.TargetName = "RectangleElement" Storyboard.TargetProperty = "bredde" From = "200" Å = "400" Varighet = "0:00:04" /> < /Storyboard > < /telefon: PhoneApplicationPage.Resources >

Takket være den unike identifikator, vil du være i stand til å kontrollere animasjon i koden bak. Hver Storyboard objekt tilbyr mange metoder for å kontrollere det, som Begin (), Stop () eller Fortsett (). I følgende kode kan du se hendelsesbehandlinger tildelt to knapper som brukes til å starte og stoppe animasjonen:
private void OnStartClicked (objekt avsenderen, GestureEventArgs e) {Animation.Begin ();} private void OnStopClicked (objekt avsenderen, GestureEventArgs e) {Animation.Stop ();}
Data Binding

Data binding er en av de kraftigste funksjonene som tilbys av XAML. Med data bindende, vil du være i stand til å skape en kommunikasjonskanal mellom en UI element og ulike datakilder, noe som kan være en annen kontroll eller en eiendom i en av klassene. Videre er databinding tungt koblet til XAML varslingssystemet (som vi vil detalj senere) slik at hver gang du endrer noe i objektet, kontroll viser det vil bli automatisk oppdatert for å gjenspeile endringene og vise den nye verdien.

Når du oppretter en kommunikasjonskanal ved hjelp av data bindende, definerer du en kilde (som inneholder data å vise) og et mål (som tar seg av visning av verdi). Som standard er den bindende kanalen satt til OneWay modus. Dette betyr at når kilden endrer seg, blir målet oppdateres for å vise den nye verdien, men ikke omvendt. Hvis vi trenger for å lage en toveis kommunikasjonskanal (for eksempel fordi målet er en tekstboks kontroll og vi trenger å fange en ny verdi satt av brukeren), kan vi sette modus eiendommen av binding til toveis.

< TextBox Text = "{Binding Sti = Navn, Mode = toveis}" />

Nesten hver kontroll i XAML kan delta i databinding. De fleste av de egenskapene som er tilgjengelige for en kontroll, faktisk er avhengighets egenskaper. Utover å tilby grunnleggende lese- og skriveegenskapene, disse er spesielle egenskaper som støtter varsler, slik at de kan varsle den andre siden av kanalen at noe har endret seg.

Følgende eksempel viser hvordan data binding kan brukes til å lage en kanal mellom to XAML kontroller:
< StackPanel > < Slider x: Name = "Volume" /> < TextBlock x: Name = "SliderValue" Text = "{Binding ElementName = Volume, Sti = Verdi}" /> < /StackPanel >

Det første man legger merke til er at for å søke bindende, må vi bruke en annen markering forlengelse, heter Binding. Med dette uttrykket, kobler vi Tekst tilhører en TextBlock kontroll (målet) til verdi tilhører en Slider kontroll heter Volume (kilde).

Siden både tekst og Verdi er avhengige egenskaper, hver gang du flytter glidebryteren, vil den valgte verdien vises automatisk på skjermen i TextBlock kontroll.

Data Binding med objekter

En av de kraftigste databinding funksjonene er muligheten til å koble kontroller med objekter som er en del av koden din. Men først må vi innføre Context konseptet. Context er en egenskap som er tilgjengelig for nesten alle kontroll og kan bli brukt til å definere dens binding sammenheng, som også er automatisk arves av hver nestet styre. Når du definerer et objekt som Context, kontroll og alle barn vil ha tilgang til alle sine eiendommer.

La oss se et eksempel som vil hjelpe deg å bedre forstå hvordan det fungerer. La oss si at du har en klasse som representerer en person:
public class Person {public string Name {får; sett; } Public string etternavn {får; sett; }}

Vårt mål er å vise informasjon om en person som bruker denne klassen. Her er hvordan vi kan gjøre det ved hjelp av databinding. Først, la oss ta en titt på koden bak:
offentlig Mainpage () {InitializeComponent (); Person person = new Person (); person.Name = "Matteo"; person.Surname = "Pagani"; Author.DataContext = person;}

Når siden er initialisert, skaper vi en ny Person objekt og sette en verdi for navn og etternavn egenskaper. Deretter setter vi dette nye objektet som Context av forfatteren kontroll. La oss se på XAML siden forfatteren kontroll og hvordan navn og etternavn egenskaper vises:
< StackPanel x: Name = "forfatter" > < TextBlock Text = "Navn" /> < TextBlock Text = "{Binding Sti = navn}" /> < TextBlock Text = "Etternavn" /> < TextBlock Text = "{Binding Sti = etternavn}" /> < /StackPanel >

Forfatter er navnet som er tilordnet en StackPanel kontroll, som er den beholder vi har plassert inne forskjellige TextBlock kontroller. I forrige prøve kan vi se Binding markup forlengelse i aksjon igjen, denne gangen med en annen egenskap: Path. Vi bruker den til å fortelle XAML som tilhører den aktuelle Context å vise. Siden Context er arvet fra StackPanel kontroll, har hver TextBlock tilgang til egenskapene til den Person objekt vi har laget i koden bak. Legg merke til at Bane attributten er valgfri. De to følgende utsagn er nøyaktig det samme:
< TextBlock Text = "{Binding Sti = navn}" /> < TextBlock Text = "{Binding navn}" />
Den INotifyPropertyChanged grensesnitt

Den forrige koden har en feil. Alt fungerer fint, men hvis du vil endre verdien til en av navn eller etternavn eiendommer under utførelsen, vil brukergrensesnittet ikke oppdateres for å vise den nye verdien. Årsaken er at Navn og etternavn er enkle egenskaper, slik at de ikke er i stand til å varsle brukergrensesnittet at noe har endret seg, i motsetning til avhengighet egenskaper. For dette scenariet har XAML rammeverket introduserte INotifyPropertyChanged grensesnitt som kan implementeres av objekter som har behov for å tilfredsstille dette meldeplikt. Her er hvordan personen klassen kan endres for å implementere dette grensesnittet:
public class Person: INotifyPropertyChanged {private string snitt; private string _surname; offentlig string Name {få {return snitt; } Satt {snitt = verdi; OnPropertyChanged (); }} Public string etternavn {få {return _surname; } Satt {_surname = verdi; OnPropertyChanged (); }} Public event PropertyChangedEventHandler PropertyChanged; beskyttet virtuelle void OnPropertyChanged ([CallerMemberName] string property = null) {PropertyChangedEventHandler handler = PropertyChanged; if (! behandleren = null) handler (Dette nye PropertyChangedEventArgs (property)); }}

Klassen implementerer nå INotifyPropertyChanged grensesnitt, slik at vi kan støtte en hendelseshåndterer (kalt PropertyChangedEventHandler) som utløses hver gang en eiendommens verdiendringer. Klassen implementerer også en metode som kalles OnPropertyChanged () som fungerer som en wrapper av hendelseshåndterer og må startes når en eiendom endringer

Vi trenger. Også en endring i våre eiendommer. Hver gang settet av eiendommen kalles (som betyr at en ny verdi er blitt tildelt) vi heve OnPropertyChanged () -metoden. Resultatet vil være at hver kontroll bundet med eiendommen vil bli varslet om endringen, og vil oppdatere sin visuelle status tilsvarende.

Data Binding og samlinger

Data binding er spesielt nyttig når du må avtale med samlinger av gjenstander som arrays eller lister (i utgangspunktet, hver rammeinnsamlings typer som implementerer IEnumerable grensesnittet). Nesten hver kontroll som støtter samlinger, som arver fra ItemsControl klasse (som Liste- eller LongListSelector), har en egenskap som kalles ItemsSource, som kan direkte tilordnes en liste.

Du kan kontrollere hvordan hver gjenstand av samlingen vil bli gjort ved hjelp av ItemTemplate eiendommen. Som vi har sett når vi snakket om data maler, gjør denne eiendommen oss å sette som XAML til å bruke for å vise objektet.

Nå som vi har snakket om data bindende, det er en annen viktig brikke for å legge til. I eksempelkoden vi brukt til å vise data maler, inkluderte vi noen bindende uttrykk for å vise navn og etternavn på en person
< DataTemplate x. Key = "PeopleTemplate" > < StackPanel > < TextBlock Text = "Navn" /> < TextBlock Text = "{Binding Sti = navn}" /> < TextBlock Text = "Etternavn" /> < TextBlock Text = "{Binding Sti = etternavn}" /> < /StackPanel > < /DataTemplate >

Når du setter en samling som ItemSource, hvert objekt som er en del av det blir Context av ItemTemplate. Hvis du for eksempel er ItemsSource tilhører en ListBox koblet til en samling som type er List < Person >, vil kontrollene inngår i ItemTemplate kunne få tilgang til alle egenskapene til personen klassen

Dette. er den virkelige betydningen av forrige eksempelkode: For hver person objekt som er en del av samlingen, kommer vi til å vise verdiene av navn og etternavn egenskaper

En annen viktig brikke i puslespillet når deg. håndtere samlinger er ObservableCollection < T > klasse. Det fungerer som en vanlig samling, slik at du enkelt kan legge til, fjerne og flytte objekter. Under panseret, implementerer det INotifyPropertyChanged grensesnitt, slik at hver gang innsamling endres, mottar UI et varsel. På denne måten hver gang vi manipulere samlingen (for eksempel, legger vi til et nytt element), kontrollen som er koblet til den vil automatisk bli oppdatert for å gjenspeile endringene.

omformere

Omformere spille en viktig rolle i databinding. Noen ganger, faktisk, må du endre kildedataene før den sendes til målet. Et vanlig eksempel er når du har å forholde seg til Datetime egenskaper. Datetime klassen inneholder en full representasjon av en dato, inkludert timer, minutter, sekunder og millisekunder. Mesteparten av tiden, men du trenger ikke å vise full representasjon-ofte datoen er akkurat nok.

Det er der omformere komme til nytte. Du er i stand til å endre dataene (eller, som vist i følgende eksempel gjelde annen formatering) før du sender den til kontrollen som kommer til å vise det ved hjelp av databinding.

For å opprette en konverter, trenger du å legge til en ny klasse i prosjektet (høyreklikk i Visual Studio, velger du Legg til > Class), og det må arve fra IValueConverter grensesnittet. Det følgende er en omformer prøve:
public class DateTimeConverter: IValueConverter {public objekt Convert (objekt verdi, Type targetType, objekt parameter, Culture kultur) {if (! Value = null) {Datetime date = (Datetime) verdi; returnere date.ToShortDateString (); } Returnere string.Empty; } Public objekt ConvertBack (objekt verdi, Type targetType, objekt parameter, Culture kultur) {if (verdi = null) {Datetime date = DateTime.Parse (value.ToString ()); returdato; } Returnere DateTime.Now; }}

Når du støtter IValueConverter grensesnittet, er du tvunget til å gjennomføre to metoder:.

Convert () er den metoden påberopes når data fra kilden sendes til målet

ConvertBack () gjør det motsatte-den startes når data fra målet blir sendt tilbake til kilden.

Mesteparten av tiden er det nok til å gjennomføre Convert () metode som støttes av hver binding. Den ConvertBack () metoden, i stedet, støttes bare når du har toveis bindende

Begge metodene motta viktig informasjon som inngangsparametere.

Den forrige kodeeksemplet viser Datetime eksempel nevnt før. I Convert () -metoden får vi den opprinnelige verdien, og etter at vi har konvertert den til en Datetime objekt, returnerer vi en streng med kort formatering.

I ConvertBack () metoden, får vi streng returnert fra kontroll og konvertere den til en Datetime objekt før du sender den tilbake til koden.

omformere blir behandlet som ressurser-du trenger å erklære dem og inkludere dem i forpliktende uttrykk ved hjelp av StaticResource søkeord.

< telefon: PhoneApplicationPage.Resources > < omformere: DateTimeConverter x: Key = "DateConverter" /></phone:PhoneApplicationPage.Resources><TextBlock Text = "{Binding Sti = fødselsdato, Converter = {StaticResource DateConverter}}" />

Det er viktig å understreke at omformere kan ha en negativ innvirkning på ytelsen hvis du bruker dem også tungt, siden bindingen operasjonen må gjøres på nytt hver gang dataene endres. I dette tilfellet er det bedre å finne en måte å direkte endre kildedataene eller for å legge til en ny eiendom i klassen med den endrede verdien.

Controls

Windows Phone 8 SDK inneholder mange innebygde kontroller som kan brukes til å definere brukergrensesnittet til applikasjonen. namespace:

xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
Pivot

The < shell: ApplicationBar.MenuItems > sett; sett; sett; sett; </toolkit:NavigationInTransition></toolkit:TransitionService.NavigationInTransition><toolkit:TransitionService.NavigationOutTransition> </toolkit:NavigationOutTransition></toolkit:TransitionService.NavigationOutTransition>

Transitions </toolkit:NavigationInTransition></toolkit:TransitionService.NavigationInTransition><toolkit:TransitionService.NavigationOutTransition> </toolkit:NavigationOutTransition></toolkit:TransitionService.NavigationOutTransition>

Then,