Xamarin.Forms Rychlý Start s hloubkovým podrobně

V Xamarin.Forms Quickstart aplikaci byly vytvořeny poznámky. Tento článek obsahuje informace o tom, co bylo sestaveno, aby bylo možné získat přehled o základech fungování Xamarin.Forms aplikací prostředí.

Projekt se také skládá z několika souborů:

• Data\NoteDatabase.cs – Tato třída obsahuje kód pro vytvoření databáze, načtení dat z ní, zápis dat do ní a odstranění dat z ní.
• Models\Note.cs – Tato třída definuje model, jehož instance ukládají data o každé poznámce v aplikaci.
• Views\AboutPage.XAML – kód XAML pro třídu, která definuje uživatelské rozhraní pro stránku o produktu.
• Views\AboutPage.XAML.cs – kód na pozadí pro třídu, která obsahuje obchodní logiku, která se spustí, když uživatel pracuje se stránkou.
• Views\NotesPage.XAML – kód XAML pro třídu, která definuje uživatelské rozhraní stránky zobrazené při spuštění aplikace.
• Views\NotesPage.XAML.cs – kód na pozadí pro třídu, která obsahuje obchodní logiku, která se spustí, když uživatel pracuje se stránkou.
• Views\NoteEntryPage.XAML – kód XAML pro třídu, která definuje uživatelské rozhraní stránky zobrazené, když uživatel zadá poznámku.
• Views\NoteEntryPage.XAML.cs – kód na pozadí pro třídu, která obsahuje obchodní logiku, která se spustí, když uživatel pracuje se stránkou.
• App. XAML – kód XAML pro třídu, která definuje slovník prostředků pro aplikaci.
• App. XAML. cs – kód na pozadí pro třídu, která je zodpovědná za vytváření instancí aplikace prostředí a pro zpracování událostí životního cyklu aplikace.
• AppShell. XAML – kód XAML pro třídu, která definuje vizuální hierarchii aplikace.
• AppShell. XAML. cs – kód na pozadí pro třídu, která vytvoří trasu pro NoteEntryPage , aby mohla být přesměrována do kódu programu.
• AssemblyInfo. cs – tento soubor obsahuje atribut aplikace o projektu, který se používá na úrovni sestavení.

Další informace o anatomii aplikace Xamarin. iOS najdete v tématu anatomie aplikace Xamarin. iOS. Další informace o anatomii aplikace Xamarin. Android najdete v tématu anatomie aplikace Xamarin. Android.

Architektura a základy aplikací

Xamarin.FormsAplikace je navržena stejným způsobem jako tradiční aplikace pro různé platformy. Sdílený kód je obvykle umístěn v knihovně .NET Standard a aplikace specifické pro platformu spotřebují sdílený kód. Následující diagram znázorňuje přehled této relace pro aplikaci Notes:

Aby bylo možné maximalizovat opakované použití spouštěcího kódu, Xamarin.Forms aplikace mají jednu třídu s názvem App , která je zodpovědná za vytváření instancí aplikace na každé platformě, jak je znázorněno v následujícím příkladu kódu:

using Xamarin.Forms;

namespace Notes
{
    public partial class App : Application
    {
        public App()
        {
            InitializeComponent();
            MainPage = new AppShell();
        }
        // ...
    }
}

Tento kód nastaví MainPage vlastnost App třídy na AppShell objekt. AppShellTřída definuje vizuální hierarchii aplikace. Prostředí získá tuto vizuální hierarchii a vytvoří pro ni uživatelské rozhraní. Další informace o definování vizuální hierarchie aplikace naleznete v tématu Visual Hierarchy aplikace.

Kromě toho obsahuje soubor AssemblyInfo. cs jeden atribut aplikace, který je použit na úrovni sestavení:

using Xamarin.Forms.Xaml;

[assembly: XamlCompilation(XamlCompilationOptions.Compile)]

