Teil 1: Erste Schritte mit XAML

Artikel
07/13/2023

In einer Xamarin.Forms Anwendung wird XAML hauptsächlich zum Definieren des visuellen Inhalts einer Seite verwendet und arbeitet mit einer C#-Codebehind-Datei zusammen.

Die CodeBehind-Datei bietet Codeunterstützung für das Markup. Zusammen tragen diese beiden Dateien zu einer neuen Klassendefinition bei, die untergeordnete Ansichten und Die Initialisierung von Eigenschaften enthält. In der XAML-Datei werden Klassen und Eigenschaften mit XML-Elementen und -Attributen referenziert, und es werden Verbindungen zwischen dem Markup und dem Code hergestellt.

Erstellen der Projektmappe

Um mit der Bearbeitung Ihrer ersten XAML-Datei zu beginnen, verwenden Sie Visual Studio oder Visual Studio für Mac, um eine neue Xamarin.Forms Projektmappe zu erstellen. (Wählen Sie die Registerkarte unten aus, die Ihrer Umgebung entspricht.)

Visual Studio
Visual Studio für Mac

Starten Sie unter Windows Visual Studio 2019, und klicken Sie im Startfenster auf Neues Projekt erstellen , um ein neues Projekt zu erstellen:

Fenster

Klicken Sie im Fenster Neues Projekt erstellen in der Dropdownliste Projekttyp auf Mobil, wählen Sie die Vorlage Mobile App (Xamarin.Forms) aus, und klicken Sie auf Weiter:

Neues Projektfenster

Legen Sie im Fenster Neues Projekt konfigurieren den Projektnamen auf XamlSamples (oder was auch immer Sie bevorzugen) fest, und klicken Sie auf die Schaltfläche Erstellen .

Klicken Sie im Dialogfeld Neue plattformübergreifende App auf Leer, und klicken Sie auf die Schaltfläche OK :

Dialogfeld

Vier Projekte werden in der Projektmappe erstellt: die XamlSamples .NET Standard-Bibliothek, XamlSamples.Android, XamlSamples.iOS und die Universelle Windows-Plattform Projektmappe XamlSamples.UWP.

Nachdem Sie die XamlSamples-Lösung erstellt haben, sollten Sie Ihre Entwicklungsumgebung testen, indem Sie die verschiedenen Plattformprojekte als Projekt zum Starten der Projektmappe auswählen und die einfache Anwendung erstellen und bereitstellen, die von der Projektvorlage erstellt wurde, entweder auf Telefonemulatoren oder realen Geräten.

Es sei denn, Sie müssen plattformspezifischen Code schreiben, das freigegebene XamlSamples .NET Standard-Bibliotheksprojekt ist der Ort, an dem Sie praktisch ihre gesamte Programmierzeit aufwenden. Diese Artikel werden nicht außerhalb dieses Projekts gehen.

Anatomie einer XAML-Datei

In der XamlSamples .NET Standard-Bibliothek befinden sich zwei Dateien mit den folgenden Namen:

App.xaml, die XAML-Datei; Und
App.xaml.cs, eine C# -Codebehind-Datei, die der XAML-Datei zugeordnet ist.

Sie müssen auf den Pfeil neben App.xaml klicken, um die CodeBehind-Datei anzuzeigen.

Sowohl App.xaml als auch App.xaml.cs tragen zu einer Klasse mit dem Namen bei App , die von abgeleitet wird Application. Die meisten anderen Klassen mit XAML-Dateien tragen zu einer Klasse bei, die von abgeleitet wird ContentPage. Diese Dateien verwenden XAML, um den visuellen Inhalt einer gesamten Seite zu definieren. Dies gilt für die beiden anderen Dateien im XamlSamples-Projekt :

MainPage.xaml, die XAML-Datei; Und
MainPage.xaml.cs, die C#-Codebehind-Datei.

