---

Agosto 2017

Volume 32 Numero 8

Il presente articolo è stato tradotto automaticamente.

Xamarin.Forms - La personalizzazione di Xamarin.Forms fa volare un'app per droni della FAA ancora più in alto

Da Ermete (commercio) Dan | 2017 agosto

Più di 1 milione drones sono in mani di volantini ricreativi. Gli utenti vengono riprese video precedenti di eventi, geography e natura con fotocamere drone. Volantini drone commerciale sono effettuano verifiche di strutture e chiedere di terreni in modo che i settori in fase di modifica. Tutti questi drones in modalità wireless sono diventate il problema del Federal aerea amministrazione FAA (), che ha risposto con una strategia e una serie di nuovi regolamenti lo scopo di aiutare volantini operano in modo sicuro e legalmente.

È naturalmente, un'applicazione a tale scopo. Viene chiamato B4UFLY e che venga scritto in xamarin. Forms (Nota: B4UFLY viene utilizzato con l'autorizzazione da progettazioni di rete e il FAA). In base a aeroporto FAA e dati sulla località speciali, l'applicazione fornisce volantini con una carta interattiva e gli aggiornamenti di stato in tempo reale in base alla posizione o del volo pianificato. Lo stato riflette il livello di sicurezza di volo e legittimità e consente di individuare le aree da quelle degli aeroporti e spazio aereo con restrizioni di volantini. L'app, come illustrato nella figura 1, è stato scaricato più di 300.000 volte ed è il secondo anno degli aggiornamenti.

Figura 1 B4UFLY pianificazione modalità consente di persone trova posizioni a loro Drones

Il vantaggio di questa implementazione di xamarin. Forms è solo la quantità di esso è realmente multipiattaforma. Delle schermate di 25 nell'app, solo uno richiede personalizzazione specifica della piattaforma. Oggi, molti, la maggior parte, i requisiti di app per dispositivi mobili includono mandato multipiattaforma. Se un piano di app è principalmente di immissione di dati e visualizzazione, navigazione standard e dell'interfaccia utente e minima grafica e animazione, quindi deve essere considerato un candidato sicuro per lo sviluppo con xamarin. Forms.

Che cos'è xamarin. Forms?

Xamarin. Forms è una libreria di classi di interfaccia utente multipiattaforma compilato sopra xamarin e xamarin. IOS associato direttamente al native Windows piattaforma UWP (Universal), come illustrato nella figura 2. Ciò fornisce un set di multipiattaforma di componenti dell'interfaccia utente che eseguono il rendering in ognuno dei tre sistemi operativi nativi.

Figura 2 Xamarin librerie associare alle librerie Native del sistema operativo

Xamarin. Forms fornisce una libreria multipiattaforma di controlli, layout e pagine ed è ideale per iniziare a creare rapidamente un'app. Esistono due modi per creare interfacce utente in xamarin. Forms: uno in c# tramite l'API completa di xamarin. Forms o Extensible Markup Language (XAML), un linguaggio di markup dichiarativo creato da Microsoft.

Cosa desidera che l'aspetto di soluzioni xamarin. Forms.

La soluzione B4UFLY contiene quattro progetti. Il progetto B4UFly contiene il markup di xamarin. Forms e il codice. Il b4ufly. Droid progetto contiene il codice Android specifico e il progetto b4ufly.iOS è l'informazione iOS della soluzione. B4UFly_UITEST contiene script di test dell'interfaccia utente, che può essere eseguito in un computer locale o, in definitiva, su Xamarin Test Cloud.

Il tipo di progetto xamarin. Forms, denominato B4UFly, contiene codice dell'interfaccia utente multipiattaforma scritto in XAML con il codebehind c# e la libreria di xamarin. Forms. Codice di accesso logica e i dati di business multipiattaforma si trova nella cartella UTILS. App. cs è il file di inizializzazione per l'app xamarin. Forms.

Ogni progetto specifico della piattaforma dispone di un proprio file di avvio per il rispettivo sistema operativo. Il progetto Android contiene un file di avvio denominato Mainactivity, che definisce una classe di attività ereditata da Xamarin.Forms.Platform.Android.FormsApplicationActivity.

Il progetto iOS contiene un file di avvio denominato AppDelegate, che eredita da Xamarin.Forms.Platform.iOS.FormsApplicationDelegate.

Dopo aver creato un progetto xamarin. Forms, è possibile seguire lo sviluppo dell'interfaccia utente.