XamlCompilationAtribut zapne kompilátor XAML, takže je XAML zkompilován přímo do mezilehlého jazyka. Další informace naleznete v tématu kompilace XAML.

Spustit aplikaci na všech platformách

Způsob, jakým se aplikace spouští na jednotlivých platformách, je specifická pro platformu.

iOS

Chcete-li spustit počáteční Xamarin.Forms stránku v iOS, projekt poznámky. iOS definuje AppDelegate třídu, která dědí z FormsApplicationDelegate třídy:

namespace Notes.iOS
{
    [Register("AppDelegate")]
    public partial class AppDelegate : global::Xamarin.Forms.Platform.iOS.FormsApplicationDelegate
    {
        public override bool FinishedLaunching(UIApplication app, NSDictionary options)
        {
            global::Xamarin.Forms.Forms.Init();
            LoadApplication(new App());
            return base.FinishedLaunching(app, options);
        }
    }
}

FinishedLaunchingPřepsání inicializuje Xamarin.Forms rozhraní voláním Init metody. To způsobí, že implementace specifická pro iOS bude Xamarin.Forms načtena do aplikace před tím, než se kontroler kořenového zobrazení nastaví voláním LoadApplication metody.

Android

Chcete-li spustit počáteční Xamarin.Forms stránku v Androidu, projekt Notes. Android obsahuje kód, který vytvoří Activity s MainLauncher atributem s aktivitou, která dědí z FormsAppCompatActivity třídy:

namespace Notes.Droid
{
    [Activity(Label = "Notes",
              Icon = "@mipmap/icon",
              Theme = "@style/MainTheme",
              MainLauncher = true,
              ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation)]
    public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity
    {
        protected override void OnCreate(Bundle savedInstanceState)
        {
            TabLayoutResource = Resource.Layout.Tabbar;
            ToolbarResource = Resource.Layout.Toolbar;

            base.OnCreate(savedInstanceState);
            global::Xamarin.Forms.Forms.Init(this, savedInstanceState);
            LoadApplication(new App());
        }
    }
}

OnCreatePřepsání inicializuje Xamarin.Forms rozhraní voláním Init metody. To způsobí, že implementace specifická pro Android Xamarin.Forms bude načtena do aplikace před Xamarin.Forms načtením aplikace.

Vizuální hierarchie aplikace

Xamarin.Forms Aplikace prostředí definují vizuální hierarchii aplikace ve třídě, která podtřídí Shell třídu. V aplikaci Notes se jedná o Appshell třídu:

<Shell xmlns="http://xamarin.com/schemas/2014/forms"
       xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
       xmlns:views="clr-namespace:Notes.Views"
       x:Class="Notes.AppShell">
    <TabBar>
        <ShellContent Title="Notes"
                      Icon="icon_feed.png"
                      ContentTemplate="{DataTemplate views:NotesPage}" />
        <ShellContent Title="About"
                      Icon="icon_about.png"
                      ContentTemplate="{DataTemplate views:AboutPage}" />
    </TabBar>
</Shell>

Tento kód XAML se skládá ze dvou hlavních objektů:

• TabBar. TabBarPředstavuje spodní panel karet a měl by být použit v případě, že navigační vzor aplikace používá dolní karty. TabBarObjekt je podřízený objekt Shell objektu.
• ShellContent, který představuje ContentPage objekty pro každou kartu v TabBar . Každý ShellContent objekt je podřízený TabBar objekt objektu.

Tyto objekty nepředstavuje žádné uživatelské rozhraní, ale spíše i organizaci vizuální hierarchie aplikace. Prostředí provede tyto objekty a vytvoří navigační uživatelské rozhraní pro obsah. Proto AppShell Třída definuje definice dvou stránek, které se naviguje z dolních karet. Stránky jsou vytvořeny na vyžádání v reakci na navigaci.

Další informace o aplikacích prostředí naleznete v tématu Xamarin.Forms Shell .