Die Datei MainPage.xaml sieht wie folgt aus (obwohl die Formatierung möglicherweise etwas anders sein kann):

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:local="clr-namespace:XamlSamples"
             x:Class="XamlSamples.MainPage">

    <StackLayout>
        <!-- Place new controls here -->
        <Label Text="Welcome to Xamarin Forms!"
               VerticalOptions="Center"
               HorizontalOptions="Center" />
    </StackLayout>

</ContentPage>

Die beiden XML-Namespacedeklarationen (xmlns) beziehen sich auf URIs, die erste scheinbar auf der Xamarin-Website und die zweite auf der Microsoft-Website. Überprüfen Sie nicht, worauf diese URIs verweisen. Es ist nichts da. Sie sind einfach URIs im Besitz von Xamarin und Microsoft und funktionieren im Grunde als Versionsbezeichner.

Die erste XML-Namespacedeklaration bedeutet, dass Tags, die in der XAML-Datei ohne Präfix definiert sind, auf Klassen in Xamarin.Formsverweisen, z. B ContentPage. . Die zweite Namespacedeklaration definiert ein Präfix von x. Dies wird für mehrere Elemente und Attribute verwendet, die für XAML selbst intrinsisch sind und von anderen XAML-Implementierungen unterstützt werden. Diese Elemente und Attribute unterscheiden sich jedoch geringfügig von dem jahr, das im URI eingebettet ist. Xamarin.Forms unterstützt die XAML-Spezifikation 2009, aber nicht alle.

Mit der local Namespacedeklaration können Sie über das .NET Standard-Bibliotheksprojekt auf andere Klassen zugreifen.

Am Ende dieses ersten Tags wird das x Präfix für ein Attribut namens Classverwendet. Da die Verwendung dieses x Präfixes für den XAML-Namespace praktisch universell ist, werden XAML-Attribute wie Class fast immer als x:Classbezeichnet.

Das x:Class Attribut gibt einen vollqualifizierten .NET-Klassennamen an: die MainPage -Klasse im XamlSamples Namespace. Dies bedeutet, dass diese XAML-Datei eine neue Klasse mit dem Namen MainPage im Namespace definiert, der XamlSamples von ContentPageabgeleitet wird – dem Tag, in dem das x:Class Attribut angezeigt wird.

Das x:Class Attribut kann nur im Stammelement einer XAML-Datei angezeigt werden, um eine abgeleitete C#-Klasse zu definieren. Dies ist die einzige neue Klasse, die in der XAML-Datei definiert ist. Alles andere, was in der XAML-Datei angezeigt wird, wird stattdessen einfach aus vorhandenen Klassen instanziiert und initialisiert.

Die Datei MainPage.xaml.cs sieht wie folgt aus (abgesehen von nicht verwendeten using Anweisungen):

using Xamarin.Forms;

namespace XamlSamples
{
    public partial class MainPage : ContentPage
    {
        public MainPage()
        {
            InitializeComponent();
        }
    }
}

Die MainPage -Klasse leitet sich von ab ContentPage, beachten Sie jedoch die partial Klassendefinition. Dies deutet darauf hin, dass es eine andere partielle Klassendefinition für MainPagegeben sollte, aber wo ist sie? Und was ist diese InitializeComponent Methode?

Wenn Visual Studio das Projekt erstellt, analysiert es die XAML-Datei, um eine C#-Codedatei zu generieren. Wenn Sie im Verzeichnis XamlSamples\XamlSamples\obj\Debug suchen, finden Sie eine Datei mit dem Namen XamlSamples.MainPage.xaml.g.cs. Das "g" steht für generiert. Dies ist die andere partielle Klassendefinition von MainPage , die die Definition der Methode enthält, die InitializeComponentMainPage vom Konstruktor aufgerufen wird. Diese beiden partiellen MainPage Klassendefinitionen können dann zusammen kompiliert werden. Je nachdem, ob der XAML-Code kompiliert ist oder nicht, wird entweder die XAML-Datei oder eine binäre Form der XAML-Datei in die ausführbare Datei eingebettet.