Layout dinamico

B4UFLY si avvalgono di tutti i layout Xamarin standard, tra cui StackLayout, AbsoluteLayout e griglia. Layout di xamarin. Forms può anche essere utilizzato per creare layout dinamici con contenuto che viene modificato in tempo reale. Non è sull'associazione dati, sebbene sia possibile, nonché. Questo argomento vengono descritti modifica la struttura e l'aspetto delle schermate di se stessi.

Le due schermate nell'app più importanti sono la mappa e la pagina di stato. La mappa è in cui viene determinata posizione GPS del WEEE, e in cui vengono visualizzati percorsi circostante e le restrizioni di volo e aeroporti. La mappa è inoltre in cui può essere rilasciato un pin, in cosiddetta modalità di pianificazione, in modo volantini del possono determinare se è sicuro a non esiste.

Nella pagina stato (figura 3) indica all'utente se è sicuro di volo. Esistono tre stati principali: rosso, arancione e giallo. (Non è disponibile alcun colore verde a causa di legali.) Ognuno di questi stati si riflette nella pagina stato da un'icona di stato diverso per il testo nell'intestazione e il colore di sfondo dell'intestazione, nonché il testo visualizzato nella pagina per spiegare lo stato. Anche i pulsanti di informazioni aggiuntive nella parte inferiore della pagina è possono modificare. Nella pagina stato intero è dinamica.

Xamarin. Forms offre diversi modi per modificare il contenuto di un messaggio già creato, fornire contenuto dinamico modificabile in tempo reale. Il primo modo consiste nel modificare layout esistenti e i relativi elementi. La seconda è per mostrare e nascondere gli elementi. Il terzo modo è per aggiungere e rimuovere elementi dalla pagina in c#. B4UFLY utilizza tutti e tre di questi approcci nella schermata di stato.

Modifica layout inizia con un layout per modificare, create tramite XAML in questo caso, se è Impossibile altrettanto facilmente creata mediante c#. In questo esempio è un StackLayout che contiene una barra di stato nella parte superiore della mappa contenente un'icona di stata chiamata topStatusIcon:

<StackLayout x:Name="topStatusIconHolder" Orientation="Horizontal"
  VerticalOptions="FillAndExpand" HorizontalOptions="StartAndExpand" 
  Padding="0, 5, 5, 0" BackgroundColor="White" >
  <Image x:Name="topStatusIcon" Aspect="AspectFit" Source="Blank.png"
    VerticalOptions="CenterAndExpand"
    BackgroundColor="Transparent" HorizontalOptions="CenterAndExpand"
    HeightRequest="50" WidthRequest="50" />
</StackLayout>

A seconda della posizione di volo dell'utente, lo stato è possibile modificare l'entrata o no in tempo reale. In questo esempio viene illustrata una situazione di no in tempo reale e il testo e l'icona vengono aggiornati per riflettere la restrizione:

if (safeToFlyResult.isInForbiddenZone == true)
{
  topStatusTextHolder.BackgroundColor = Color.White;
  topStatusText.Text = "Flight Prohibited";
  topStatusText.IsVisible = true;
  topStatusIcon.Source = ImageSource.FromFile("no_drone_zone.png");

Visualizzare e nascondere elementi inizia con un layout in XAML, lo stato di "Eseguire entrata" in questo caso:

<StackLayout x:Name="stackForbiddenToFly" Orientation="Vertical" IsVisible="false" 
  Padding="10, 20, 10, 5" VerticalOptions="Start">
  <Label x:Name="forbiddenDoNotFlyText" Text="DO NOT FLY YOUR AIRCRAFT" 
    TextColor="#DA4E5B"  
    FontSize="22" FontAttributes="Bold" HorizontalOptions="Center"
    HorizontalTextAlignment="Center" />
</StackLayout>

Quando lo stato viene determinato in quanto è stato scelto un percorso in cui non è consentito il volo drone no in tempo reale, il stackForbiddenToFly StackLayout viene reso visibile (come illustrato nella figura 3):

Figura 3 B4UFLY stato pagina in un'Area No in tempo reale

if (safeToFlyResult.isInForbiddenZone == true)
{
  stackForbiddenToFly.IsVisible = true;
  ...

L'approccio di interfaccia utente dinamica finale è la rimozione fisica di elementi da un layout usando codice c#. Di seguito è riportato un esempio di un layout e un pulsante viene rimosso dalla raccolta di un layout di elementi figlio:

stackCurrentLocationTop.Children.Remove (refreshComboStack);
stackCurrentLocationTop.Children.Remove (dismissImgBtn);

Aggiungere un layout di elementi figlio di un layout:

stackCurrentLocationTop.Children.Add 
       (refreshComboStack, 3, 4, 0, 1);

Questi sono i tre approcci principali all'interfaccia utente dinamica: Modifica layout esistenti e gli elementi, mostrare e nascondere elementi e l'aggiunta e rimozione di elementi e i layout dalle raccolte di layout tramite c#.

Xamarin. Forms è diventata una scelta sempre più semplice con il supporto per la personalizzazione di xamarin. Forms, che fornisce accesso a funzionalità dell'interfaccia utente nativa in sospeso. Una buona regola pratica è che non si desidera personalizzare (piattaforma) necessario più di 20 al 30 percento dell'app. Più che ed è necessario utilizzare un'opzione di specifica della piattaforma, ad esempio xamarin o xamarin. IOS. In modo che cosa significa personalizzare un'app xamarin. Forms?

Personalizzazione dell'App con xamarin. Forms

Prima del rilascio di xamarin. Forms, trattasse del codice della logica di business multipiattaforma dell'app mobile e il livello di dati in c#. Creerebbe quindi my interfacce utente con accesso completo per il SDK di nativo sottostante, ma è necessario apportare le interfacce utente per ogni piattaforma usando xamarin. IOS, xamarin o Windows 10 SDK.

Pertanto, quando è stato annunciato che con xamarin. Forms è possibile compilare una sola volta l'interfaccia utente di dispositivi mobili e compilare per iOS, Android e la piattaforma UWP, il cuore ignorato un heartbeat. Infatti è ciò che sempre longed per: un'esperienza di sviluppo multipiattaforma end-to-end.

Tuttavia, conosce solo il livello di profondità Xamarin già è verificato un quando fornito all'interfaccia utente nativa e spiega: "Se è necessario un elemento che non è possibile eseguire xamarin. Forms?"

Viene richiesto di tutti gli utenti che per spiegare esattamente ciò che è possibile eseguire xamarin. Forms e l'effetto che non è stato, di sapere e ho ricevuto numerose risposte straordinaria che ha consentito di comprendere meglio xamarin. Forms, ma nessuno effettivamente possibile rispondere alle domande. In tal caso, ho scritto un libro per tale operazione: "Sviluppo di applicazioni mobili Xamarin" (Apress, 2015). Di seguito è un spoiler: Utilizzare un renderer personalizzato.

Renderer personalizzati offrono la possibilità di entrata verso il basso attraverso l'astrazione di xamarin. Forms e ottenere l'accesso diretto a xamarin, xamarin. IOS e la piattaforma UWP. Questo significa che l'accesso per il SDK dell'interfaccia utente nativa: iOS UIKit, Android SDK e Windows 10 SDK. Ogni volta che si desidera utilizzare funzionalità native per iOS, Android e Windows, è possibile creare viste specifiche della piattaforma e le pagine nel progetto specifico della piattaforma.

Tramite l'inserimento di dipendenze predefiniti di xamarin. Forms, inizializzare, si fa riferimento la classe dell'interfaccia utente personalizzata e Xamarin automaticamente dal progetto della piattaforma appropriata per l'utente. Ovvero come pagina della mappa è stata compilata in B4UFLY.

Ma cosa accade se sufficiente modificare uno o due proprietà o eventi e non è necessaria un'intera classe di interfaccia utente personalizzata?

Immettere gli effetti. Codifica un'intera classe di rendering dell'interfaccia utente per ogni piattaforma può essere un numero eccessivo. Talvolta, tutto ciò che serve è un tweak a un elemento singolo controllo, ad esempio un'ombreggiatura in un'etichetta. Mentre un renderer personalizzato esporre un'intera classe specifico della piattaforma, effetti espone solo le proprietà. Non sottoclassato l'intero elemento, anche se è necessaria una classe specifica della piattaforma. Un effetto di xamarin. Forms offre questo approccio precisione alla personalizzazione dell'interfaccia utente specifiche della piattaforma.

Cosa accade se si necessita è un controllo nativo nel layout di xamarin. Forms?

Evitare di dichiarare un controllo specifico della piattaforma, detto anche "controllo nativo", anche se si tratta di un controllo di Xamarin e non è realmente nativo. Anziché eccessivamente nel codice personalizzato renderer personalizzato, dichiarare viste native da xamarin. IOS, xamarin o alla piattaforma UWP direttamente nel layout di xamarin. Forms. Utilizzando un progetto condiviso e la compilazione condizionale, includere le raccolte di UI specifico della piattaforma nelle classi c# dell'interfaccia utente in cui è possibile farvi riferimento come direttamente come se si sono stati la codifica nella piattaforma nativa. Impostare le proprietà e i gestori eventi in queste viste e usarli side-by-side con le visualizzazioni di xamarin. Forms, in c# e XAML.

Sviluppo di xamarin. Forms offre la semplicità di sviluppo multipiattaforma con c# e una singola libreria dell'interfaccia utente con una base solida di opzioni di personalizzazione per tutte le volte quando si necessita delle funzionalità native. Utilizzare un renderer personalizzato per generare classi di interfaccia utente specifiche della piattaforma usando xamarin. IOS, xamarin e alla piattaforma UWP. Utilizzare gli effetti per accedere alle proprietà specifici della piattaforma. E quando non è possibile eseguire senza il componente reale, dichiarare una vista nativa nel layout xamarin. Forms.

Un renderer personalizzato, ovvero B4UFLY mappa

La pagina della mappa B4UfLY è la pagina sola da più di 25 nell'app che richiedono la personalizzazione. Tale rapporto delle 25:1 generico xamarin. Forms pagine personalizzato rende sicuro case study questa app per xamarin. Forms.

La mappa usa la posizione corrente e fornisce immediato circostante restrizioni di volo e avvisi, come illustrato nella figura 4.

Figura 4 mappa pagina lessico sistemi ufficio in Beverly, Mass.

Una variazione nella pagina mappa è in modalità di pianificazione, che consente il rilascio di un pin per determinare le restrizioni e gli stati di volo del ipotetica posizioni, come illustrato nel figura 5. Si noti l'icona nella parte superiore sinistra che indica "no immediatamente" a causa di uno spazio aereo controllato nelle vicinanze (l'icona di "C").

Figura 5 B4UFLY pianificazione in modalità pagina in San Francisco, California

Xamarin. Forms associa solo una frazione di funzionalità disponibili nelle librerie dell'interfaccia utente completate specifico della piattaforma (iOS Webkit, Android SDK e Windows 10 SDK). Fortunatamente, xamarin. Forms espone il meccanismo in base al quale multipiattaforma viste vengono convertite in viste specifiche della piattaforma. Questo meccanismo è denominato per il rendering. Per creare il propria renderer personalizzato, si otterrà accesso completo alle funzionalità specifiche della piattaforma nascosti complete all'interno di ogni visualizzazione.

Renderer personalizzati sono un bridge tra xamarin. Forms e Xamarin librerie specifiche della piattaforma, xamarin. IOS, xamarin e Windows 10 SDK. Considerare un renderer personalizzato come un modo per accedere ed estendere l'associazione tra gli elementi specifici della piattaforma e xamarin. Forms.

Chiamata di requisiti di progetto per le funzionalità non disponibili con la libreria Xamarin.Forms.Maps della casella, tra cui la posizione delle icone e le aree colorate attorno a ogni icona per delimitare gli determinati spazi aerei sulla mappa. Per il rendering personalizzate per il salvataggio. A partire da MapPage, create ereditando ContentPage, è possibile creare una classe base, che è possibile utilizzare per personalizzare il renderer per ogni piattaforma, consentendo di codice personalizzata grafica separatamente per iOS e Android:

namespace b4ufly.iOS
{
  public partial class MapPage : ContentPage
  {
    public static MapPage me = null;
    public static MyMap map = null;
    public static Boolean plannerModeOn = false;

Dopo aver creato un elemento personalizzato, MapPage, sarà necessario creare il renderer personalizzato per ogni piattaforma, iOS e Android in B4UFLY, anche se è possibile farlo anche per la piattaforma UWP. Renderer di tenere presente una visualizzazione sulla piattaforma nativa. Creare il propria renderer ereditando dalla classe di MapRenderer standard, a partire da iOS:

[assembly:ExportRenderer (typeof(MyMap), typeof(MyMapRenderer))]
namespace b4ufly.iOS
{
  public class MyMapRenderer : MapRenderer, MapExtension
  {

MyMapRenderer disegna le posizioni sulla mappa che drone devono essere consapevoli di volantini: aeroporti, controllato spazio aereo, militare strutture e così via. Il renderer disegna le icone e circostante aree colorate che indica lo spazio aereo di importanti. Questi tipi di grafici sono gestiti in modo leggermente diverso in iOS rispetto a in Android. Il renderer Android mappa utilizza un approccio simile a quella utilizzata per iOS:

[assembly: ExportRenderer (typeof(MyMap), typeof(MyMapRenderer))]
namespace b4ufly.Droid
{

  public class MyMapRenderer : MapRenderer, MapExtension,  
    GoogleMap.IOnCameraChangeListener, GoogleMap.IOnMarkerDragListener,  
    GoogleMap.IOnMarkerClickListener
  {

Dopo aver creato il renderer, è necessario utilizzarli. In base al tipo di dati MyMap, che usa il MyMapRenderer, l'istruzione seguente crea un'istanza di una mappa specifica della piattaforma:

map = new MyMap(MapSpan.FromCenterAndRadius(new Position(0, 0), Distance.FromMiles(1.0)))

Il meccanismo Inversion of Control (IoC) incorporato in xamarin. Forms Usa il renderer dal progetto della piattaforma in corso la generazione. Aggiungendo i riferimenti della mappa specifico della piattaforma, è Impossibile creare istanze in modo esplicito un Mapkit Apple nel renderer del iOS e una mappa di Google nel renderer del Android.

Personalizzazione di elementi di xamarin. Forms riconducibili a una visualizzazione diversa dell'architettura della soluzione, con il renderer personalizzato che si trova nel livello dell'interfaccia utente specifiche della piattaforma intermedio, come illustrato nella figura 6.

Interfaccia utente xamarin. Forms nella figura 6

Un renderer personalizzato è potente e completa nella loro implementazione come realizzare l'obiettivo specifico della piattaforma di elementi dell'interfaccia utente xamarin. Forms. Un renderer personalizzato è, tuttavia, artillery elevato. Se si desidera qualcosa di più tattico, ad esempio semplicemente la personalizzazione di una proprietà in un controllo di xamarin. Forms, tenere in considerazione "effetto".

Effetti

Effetti forniscono l'accesso alle singole proprietà specifiche della piattaforma di controlli e possono essere parametrizzati. Per creare un effetto, è necessario creare innanzitutto una classe che è una sottoclasse della classe RoutingEffect. Ricordare che gli override del metodo e attributi. Utilizzare quindi l'effetto dell'app.

Oltre a esporre le proprietà, gli effetti hanno anche la capacità di passare parametri a tali proprietà e definire gli eventi nei controlli di xamarin. Forms. Parametri vengono passati all'effetto utilizzando la proprietà associata o Common Language Runtime (CLR). Nell'esempio seguente viene utilizzato Common Language Runtime per associare le proprietà per l'effetto e crea il DropShadowEffect nel progetto xamarin. Forms:

public class DropShadowEffect : RoutingEffect
{
  public Color Color { get; set; } 

  public DropShadowEffect () : base ("FAA.DropShadowEffectLabel")
    {           
    }
}

Questo effetto etichetta fornisce una proprietà di colore dell'ombreggiatura e fa riferimento all'implementazione specifica della piattaforma di DropShadowEffectLabel nella relativa classe base.

L'effetto è implementare in un progetto specifico della piattaforma, in modo simile a un renderer personalizzato, anche se l'implementazione è facoltativa in ogni piattaforma. Una volta per ogni progetto, aggiungere un attributo ResolutionGroupName contenente il nome della società per evitare conflitti con altri effetti lo stesso nome. Ogni classe effetto è una sottoclasse di PlatformEffect ed è necessario un ExportEffect, che registra l'effetto con xamarin. Forms. Figura 7 viene illustrata un'implementazione in iOS nel progetto xamarin. IOS.

Figura 7 iOS implementazione di DropShadowEffectLabel

[assembly:ResolutionGroupName ("FAA")]
[assembly:ExportEffect (typeof(DropShadowEffectLabel), "DropShadowEffectLabel")]
namespace b4ufly.iOS
{
  public class DropShadowEffectLabel : PlatformEffect
  {
    protected override void OnAttached ()
    {
      try {
        var effect = 
         (DropShadowEffect)Element.Effects.FirstOrDefault 
           (e => e is DropShadowEffect);
        if (effect != null) {
          Control.Layer.ShadowColor = effect.Color.ToCGColor();
          Control.Layer.CornerRadius = 5;
          Control.Layer.ShadowOffset = new CGSize (5, 5);
          Control.Layer.ShadowOpacity = 1.0f;          }
    } catch (Exception ex) 
    {
      Console.WriteLine ("Cannot set effect property. Error: ", ex.Message);
    }
    }

    protected override void OnDetached ()
    {
    }
}

Il controllo è un iOS UIView.PlatformEffect che espone questi metodi e che deve essere sottoposto a override:

• OnAttached: personalizzare il controllo qui
• OnDetached, eseguire la pulizia (ad esempio, annullare la registrazione di eventi)

Di seguito è l'implementazione di Android, simile all'effetto iOS, ad eccezione del fatto che il controllo etichetta è il controllo TextView Android specifiche, come illustrato nella figura 8. Il controllo TextView è tipizzato in modo esplicito per accedere al metodo SetShadowLayer.

Figura 8 implementazione Android di DropShadowEffectLabel

[assembly:ResolutionGroupName ("FAA")]
[assembly:ExportEffect (typeof(DropShadowEffectLabel), "DropShadowEffectLabel")]
namespace b4ufly.Droid
{
  public class DropShadowEffectLabel : PlatformEffect
  {

    protected override void OnAttached ()
    {
      try {
        var control = Control as Android.Widget.TextView;
        var effect = 
         (DropShadowEffect)Element.Effects.FirstOrDefault 
           (e => e is DropShadowEffect);
        if (effect != null) {
          Android.Graphics.Color color = effect.Color.ToAndroid ();
          control.SetShadowLayer (5, 5, 5, color); 
          // params: radius, offsetX, offsetY, color
        }
      } catch (Exception ex) {
        Console.WriteLine ("Cannot set effect property. Error: ", ex.Message);
      }
    }

    protected override void OnDetached ()
    {
    }
  }
}

Una volta l'effetto, è necessario richiamarlo. Innanzitutto, un controllo deve essere dichiarato in XAML o c#. Allegare quindi l'effetto al controllo aggiungendolo alla raccolta di effetti del controllo. L'esempio seguente viene illustrato l'approccio XAML con un controllo voce dichiarato in XAML con il DropShadowEffect aggiunto alla raccolta di effetti del controllo e proprietà del colore impostato su nero:

<Label Text="Label with Shadow" ... >
  <Label.Effects>
    <local:DropShadowEffect Color="Black">
    </local:DropShadowEffect>
  </Label.Effects>
</Label>

Il linguaggio c# anziché il linguaggio XAML, l'etichetta con effetto collegato è possibile creare, come illustrato di seguito:

var label = new Label {
  Text = "Label with Shadow",
  ...
};
label.Effects.Add (new DropShadowEffect {
  Color = Color.Black,
});

Personalizzazione tattica tramite effetti consente di apportare modifiche specifiche per i controlli di xamarin. Forms, ma talvolta modificando solo determinati metodi e proprietà non è sufficiente. Quando si desidera utilizzare molte delle funzionalità di un controllo nativo, impedisce tale eseguono numerose operazioni di codifica di effetti personalizzati.

Dichiarazione di vista nativo

Talvolta si desidera il controllo completo dell'interfaccia utente. Fortunatamente è ora disponibile un modo per ottenere questo tramite la dichiarazione di vista native in xamarin. Forms. Controlli nativi dichiarati sono incredibilmente potenti, ma non sono senza limitazioni. Si tratta di una più facile da usare in XAML, poi in c# utilizzando un progetto condiviso (che viene chiamato l'incorporamento nativo), anche se è possibile ma non semplice o consigliabile utilizzare in una libreria di classe portabile (PCL). In molti progetti utilizzare PCLs che spesso viste native di mezzo migliore utilizzati in XAML e che è l'approccio che descritti di seguito.

Sono disponibili due passaggi nella dichiarazione di una vista native in XAML. Innanzitutto, specificare lo spazio dei nomi per ogni origine nativa. In secondo luogo, dichiarare tale visualizzazione. Figura 9 Mostra un esempio, utilizzando il controllo etichetta. Inizia con la pagina XAML di base e definisce gli spazi dei nomi per iOS, Android e Windows (illustrata nel codice in grassetto).

Figura 9 controllo nativo Namespace dichiarazioni

<?xml version="1.0" encoding="utf-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
  xmlns:x="https://schemas.microsoft.com/winfx/2009/xaml"
  xmlns:ios="clr-namespace:UIKit;assembly=Xamarin.iOS;targetPlatform=iOS"
  xmlns:androidWidget="clr-namespace:Android.Widget;assembly=
    Mono.Android;targetPlatform=Android"
    xmlns:formsandroid="clr-namespace:Xamarin.Forms;assembly=
    Xamarin.Forms.Platform.Android;targetPlatform=Android"
  xmlns:win="clr-namespace:Windows.UI.Xaml.Controls;assembly=Windows, 
    Version=255.255.255.255, Culture=neutral, PublicKeyToken=null, 
    ContentType=WindowsRuntime;targetPlatform=Windows"
  x:Class="b4ufly.NativeView" >
  <ContentPage.Content>
  </ContentPage.Content>
</ContentPage>

Visualizzazioni native successiva vengono dichiarate nella proprietà del contenuto di ContentPage. UILabel per iOS, un oggetto TextView per Android e un controllo TextBlock per Windows:

<ContentPage.Content>
  <ios:UILabel Text="This is an iOS UILabel" View.HorizontalOptions="Start"/>
  <androidWidget:TextView Text="This is an Android TextView" 
    x:Arguments="{x:Static formsandroid:Forms.Context}" />
  <win:TextBlock Text="This is a Windows TextBlock"/>
</ContentPage.Content>

Questi sono i tre approcci alla personalizzazione di xamarin. Forms: un renderer personalizzato, gli effetti e dichiarazione di vista nativo. Renderer personalizzato è un'opzione di ad alta densità che offre una notevole flessibilità, mentre gli effetti fornisce un approccio costituite da tagli alla personalizzazione. Dichiarazione di vista nativa è l'opzione nucleare, evitando di utilizzare completamente xamarin. Forms.

Conclusioni

Sarà infine necessario supera il limite di xamarin. Forms offre out-of-the-box, come con B4UFLY. Quando le attività complesse o le progettazioni sono richiesti da xamarin. Forms, qualsiasi elemento è possibile utilizzare xamarin. Forms personalizzazione. Personalizzazione consente di accedere alle classi di livello inferiore, specifici della piattaforma, per il rendering di schermata denominato "renderer", che utilizza controlli specifici della piattaforma per creare tutte le schermate di xamarin. Forms. Qualsiasi schermata di xamarin. Forms può essere suddiviso nelle schermate specifiche della piattaforma, classi, i controlli e le proprietà utilizzando questo approccio.

Un approccio più semplice consiste nell'utilizzare effetti di accedere a eventi e proprietà specifiche della piattaforma. È possibile utilizzare anche intera controlli nativi nelle pagine di xamarin. Forms mediante dichiarazione di vista nativo.

Ciò significa che è possibile scrivere una pagina di xamarin. Forms o l'app e personalizzarla in base alla piattaforma. Personalizzazione usata con cautela, o una frammentazione dell'interfaccia utente codebase che probabilmente dovrebbe essere stato scritto completamente come un'interfaccia utente specifiche della piattaforma di rischio. Utilizzarlo con cautela, personalizzazione possibile attivare il prodotto lackluster di base in un'app versatile univoca, più diffusa.

In B4UFLY, investimento del FAA in xamarin. Forms continua il pagamento a causa di numerosi miglioramenti in corso generiche per le numerose pagine basata su testo multipiattaforma. Pagina della mappa specifico della piattaforma contiene alcuni elementi multipiattaforma, ma la maggior parte di tale pagina richiede la personalizzazione specifica della piattaforma. Questa architettura di xamarin. Forms è estensibile e i costi e tempi di sviluppo sono inferiori a causa di tale ambiente. il riutilizzo del codice significativo è pratico ed elegante.

---

Dan Hermes è MVP di Xamarin, MVP di Microsoft e l'autore di "Sviluppo di applicazioni mobili Xamarin". Giorgio è il server principale dei sistemi di lessico, consulenza basato su Boston compilazione di applicazioni mobili pluripremiato e aiuta le aziende di creare le proprie App ha esito positivo. Seguire il suo blog all'indirizzo mobilecsharpcafe.com, su Twitter: @danhermes o contattarlo dan@lexiconsystemsinc.com.

Un ringraziamento al seguente esperto tecnico per la revisione dell'articolo: Jesse Liberty

---

Viene illustrato in questo articolo nel forum di MSDN Magazine