Uživatelské rozhraní

K vytvoření uživatelského rozhraní aplikace se používá několik skupin ovládacích prvků Xamarin.Forms :

1. Stránky – stránky znázorňují obrazovky mobilní aplikace pro různé platformy. Aplikace Notes používá ContentPage třídu k zobrazení jednotlivých obrazovek. Další informace o stránkách naleznete v tématu Xamarin.Forms Pages .
2. Zobrazení – zobrazení jsou ovládací prvky zobrazené v uživatelském rozhraní, například popisky, tlačítka a textové vstupní pole. Dokončená aplikace s poznámkami CollectionView používá Editor zobrazení, a Button . Další informace o zobrazeních naleznete v tématu Xamarin.Forms Views .
3. Rozložení – rozložení jsou kontejnery používané k vytváření zobrazení do logických struktur. Aplikace Notes používá StackLayout třídu k uspořádání zobrazení ve svislém zásobníku a Grid třídě k vodorovnému uspořádání tlačítek. Další informace o rozložení najdete v tématu Xamarin.Forms Layouts .

Za běhu se každý ovládací prvek namapuje na jeho nativní ekvivalent, který se vykreslí.

Layout

Aplikace Notes používá StackLayout ke zjednodušení vývoje aplikací pro různé platformy tím, že automaticky uspořádává zobrazení na obrazovce bez ohledu na velikost obrazovky. Každý podřízený element je umístěný po druhém, vodorovně nebo svisle v pořadí, v jakém byly přidány. Velikost místa, které StackLayout bude používat, závisí na tom, jak Xamarin_Forms StackLayout _View_HorizontalOptions "data-LINKTYPE =" absolutní cesta ">HorizontalOptions a Xamarin_Forms _View_HorizontalOptions" data-LINKTYPE = "absolutní cesta" >VerticalOptions vlastnosti jsou nastaveny, ale ve výchozím nastavení se StackLayout pokusí použít celou obrazovku.

Následující kód XAML ukazuje příklad použití prvku StackLayout k rozložení NoteEntryPage :

<?xml version="1.0" encoding="UTF-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="Notes.Views.NoteEntryPage"
             Title="Note Entry">
    ...    
    <StackLayout Margin="{StaticResource PageMargin}">
        <Editor Placeholder="Enter your note"
                Text="{Binding Text}"
                HeightRequest="100" />
        <Grid>
            ...
        </Grid>
    </StackLayout>    
</ContentPage>

Ve výchozím nastavení StackLayout předpokládá, že převezme svislou orientaci. Dá se ale změnit na vodorovnou orientaci nastavením Xamarin_Forms _StackLayout_Orientation data-LINKTYPE = "absolutní cesta" >StackLayout.Orientation vlastnost na Xamarin_Forms StackLayout.Orientation _StackOrientation_Horizontal data-linktype = "absolutní cesta" >StackOrientation.Horizontal člen výčtu.

Další informace o StackLayout třídě naleznete v tématu Xamarin.Forms StackLayout .

Reakce na interakci s uživatelem

Objekt definovaný v jazyce XAML může vyvolat událost, která je zpracována v souboru kódu na pozadí. Následující příklad kódu ukazuje OnSaveButtonClicked metodu v kódu na pozadí pro NoteEntryPage třídu, která je spuštěna v reakci na Clicked událost na tlačítku OnSaveButtonClicked .

async void OnSaveButtonClicked(object sender, EventArgs e)
{
    var note = (Note)BindingContext;
    note.Date = DateTime.UtcNow;
    if (!string.IsNullOrWhiteSpace(note.Text))
    {
        await App.Database.SaveNoteAsync(note);
    }
    await Shell.Current.GoToAsync("..");
}

OnSaveButtonClickedMetoda uloží poznámku do databáze a přejde zpět na předchozí stránku. Další informace o navigaci naleznete v tématu Navigace.

