An Introduksjon til Xamarin.Forms og Messaging
32
Del
10
Del
Dette Cyber Monday Envato Tuts + kurs vil bli redusert til bare $ 3. Ikke gå glipp av.
Helt siden Xamarin tre ble innført, har det vært ganske mye buzz rundt det. Ideen om å være i stand til å lage en mobilapplikasjon, inkludert brukergrensesnittet, ved hjelp av en enkelt kode base er fantastisk. Men Xamarin.Forms er så mye mer enn det. En av de ofte oversett funksjonene i Xamarin.Forms er begrepet Meldinger og som er tema for denne opplæringen.
1. Hva er meldinger?
Hvis du har erfaring å skrive programvare i bedriftsmiljøer, kan du også ha erfaring med-eller har i det minste hørt om meldinger i programmene dine. Meldinger er et begrep som brukes for å beskrive programmer som drar nytte av den publisere /abonnere (pub /sub) design mønster. Publisere /abonnere arkitekturen består av tre primære spillere:
meldinger
utgivere
abonnenter
Det sentrale fokus for denne prosessen er rundt meldingene. Meldinger er bare en måte å overføre informasjon om en bestemt hendelse som har inntruffet. Denne hendelsen er vanligvis knyttet til noen form for forretningsprosesser og den inneholder informasjon som kreves av systemer som til slutt vil bruke denne informasjonen til å utføre noen andre operasjoner.
De to andre spillere, utgivere og abonnenter, er formidlere av disse meldinger. Som navnene tilsier, forlagene er avsenderne av meldingene og abonnenter er mottakerne av meldingene.
Hvordan messaging arbeid?
Den grunnleggende prosessen med meldinger er ganske enkel. Innenfor et system, oppstår det en viss hendelse. Denne hendelsen kan være noe enkelt, som en bruker klikker på en knapp, eller så komplisert som en bedrift regel skyte i et stort økonomisk firmaets trading program. I en verden av meldinger, er det liten forskjell mellom disse to tingene. Alt du trenger å vite er at noe har skjedd.
Når en hendelse inntreffer, vil en utgiver ta informasjon om denne hendelsen, og pakke det opp i en melding. Denne meldingen vil ha noen form for type knyttet til det, samt ytterligere data som beskriver hendelsen. Den type er meget viktig senere i prosessen. Når denne meldingen er opprettet, vil utgiveren sende den ut i noe system. Fra dette punktet, forlaget ikke lenger bryr seg om denne hendelsen eller melding. Det er noen typer av utgivere som trenger å få et svar, men det er ikke veldig viktig i vårt tilfelle.
På den andre enden av ligningen er abonnenter. Abonnenter er det motsatte av utgiverne. De venter på meldinger av en bestemt type som skal publiseres. Det er der deres navn kommer fra, de abonnerer på visse typer arrangementer. Når en abonnent ser at en hendelse som de er tegnet har oppstått, vil det ta dette budskapet og alle sine data, og gjøre noe med det. Når denne prosessen er fullført, går abonnenten tilbake til venter på flere meldinger.
Hvorfor skal du bruke meldinger?
Med denne arkitekturen i bakhodet, lurer du kanskje på hvorfor eller når du bør bruke den. Vanligvis utviklere velger å bruke denne type arkitektur av to grunner, løs kopling og skalerbarhet.
Løse Coupling
Når det gjelder programvareutvikling, er løs kobling begrepet holde annerledes komponenter innenfor programmet som separate som mulig til det punktet at de vet så lite om hverandre som mulig. Dette skillet tillater utviklere å fokusere mer på funksjonalitet i et system og mindre på samspillet mellom ulike komponenter eller deler av systemet. Dette åpner for enklere endringer av funksjonalitet og testing av ulike komponenter.
Skalerbarhet
Skalerbarhet har å gjøre med hvordan et system kan vokse uten å hele tiden bearbeide og re-arkitekten hele løsning. Når det gjelder meldinger, hvis du trenger å gjøre noen form for ekstra behandling når en bestemt melding blir oppdaget, er en ny abonnent opprettet for å håndtere denne funksjonaliteten i motsetning til å måtte åpne opp en eksisterende stykke kode og gjøre endringer.
Nå, la oss se hvordan vi kan sette dette ekstremt kraftig arkitektur til å bruke i våre mobilapplikasjoner bruker Xamarin.
2. Utnytte Messaging i Xamarin.Forms
Gå inn i en verden av meldinger i Xamarin.Forms er faktisk ganske enkelt nå som vi forstår de grunnleggende begrepene meldinger. Alt vi trenger nå er en konstruksjon for å få tilgang til dem. Heldigvis for oss, er det bare én klasse vi virkelig trenger å bekymre deg for hva som er MessagingCenter. Den MessagingCenter klasse er en del av Xamarin.Forms og har metoder for å hjelpe oss med både publisering og abonnere på meldinger. La oss ta en titt på hver.
Publiser
Den første metoden vi kommer til å ta en titt på i MessagingCenter klassen er Send. Selv om konseptet i en meldings sammenheng er publisere, den Xamarin.Forms gjennomføringen bruker Send. Det finnes to versjoner av Send metode som kan brukes til å publisere data
MessagingCenter.Send. ≪ TSender > (TSender avsender, string melding)
MessagingCenter.Send < TSender, TArgs > (TSender avsender, streng beskjed, TArgs args)
Begge disse alternativene er generisk. Den første lar deg spesifisere avsenderen av denne meldingen og den andre gjør det også et sekundært argument, nyttelast type.
Det er viktig å påpeke at TArgs generiske parameter kan være en hvilken som helst type. Det kan være noe enkelt som en streng eller så komplisert som en tilpasset type.
Abonner
Nå som vi forstår hvordan å publisere, eller Send, meldinger i systemet, er det tid for noe å abonnere på dem. For å gjøre det, vil vi være å bruke Abonner metoden på MessagingCenter klassen.
I likhet med de to versjonene av Send metoden, har Abonner metoden også to overbelastning.
MessagingCenter.Subscribe < TSender, TArgs > (objekt abonnent, streng beskjed, Handling < TSender, TArgs > tilbakeringing, TSender avsender = null)
For de Abonner metoder, er vi spesifisere hvem abonnenten er. Vanligvis vil vi spesifisere dette for første parameter. Den andre parameteren vil inneholde det samme budskapet som ble oppgitt i Send metoden, slik at vi kan bli varslet når den aktuelle meldingen er sendt. Den tredje parameteren er en generisk delegat som aksepterer avsenderen, og muligens args, avhengig av hvilken versjon av metoden brukes. Representanten er en tilbakeringing som kjøres når en melding av denne typen er publisert. Endelig er et nullable parameter spesifisere hvilke TSender denne meldingen bør tegnes. Det kan stå som null å akseptere denne type meldinger fra alle avsendere.
Flott, nå er vi abonnerer på meldinger, men hva om vi ikke bryr seg om visse meldinger lenger? Godt spørsmål. Det er én mer metode for å ta hensyn til.
Avmelding
En ofte oversett prosess i verden av meldinger er å stoppe abonnementet. Når du jobber i et veldig stort enterprise-klassen infrastruktur, kanskje det er ikke fullt så viktig. I kontrast, når du jobber i et mindre miljø, for eksempel en telefon, blir det enda viktigere.
Selv om du bruker meldingsarkitektur gir mer fleksibilitet og skalerbarhet, tar det fortsatt systemressurser. På grunn av dette, kan vi ikke fortsette å øke antall abonnenter i et system uendelig. At det å være tilfelle, må vi ha respekt for ressurser som best vi kan. I Xamarin.Forms, er måten vi gjør dette gjennom å ringe Avmelding metoden. Denne metoden gjør det mulig for oss å si at vi ikke lenger bryr seg om en bestemt melding blir publisert ut til systemet
Avmelding metoden har også to overbelastning
MessagingCenter.Unsubscribe. ≪. TSender > (objekt abonnent, string melding)
MessagingCenter.Unsubscribe < TSender, TArgs > (objekt abonnent, streng beskjed)
Du kan se at de generiske argumenter ikke manifesterer seg i parameterlisten. Bare utviklerne har en god idé om hvorfor akkurat, men jeg føler at det er nok mer en formalitet. Uansett, jeg velger å være konsekvent på tvers av alle mine samtaler for å sende, Abonner, og Avslutt abonnement, og bruker de samme signaturer og argumenter for å eliminere enhver form for forvirring.
Nå som vi forstår de grunnleggende begrepene meldinger, det er på tide å lage et enkelt eksempel utnytte disse ideene.
3. Opprette et eksempel
I dette eksemplet vil vi lage en enkel Xamarin.Forms app som vil bruke alle tre metodene til MessagingCenter klassen nevnt tidligere i denne artikkelen. Appen i seg selv kan virke ganske ubetydelig, men det vil gi en nyttig illustrasjon av hvordan du bruker disse begrepene i dine apps fremover
Trinn 1:. Lag en Xamarin.Forms App
Vi ll begynne med å lage en ny Xamarin.Forms app. For å oppnå dette, er det bare åpent Xamarin Studio (eller Visual Studio), og velg Fil > Ny løsning. I dialogboksen Ny løsning, velg Mobile Apps mal familie og velg en av malene. Jeg velger PCL-versjonen, men du kan bruke Delt Prosjekt versjon hvis du liker
Trinn 2:. Legg noen kode
Når løsningen er opprettet, la oss legge til noen kode. I den delte prosjektet, opprette en ny klasse og gi den navnet Mainpage. Dette vil være skjermen i applikasjonen som skal inneholde brukergrensesnittet, samt logikk. Dette kan selvsagt være brutt ut i flere logiske brikker, men dette programmet er enkelt nok til at jeg ikke trodde det var nødvendig
Erstatt innholdet i MainPage.cs fil med følgende:.
Hjelp System, bruker Xamarin.Forms, bruker System.Collections.Generic, bruker System.Collections.ObjectModel; namespace MessagingSample {public class Mainpage: ContentPage {private List < streng > _eventTimes; privat bool _isSubscribed = false; private Listview _eventList; offentlig Mainpage () {_eventTimes = new List < streng > (); Var clearButton = new Button {Text = "Clear"}; clearButton.Clicked + = (avsender, e) = > {_eventTimes.Clear (); UpdateList (); }; Var publishButton = new Button {Text = "Publiser"}; publishButton.Clicked + = (avsender, e) = > {MessagingCenter.Send < Mainpage, Datetime > (dette, "boom", DateTime.Now); }; Var subUnsubButton = new Button {Text = "Abonner"}; subUnsubButton.Clicked + = (avsender, e) = > {_isSubscribed = _isSubscribed!; if (_isSubscribed) {subUnsubButton.Text = "Unsubscribe"; MessagingCenter.Subscribe < Mainpage, Datetime > (dette, "boom", (side, tid) = > {_eventTimes.Add (time.ToString ()); UpdateList ();}); } else {subUnsubButton.Text = "Abonner"; MessagingCenter.Unsubscribe < Mainpage, Datetime > (dette, "boom"); }}; Var buttonStack = new StackLayout {Mellomrom = 20, Padding = 20, Orientering = StackOrientation.Horizontal, Barn = {publishButton, subUnsubButton, clearButton} HorizontalOptions = LayoutOptions.CenterAndExpand}; _eventList = new Listview {ItemsSource = new ObservableCollection < streng > (_ eventTimes)}; Var mainStackLayout = new StackLayout {Barn = {buttonStack, _eventList} HorizontalOptions = LayoutOptions.FillAndExpand, VerticalOptions = LayoutOptions.FillAndExpand}; Content = mainStackLayout; } Private void UpdateList () {_eventList.ItemsSource = new ObservableCollection < streng > (_eventTimes); }}}
Dette kan i utgangspunktet virke litt overveldende, men jeg kan forsikre deg om at det er ganske enkel. Det er tre knapper:
Publiser: bruker Send metoden for å publisere en melding med et navn på boom
Abonner /Avmelding: knipser siden blir tegnet /meldt fra boom
Slett: sletter innholdet i Listview
Den grunnleggende forutsetningen for dette programmet er at det starter i et meldt tilstand. I denne tilstanden, hvis du trykker på knappen Publiser, ingenting synes å skje. Vi vet at bommen meldingen blir publisert, men siden det ikke er noen abonnenter, skjer det ingenting.
Når du trykker på knappen Abonner, går programmet inn i en tegnet tilstanden det blir det nå lytter etter bommen melding . Når den mottar denne meldingen, det plasserer en ny Datetime verdi inn i _eventTimes samlingen, som blir oppdatert i den _eventList Listview via en ObservableCollection.
Resten av koden er bare noen grunnleggende formatering og avstand.
Trinn 3: Bygg og Kjør
Kjører programmet i iOS Simulator bør se omtrent slik ut:
På samme måte, den første staten i Android Emulator skal se slik ut .:
Etter å peke på Abonner-knappen og publisere noen meldinger, bør du begynne å se brukergrensesnittet blir oppdatert ved å få noen datetime-verdier i Listview
Konklusjon
Det du har det. Du har nå opprettet en Xamarin.Forms app som utnytter en arkitektur som vanligvis er reservert for store bedrifter. Du skal føle deg ganske spent på dette punktet som du nå har et nytt verktøy i verktøyet belte som vil tillate deg å lage svært skalerbar og fleksibel-for ikke å nevne testbare-applikasjoner som kan kjøre i hånden til sluttbrukeren. Og det kan åpne døren til mange flere muligheter.