Zur Laufzeit ruft Code im jeweiligen Plattformprojekt eine LoadApplication -Methode auf, und übergibt ihr eine neue instance der App -Klasse in der .NET Standard-Bibliothek. Der App Klassenkonstruktor instanziiert MainPage. Der Konstruktor dieser Klasse ruft InitializeComponentauf, wodurch dann die LoadFromXaml Methode aufgerufen wird, die die XAML-Datei (oder die kompilierte Binärdatei) aus der .NET Standard-Bibliothek extrahiert. LoadFromXaml Initialisiert alle in der XAML-Datei definierten Objekte, verbindet sie alle in beziehungen zwischen übergeordnetem und untergeordnetem Element, fügt im Code definierte Ereignishandler an Ereignisse an, die in der XAML-Datei festgelegt sind, und legt die resultierende Struktur der Objekte als Inhalt der Seite fest.

Obwohl Sie normalerweise nicht viel Zeit mit generierten Codedateien verbringen müssen, werden manchmal Laufzeitausnahmen für Code in den generierten Dateien ausgelöst, sodass Sie mit ihnen vertraut sein sollten.

Wenn Sie dieses Programm kompilieren und ausführen, wird das Label -Element in der Mitte der Seite angezeigt, wie es der XAML-Code vorschlägt:

Für interessantere Visuals benötigen Sie lediglich interessantere XAML-Elemente.

Um ihrem Projekt weitere XAML-basierte ContentPage Klassen hinzuzufügen, wählen Sie das Bibliotheksprojekt XamlSamples .NET Standard aus, klicken Sie mit der rechten Maustaste, und wählen Sie Neues Element hinzufügen>... aus. Wählen Sie im Dialogfeld Neues Element hinzufügendie Option Inhaltsseite für Visual C#-Elemente >Xamarin.Forms> (nicht Inhaltsseite (C#) aus, wodurch eine reine Codeseite oder Inhaltsansicht erstellt wird, bei der es sich nicht um eine Seite handelt. Geben Sie der Seite einen Namen, z. B . HelloXamlPage:

Dialogfeld

Um ihrem Projekt weitere XAML-basierte ContentPage Klassen hinzuzufügen, wählen Sie das Bibliotheksprojekt XamlSamples .NET Standard aus, und rufen Sie das Menüelement Neue Datei auf>. Wählen Sie links neben dem Dialogfeld Neue Datei die Option Forms und Forms ContentPage XAML (nicht Forms ContentPage, wodurch eine reine Codeseite erstellt wird, oder Inhaltsansicht, bei der es sich nicht um eine Seite handelt) aus. Geben Sie der Seite einen Namen, z. B . HelloXamlPage:

Dialogfeld

Dem Projekt werden zwei Dateien hinzugefügt: HelloXamlPage.xaml und die CodeBehind-Datei HelloXamlPage.xaml.cs.

Festlegen des Seiteninhalts

Bearbeiten Sie die Datei HelloXamlPage.xaml so, dass die einzigen Tags für ContentPage und ContentPage.Contentsind:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="XamlSamples.HelloXamlPage">
    <ContentPage.Content>

    </ContentPage.Content>
</ContentPage>

Die ContentPage.Content Tags sind Teil der eindeutigen Syntax von XAML. Zunächst scheinen sie ungültige XML-Dateien zu sein, aber sie sind legal. Der Punkt ist kein Sonderzeichen in XML.

Die ContentPage.Content Tags werden als Eigenschaftselementtags bezeichnet. Content ist eine Eigenschaft von ContentPageund wird im Allgemeinen auf eine einzelne Ansicht oder ein Layout mit untergeordneten Ansichten festgelegt. Normalerweise werden Eigenschaften in XAML zu Attributen, aber es wäre schwierig, ein Content Attribut auf ein komplexes Objekt festzulegen. Aus diesem Grund wird die Eigenschaft als XML-Element ausgedrückt, das aus dem Klassennamen und dem Durch einen Punkt getrennten Eigenschaftsnamen besteht. Jetzt kann die Content -Eigenschaft wie folgt zwischen den ContentPage.Content Tags festgelegt werden:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="XamlSamples.HelloXamlPage"
             Title="Hello XAML Page">
    <ContentPage.Content>

        <Label Text="Hello, XAML!"
               VerticalOptions="Center"
               HorizontalTextAlignment="Center"
               Rotation="-15"
               IsVisible="true"
               FontSize="Large"
               FontAttributes="Bold"
               TextColor="Blue" />

    </ContentPage.Content>