OnSaveButtonClickedV kódu XAML pro třídu probíhá propojení tlačítka Uložit k metodě NoteEntryPage :

<Button Text="Save"
        Clicked="OnSaveButtonClicked" />

Seznamy

CollectionViewZodpovídá za zobrazení kolekce položek v seznamu. Ve výchozím nastavení se položky seznamu zobrazují svisle a každá položka se zobrazí na jednom řádku.

Následující příklad kódu ukazuje CollectionView z NotesPage :

<CollectionView x:Name="collectionView"
                Margin="{StaticResource PageMargin}"
                SelectionMode="Single"
                SelectionChanged="OnSelectionChanged">
    <CollectionView.ItemsLayout>
        <LinearItemsLayout Orientation="Vertical"
                           ItemSpacing="10" />
    </CollectionView.ItemsLayout>
    <CollectionView.ItemTemplate>
        <DataTemplate>
            <StackLayout>
                <Label Text="{Binding Text}"
                       FontSize="Medium" />
                <Label Text="{Binding Date}"
                       TextColor="{StaticResource TertiaryColor}"
                       FontSize="Small" />
            </StackLayout>
        </DataTemplate>
    </CollectionView.ItemTemplate>
</CollectionView>

Rozložení každého řádku v CollectionView je definováno v rámci Xamarin_Forms CollectionView _ItemsView_1_ItemTemplate "data-LINKTYPE =" absolutní cesta ">CollectionView.ItemTemplate element a používá datovou vazbu k zobrazení všech poznámek, které jsou načteny aplikací. Vlastnost Xamarin_Forms _ItemsView_1_ItemsSource data-LINKTYPE = "absolutní cesta" >CollectionView.ItemsSource vlastnost je nastavena na hodnotu zdroj dat v souboru CollectionView.ItemsSource:

protected override async void OnAppearing()
{
    base.OnAppearing();

    collectionView.ItemsSource = await App.Database.GetNotesAsync();
}

Tento kód naplní CollectionView všechny poznámky uložené v databázi a provede se při zobrazení stránky.

Když je vybrána položka v CollectionView , SelectionChanged událost je aktivována. Obslužná rutina události s názvem se OnSelectionChanged spustí, když se událost aktivuje:

async void OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
    if (e.CurrentSelection != null)
    {
        // ...
    }
}

SelectionChangedUdálost má přístup k objektu, který byl přidružen k položce prostřednictvím e.CurrentSelection Vlastnosti.

Další informace o CollectionView třídě naleznete v tématu Xamarin.Forms CollectionView .

Navigace

Navigace se provádí v aplikaci prostředí zadáním identifikátoru URI, na který se má přejít. Identifikátory URI pro navigaci mají tři součásti:

• Trasa, která definuje cestu k obsahu, který existuje jako součást vizuální hierarchie prostředí.
• Stránka. Stránky, které neexistují ve vizuální hierarchii prostředí, se dají do navigačního zásobníku vložit odkudkoli v rámci aplikace prostředí. Například NoteEntryPage není definován ve vizuální hierarchii prostředí, ale lze jej do navigačního zásobníku vložit podle potřeby.
• Jeden nebo více parametrů dotazu. Parametry dotazu jsou parametry, které lze předat cílové stránce při navigaci.

Identifikátor URI navigace nemusí zahrnovat všechny tři komponenty, ale pokud je struktura://Route/Page? queryParameters

Další informace o navigaci v prostředí najdete v tématu Xamarin.Forms Shell navigation .

Registrovat trasy

Aby bylo možné přejít na stránku, která neexistuje ve vizuální hierarchii prostředí, je nutné ji nejprve zaregistrovat v systému směrování prostředí. pomocí Routing.RegisterRoute metody. V aplikaci Notes k tomu dojde v AppShell konstruktoru:

public partial class AppShell : Shell
{
    public AppShell()
    {
        // ...
        Routing.RegisterRoute(nameof(NoteEntryPage), typeof(NoteEntryPage));
    }
}

V tomto příkladu je trasa s názvem NoteEntryPage registrována pro NoteEntryPage typ. Tato stránka se pak dá přejít na použití navigace na základě identifikátoru URI z libovolného místa v aplikaci.

Provést navigaci

Navigace je prováděna GoToAsync metodou, která přijímá argument reprezentující trasu, do které se má přejít:

await Shell.Current.GoToAsync("NoteEntryPage");

V tomto příkladu NoteEntryPage je přesměrován na.

Při přechodu na stránku lze na stránku předat data jako parametr dotazu:

async void OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
    if (e.CurrentSelection != null)
    {
        // Navigate to the NoteEntryPage, passing the ID as a query parameter.
        Note note = (Note)e.CurrentSelection.FirstOrDefault();
        await Shell.Current.GoToAsync($"{nameof(NoteEntryPage)}?{nameof(NoteEntryPage.ItemId)}={note.ID.ToString()}");
    }
}

Tento příklad načte aktuálně vybranou položku v CollectionView a přejde do objektu NoteEntryPage s hodnotou vlastnosti objektu, který je IDNote předán jako parametr dotazu NoteEntryPage.ItemId Vlastnosti.

Pro příjem předaných dat NoteEntryPage Třída je upravena pomocí QueryPropertyAttribute

[QueryProperty(nameof(ItemId), nameof(ItemId))]
public partial class NoteEntryPage : ContentPage
{
    public string ItemId
    {
        set
        {
            LoadNote(value);
        }
    }
    // ...
}

První argument pro QueryPropertyAttribute Určuje, že ItemId vlastnost obdrží předávaná data s druhým argumentem, který určuje ID parametru dotazu. Proto QueryPropertyAttribute v předchozím příkladu určuje, že ItemId vlastnost obdrží data předaná ItemId parametrem dotazu z identifikátoru URI ve GoToAsync volání metody. ItemIdVlastnost pak zavolá LoadNote metodu pro načtení poznámky ze zařízení.

Zpětná navigace se provádí zadáním ".." jako argumentu GoToAsync metody:

await Shell.Current.GoToAsync("..");

Další informace o zpětnou navigaci naleznete v tématu Zpětná navigace.

Datová vazba

Datová vazba slouží ke zjednodušení způsobu, jakým Xamarin.Forms aplikace zobrazuje a komunikuje s daty. Vytváří připojení mezi uživatelským rozhraním a podkladovou aplikací. BindableObjectTřída obsahuje většinu infrastruktury pro podporu datové vazby.

Datová vazba spojuje dva objekty označované jako zdroj a cíl. Zdrojový objekt poskytuje data. Cílový objekt bude spotřebovávat (a často zobrazuje) data ze zdrojového objektu. Například Editor (Editor objekt) bude běžně navazovat jeho Xamarin_Forms _InputView_Text "data-LINKTYPE =" absolutní cesta ">Text vlastnost na veřejnou string vlastnost ve Text objektu. Vztah vazby znázorňuje následující diagram:

Hlavní výhodou datové vazby je, že už se nemusíte starat o synchronizaci dat mezi vašimi zobrazeními a zdrojem dat. Změny ve zdrojovém objektu jsou automaticky vloženy do cílového objektu na pozadí prostřednictvím rozhraní vazby a změny v cílovém objektu mohou být volitelně vloženy zpět do zdrojového objektu.

Vytvoření vazby dat je proces se dvěma kroky:

• Vlastnost Xamarin_Forms _BindableObject_BindingContext data-LINKTYPE = "absolutní cesta" >BindingContextBindingContext objektu musí být nastavena na .
• Vazba musí být navázána mezi cílem a zdrojem. V jazyce XAML se to dosáhne použitím Binding rozšíření značek.