</ContentPage>

Beachten Sie auch, dass ein Title Attribut für das Stammtag festgelegt wurde.

Zu diesem Zeitpunkt sollte die Beziehung zwischen Klassen, Eigenschaften und XML offensichtlich sein: Eine Xamarin.Forms Klasse (z ContentPage . B. oder Label) wird in der XAML-Datei als XML-Element angezeigt. Eigenschaften dieser Klasse – einschließlich Title der eigenschaften on ContentPage und sieben eigenschaften von Label– werden normalerweise als XML-Attribute angezeigt.

Es gibt viele Tastenkombinationen, um die Werte dieser Eigenschaften festzulegen. Einige Eigenschaften sind grundlegende Datentypen: Beispielsweise sind die Title Eigenschaften und Text vom Typ String, Rotation und IsVisibleDouble(dies ist true standardmäßig und wird hier nur zur Veranschaulichung festgelegt) vom Typ Boolean.

Die HorizontalTextAlignment -Eigenschaft ist vom Typ TextAlignment, was eine Enumeration ist. Für eine Eigenschaft eines beliebigen Enumerationstyps müssen Sie lediglich einen Membernamen angeben.

Für Eigenschaften komplexerer Typen werden jedoch Konverter zum Analysieren des XAML-Codes verwendet. Dies sind Klassen in Xamarin.Forms , die von TypeConverterabgeleitet werden. Viele sind öffentliche Klassen, aber einige nicht. Für diese bestimmte XAML-Datei spielen mehrere dieser Klassen im Hintergrund eine Rolle:

LayoutOptionsConverter für die VerticalOptions -Eigenschaft
FontSizeConverter für die FontSize -Eigenschaft
ColorTypeConverter für die TextColor -Eigenschaft

Diese Konverter steuern die zulässige Syntax der Eigenschafteneinstellungen.

Der ThicknessTypeConverter kann eine, zwei oder vier Zahlen durch Kommas getrennt verarbeiten. Wenn eine Zahl angegeben wird, gilt sie für alle vier Seiten. Bei zwei Zahlen ist die erste Auffüllung links und rechts, und die zweite ist oben und unten. Vier Zahlen befinden sich in der Reihenfolge links, oben, rechts und unten.

Kann LayoutOptionsConverter die Namen öffentlicher statischer Felder der LayoutOptions -Struktur in Werte vom Typ LayoutOptionskonvertieren.

Der FontSizeConverter kann einen NamedSize Member oder einen numerischen Schriftgrad verarbeiten.