V aplikaci Notes je cíl vazby Editor , který zobrazuje poznámku, zatímco Note instance nastavená jako Xamarin_Forms Editor _BindableObject_BindingContext "data-LINKTYPE =" absolutní cesta ">BindingContextNoteEntryPage je zdroj vazby. Zpočátku BindingContextNoteEntryPage je nastavena, když se konstruktor stránky spustí:

public NoteEntryPage()
{
    // ...
    BindingContext = new Note();
}

V tomto příkladu BindingContext je stránka při vytvoření nastavena na novou NoteNoteEntryPage . To zpracovává scénář přidání nové poznámky do aplikace.

Kromě toho je BindingContext možné stránku nastavit také v případě, že je k NoteEntryPage dispozici navigace, za předpokladu, že byla vybrána existující Poznámka v NotesPage :

[QueryProperty(nameof(ItemId), nameof(ItemId))]
public partial class NoteEntryPage : ContentPage
{
    public string ItemId
    {
        set
        {
            LoadNote(value);
        }

        async void LoadNote(string itemId)
        {
            try
            {
                int id = Convert.ToInt32(itemId);
                // Retrieve the note and set it as the BindingContext of the page.
                Note note = await App.Database.GetNoteAsync(id);
                BindingContext = note;
            }
            catch (Exception)
            {
                Console.WriteLine("Failed to load note.");
            }
        }    
        // ...    
    }
}

V tomto příkladu, když dojde k navigaci stránky, BindingContext je stránka nastavena na vybraný Note objekt poté, co byla načtena z databáze.

EditorV se NoteEntryPage pak váže k Text vlastnosti Note objektu:

<Editor Placeholder="Enter your note"
        Text="{Binding Text}" />

Je navázána vazba mezi Xamarin_Forms _InputView_Text "data-LINKTYPE =" absolutní cesta ">Editor.Text vlastnost a Text vlastnost Editor.Text objektu. Změny provedené v se Editor automaticky rozšíří do Note objektu. Podobně, pokud jsou provedeny změny Note.Text vlastnosti, Xamarin.Forms modul vazby také aktualizuje obsah Editor . Tato možnost se označuje jako Obousměrná vazba.

Další informace o datové vazbě najdete v tématu Xamarin.Forms Data Binding .

Použití stylů

Xamarin.Forms aplikace často obsahují více vizuálních prvků, které mají stejný vzhled. Nastavení vzhledu každého vizuálního prvku může být opakované a náchylné k chybám. Místo toho lze vytvořit styly, které definují vzhled a následně použity na požadované vizuální prvky.

Třída Style seskupuje kolekci hodnot vlastností do jednoho objektu, který lze poté použít na více instancí vizuálních prvků. Styly jsou uložené v ResourceDictionary , a to buď na úrovni aplikace, na úrovni stránky nebo na úrovni zobrazení. Volba toho, kde definovat Style dopady, kde se má použít:

• Style Instance definované na úrovni aplikace lze použít v celé aplikaci.
• Style Instance definované na úrovni stránky lze použít na stránku a její děti.
• Style Instance definované na úrovni zobrazení lze použít pro zobrazení a pro jeho děti.

Každá instance obsahuje kolekci jednoho nebo více objektů, z nichž každý má StyleSetter Xamarin_Forms SetterStyle _Setter_Property" data-linktype="absolute-path">Property a Xamarin_Forms Setter _Setter_Value" data-linktype="absolute-path">Value . je název vázání vlastnosti prvku, na který je styl použit, a je hodnota, Property která se použije na vlastnost Value . Následující příklad kódu ukazuje styl z NoteEntryPage :

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="Notes.Views.NoteEntryPage"
             Title="Note Entry">
    <ContentPage.Resources>
        <!-- Implicit styles -->
        <Style TargetType="{x:Type Editor}">
            <Setter Property="BackgroundColor"
                    Value="{StaticResource AppBackgroundColor}" />
        </Style>
        ...
    </ContentPage.Resources>
    ...
</ContentPage>

Tento styl se použije na Editor všechny instance na stránce.

Při vytváření Style objektu se Xamarin_Forms Style _Style_TargetType" data-linktype="absolute-path">vlastnost je vždy TargetType povinná.

Další informace o stylech XAML najdete v tématu Styling Xamarin.Forms Apps using XAML Styles .

Testování a nasazení

Visual Studio pro Mac i Visual Studio poskytují mnoho možností pro testování a nasazení aplikace. Ladění aplikací je běžnou součástí životního cyklu vývoje aplikací a pomáhá diagnostikovat problémy s kódem. Další informace najdete v části Set a Breakpoint, Step Through Codea Output Information to the Log Window.

Simulátory jsou dobrým místem, kde můžete začít nasazovat a testovat aplikaci, a nabízejí užitečné funkce pro testování aplikací. Uživatelé ale poslední aplikaci v simulátoru nevyužívají, takže by aplikace měly být na skutečných zařízeních testovány včas a často. Další informace o zřizování zařízení s iOSem najdete v tématu Device Provisioning. Další informace o zřizování zařízení s Androidem najdete v tématu Nastavení zařízení pro vývoj.

Další kroky

V tomto hloubku jsme prozkoumali základy vývoje aplikací pomocí Xamarin.Forms Shellu. Mezi navrhované další kroky patří čtení o následujících funkcích:

• Xamarin.Forms Shell snižuje složitost vývoje mobilních aplikací tím, že poskytuje základní funkce, které většina mobilních aplikací vyžaduje. Další informace naleznete v tématu Xamarin.Forms Shell.
• K vytvoření uživatelského rozhraní aplikace se používá několik řídicích Xamarin.Forms skupin. Další informace najdete v referenčních informacích k ovládacím prvkům.
• Datová vazba je technikou propojení vlastností dvou objektů, takže změny v jedné vlastnosti se automaticky odrazí v jiné vlastnosti. Další informace najdete v článku, který se týká datových vazeb.
• Xamarin.Forms nabízí více možností navigace po stránce v závislosti na použitém typu stránky. Další informace najdete v článku o navigaci.
• Styly pomáhají snížit počet opakovaných značek a umožňují snadnější změnu vzhledu aplikací. Další informace naleznete v tématu Styling Xamarin.Forms Apps.
• Šablony dat poskytují možnost definovat vyjádření dat u podporovaných zobrazení. Další informace najdete v článku o šablonách dat.
• Efekty také umožňují přizpůsobení nativních ovládacích prvků na různých platformách. Efekty se vytvářejí v projektech specifických pro platformu vytvořením podtřídy třídy a využívají se jejich připojením k PlatformEffect příslušnému ovládacímu Xamarin.Forms prvku. Další informace najdete v článku o efektech.
• Stránky, rozložení a zobrazení se na různých platformách vykreslují odlišně pomocí třídy Renderer, která vytvoří nativní ovládací prvek, uspořádá ho na obrazovce a přidá chování zadané ve sdíleném kódu. Vývojáři mohou implementovat vlastní třídy Renderer a přizpůsobit tak vzhled a chování ovládacího prvku. Další informace najdete v článku o vlastních renderech.
• Sdílený kód má přístup k nativní funkci prostřednictvím třídy DependencyService. Další informace najdete v článku, který se zabývá přístupem k nativním funkcím pomocí služby DependencyService.

Související odkazy

• Xamarin.Forms Shell
• XAML (eXtensible Application Markup Language)
• Datová vazba
• Referenční informace k ovládacím prvkům
• Xamarin.Forms %2bget%2bstarted" data-linktype="absolute-path">Začínáme ukázky
• Xamarin.Forms " data-linktype="absolute-path">Xamarin.Forms ukázky
• Xamarin.Forms API reference

Související video

Další videa o Xamarinu najdete na Channel 9 a YouTube.