Akzeptiert ColorTypeConverter die Namen öffentlicher statischer Felder der Color Struktur oder hexadezimaler RGB-Werte mit oder ohne Alphakanal, vor dem ein Zahlenzeichen (#) steht. Dies ist die Syntax ohne Alphakanal:

TextColor="#rrggbb"

Jeder der kleinen Buchstaben ist eine Hexadezimalziffer. Hier sehen Sie, wie ein Alphakanal enthalten ist:

TextColor="#aarrggbb">

Beachten Sie für den Alphakanal, dass FF vollständig undurchsichtig und 00 vollständig transparent ist.

Mit zwei anderen Formaten können Sie nur eine einzelne Hexadezimalziffer für jeden Kanal angeben:

TextColor="#rgb" TextColor="#argb"

In diesen Fällen wird die Ziffer wiederholt, um den Wert zu bilden. Beispielsweise ist #CF3 die RGB-Farbe CC-FF-33.

Wenn Sie das XamlSamples-Programm ausführen, wird angezeigt MainPage . Um das neue HelloXamlPage anzuzeigen, können Sie diese entweder als neue Startseite in der Datei App.xaml.cs festlegen oder von zu MainPageder neuen Seite navigieren.

Um die Navigation zu implementieren, ändern Sie zuerst den Code im App.xaml.cs-Konstruktor , sodass ein NavigationPage Objekt erstellt wird:

public App()
{
    InitializeComponent();
    MainPage = new NavigationPage(new MainPage());
}

Im MainPage.xaml.cs-Konstruktor können Sie eine einfache Button erstellen und den Ereignishandler verwenden, um zu navigieren HelloXamlPage:

public MainPage()
{
    InitializeComponent();

    Button button = new Button
    {
        Text = "Navigate!",
        HorizontalOptions = LayoutOptions.Center,
        VerticalOptions = LayoutOptions.Center
    };

    button.Clicked += async (sender, args) =>
    {
        await Navigation.PushAsync(new HelloXamlPage());
    };

    Content = button;
}

Durch festlegen der Content -Eigenschaft der Seite wird die Einstellung der Content -Eigenschaft in der XAML-Datei ersetzt. Wenn Sie die neue Version dieses Programms kompilieren und bereitstellen, wird eine Schaltfläche auf dem Bildschirm angezeigt. Wenn Sie ihn drücken, wird zu HelloXamlPagenavigiert. Dies ist die resultierende Seite auf iPhone, Android und UWP:

Sie können unter iOS über die < Schaltfläche "Zurück" zurück MainPage zu navigieren, den Linkspfeil oben auf der Seite oder unten auf dem Smartphone unter Android oder den Linken-Pfeil oben auf der Seite auf Windows 10 verwenden.

Sie können mit xaml experimentieren, um verschiedene Möglichkeiten zum Rendern von Labelzu erhalten. Wenn Sie Unicode-Zeichen in den Text einbetten müssen, können Sie die XML-Standardsyntax verwenden. Verwenden Sie beispielsweise Folgendes, um die Begrüßung in intelligente Anführungszeichen zu setzen:

<Label Text="“Hello, XAML!”" … />

So sieht es aus:

XAML- und Codeinteraktionen

Das HelloXamlPage-Beispiel enthält nur einen einzelnen Label auf der Seite, aber dies ist sehr ungewöhnlich. Die meisten ContentPage Ableitungen legen die Content -Eigenschaft auf ein Layout irgendeiner Art fest, z. B. .StackLayout Die Children -Eigenschaft von StackLayout ist vom Typ IList<View> definiert, aber es handelt sich tatsächlich um ein Objekt vom Typ ElementCollection<View>, und diese Auflistung kann mit mehreren Ansichten oder anderen Layouts aufgefüllt werden. In XAML werden diese über- und untergeordneten Beziehungen mit der normalen XML-Hierarchie hergestellt. Dies ist eine XAML-Datei für eine neue Seite mit dem Namen XamlPlusCodePage:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="XamlSamples.XamlPlusCodePage"
             Title="XAML + Code Page">
    <StackLayout>
        <Slider VerticalOptions="CenterAndExpand" />

        <Label Text="A simple Label"
               Font="Large"
               HorizontalOptions="Center"
               VerticalOptions="CenterAndExpand" />

        <Button Text="Click Me!"
                HorizontalOptions="Center"
                VerticalOptions="CenterAndExpand" />
    </StackLayout>
</ContentPage>

Diese XAML-Datei ist syntaktisch vollständig und sieht wie folgt aus:

Sie werden dieses Programm jedoch wahrscheinlich als funktionsarm ansehen. Vielleicht soll die Slider bewirken, dass der Label den aktuellen Wert anzeigt, und der Button ist wahrscheinlich dafür gedacht, etwas innerhalb des Programms zu tun.

Wie Sie in Teil 4 sehen werden. Datenbindungsgrundlagen: Die Aufgabe, einen Wert mithilfe eines SliderLabel anzuzeigen, kann vollständig in XAML mit einer Datenbindung behandelt werden. Es ist jedoch nützlich, zuerst die Codelösung zu sehen. Trotzdem erfordert die Verarbeitung des Button Klicks definitiv Code. Dies bedeutet, dass die CodeBehind-Datei für XamlPlusCodePage Handler für das ValueChanged -Ereignis von Slider und das Clicked -Ereignis von Buttonenthalten muss. Fügen Sie sie hinzu:

namespace XamlSamples
{
    public partial class XamlPlusCodePage
    {
        public XamlPlusCodePage()
        {
            InitializeComponent();
        }

        void OnSliderValueChanged(object sender, ValueChangedEventArgs args)
        {

        }

        void OnButtonClicked(object sender, EventArgs args)
        {

        }
    }
}

Diese Ereignishandler müssen nicht öffentlich sein.

Zurück in der XAML-Datei müssen die Slider Tags und Button Attribute für die Ereignisse und Clicked enthalten, die ValueChanged auf diese Handler verweisen:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="XamlSamples.XamlPlusCodePage"
             Title="XAML + Code Page">
    <StackLayout>
        <Slider VerticalOptions="CenterAndExpand"
                ValueChanged="OnSliderValueChanged" />

        <Label Text="A simple Label"
               Font="Large"
               HorizontalOptions="Center"
               VerticalOptions="CenterAndExpand" />

        <Button Text="Click Me!"
                HorizontalOptions="Center"
                VerticalOptions="CenterAndExpand"
                Clicked="OnButtonClicked" />
    </StackLayout>
</ContentPage>

Beachten Sie, dass das Zuweisen eines Handlers zu einem Ereignis dieselbe Syntax aufweist wie das Zuweisen eines Werts zu einer Eigenschaft.

Wenn der Handler für das ValueChanged -Ereignis von Slider verwendet wird, Label um den aktuellen Wert anzuzeigen, muss der Handler aus Code auf dieses Objekt verweisen. Benötigt Label einen Namen, der mit dem x:Name -Attribut angegeben wird.

<Label x:Name="valueLabel"
       Text="A simple Label"
       Font="Large"
       HorizontalOptions="Center"
       VerticalOptions="CenterAndExpand" />

Das x Präfix des x:Name Attributs gibt an, dass dieses Attribut in XAML integriert ist.

Der Name, den Sie dem x:Name Attribut zuweisen, weist dieselben Regeln wie C#-Variablennamen auf. Sie muss beispielsweise mit einem Buchstaben oder Unterstrich beginnen und keine eingebetteten Leerzeichen enthalten.

ValueChanged Der Ereignishandler kann jetzt festlegen, dass der Label neue Slider Wert angezeigt wird. Der neue Wert ist über die Ereignisargumente verfügbar:

void OnSliderValueChanged(object sender, ValueChangedEventArgs args)
{
    valueLabel.Text = args.NewValue.ToString("F3");
}

Oder der Handler könnte das Slider Objekt, das dieses Ereignis generiert, aus dem sender -Argument und die Value -Eigenschaft abrufen:

void OnSliderValueChanged(object sender, ValueChangedEventArgs args)
{
    valueLabel.Text = ((Slider)sender).Value.ToString("F3");
}

Wenn Sie das Programm zum ersten Mal ausführen, wird der Slider Wert nicht angezeigt, Label da das ValueChanged Ereignis noch nicht ausgelöst wurde. Jede Manipulation des Slider bewirkt jedoch, dass der Wert angezeigt wird:

Jetzt für .Button Lassen Sie uns eine Antwort auf ein Clicked Ereignis simulieren, indem sie eine Warnung mit der Text der Schaltfläche anzeigen. Der Ereignishandler kann das sender Argument sicher in ein Button umwandeln und dann auf dessen Eigenschaften zugreifen:

async void OnButtonClicked(object sender, EventArgs args)
{
    Button button = (Button)sender;
    await DisplayAlert("Clicked!",
        "The button labeled '" + button.Text + "' has been clicked",
        "OK");
}

Die -Methode wird als async definiert, da die DisplayAlert Methode asynchron ist und dem Operator vorangestellt werden sollte, der await nach Abschluss der Methode zurückgibt. Da diese Methode das Auslösen des Button Ereignisses aus dem sender Argument abruft, kann derselbe Handler für mehrere Schaltflächen verwendet werden.

Sie haben gesehen, dass ein in XAML definiertes Objekt ein Ereignis auslösen kann, das in der CodeBehind-Datei behandelt wird, und dass die CodeBehind-Datei auf ein objekt zugreifen kann, das in XAML mit dem -Attribut zugewiesen wurde x:Name . Dies sind die beiden grundlegenden Möglichkeiten, wie Code und XAML interagieren.

Einige zusätzliche Einblicke in die Funktionsweise von XAML können sie gewinnen, indem Sie die neu generierte Datei XamlPlusCode.xaml.g.cs untersuchen, die jetzt alle Namen enthält, die einem Attribut x:Name als privates Feld zugewiesen sind. Dies ist eine vereinfachte Version dieser Datei:

public partial class XamlPlusCodePage : ContentPage {

    private Label valueLabel;

    private void InitializeComponent() {
        this.LoadFromXaml(typeof(XamlPlusCodePage));
        valueLabel = this.FindByName<Label>("valueLabel");
    }
}

Die Deklaration dieses Felds ermöglicht die freie Verwendung der Variablen innerhalb der XamlPlusCodePage partiellen Klassendatei unter Ihrer Gerichtsbarkeit. Zur Laufzeit wird das Feld zugewiesen, nachdem der XAML-Code analysiert wurde. Dies bedeutet, dass das valueLabel Feld ist null , wenn der XamlPlusCodePage Konstruktor beginnt, aber gültig ist, nachdem InitializeComponent aufgerufen wird.

Nachdem InitializeComponent das Steuerelement zurück an den Konstruktor zurückgegeben wurde, wurden die Visuals der Seite so erstellt, als ob sie im Code instanziiert und initialisiert worden wären. Die XAML-Datei spielt in der -Klasse keine Rolle mehr. Sie können diese Objekte auf der Seite in beliebiger Weise bearbeiten, z. B. indem Sie Ansichten zu StackLayouthinzufügen oder die Content -Eigenschaft der Seite auf etwas ganz anderes festlegen. Sie können die Struktur "durchlaufen", indem Sie die Content -Eigenschaft der Seite und die Elemente in den Children Auflistungen von Layouts untersuchen. Sie können Eigenschaften für Ansichten festlegen, auf die auf diese Weise zugegriffen wird, oder ihnen dynamisch Ereignishandler zuweisen.

Fühlen Sie sich frei. Es handelt sich um Ihre Seite, und XAML ist nur ein Tool zum Erstellen des Inhalts.

Zusammenfassung

In dieser Einführung haben Sie erfahren, wie eine XAML-Datei und eine Codedatei zu einer Klassendefinition beitragen und wie XAML- und Codedateien interagieren. XAML verfügt aber auch über eigene einzigartige syntaktische Features, die eine sehr flexible Verwendung ermöglichen. Sie können diese in Teil 2 untersuchen. Grundlegende XAML-Syntax.

Teil 1: Erste Schritte mit XAML

Erstellen der Projektmappe

Anatomie einer XAML-Datei

Hinzufügen neuer XAML-Seiten

Festlegen des Seiteninhalts

Seitennavigation

XAML- und Codeinteraktionen

Zusammenfassung

Zusätzliche Ressourcen

Teil 1: Erste Schritte mit XAML

Erstellen der Projektmappe

Anatomie einer XAML-Datei

Hinzufügen neuer XAML-Seiten

Festlegen des Seiteninhalts

Seitennavigation

XAML- und Codeinteraktionen

Zusammenfassung

Ähnliche Themen

Zusätzliche Ressourcen