Xamarin.Forms Geräteklasse

Artikel
07/20/2020

Die Device Klasse enthält eine Reihe von Eigenschaften und Methoden, mit denen Entwickler Layout und Funktionalität auf Plattformbasis anpassen können.

Zusätzlich zu Methoden und Eigenschaften für den Zielcode für bestimmte Hardwaretypen und -größen enthält die Device Klasse Methoden, die für die Interaktion mit UI-Steuerelementen aus Hintergrundthreads verwendet werden können. Weitere Informationen finden Sie unter "Interagieren mit der Benutzeroberfläche aus Hintergrundthreads".

Bereitstellen plattformspezifischer Werte

Xamarin.Forms Vor 2.3.4 konnte die Plattform, auf der die Anwendung ausgeführt wurde, durch Prüfung der Device.OS Eigenschaft und Vergleich mit den TargetPlatform.iOSWerten , TargetPlatform.Android, TargetPlatform.WinPhoneund TargetPlatform.Windows Enumerationswerten abgerufen werden. Ebenso könnte eine der Device.OnPlatform Überladungen verwendet werden, um plattformspezifische Werte für ein Steuerelement bereitzustellen.

Seit Xamarin.Forms 2.3.4 werden diese APIs jedoch veraltet und ersetzt. Die Device Klasse enthält nun öffentliche Zeichenfolgenkonstanten, die Plattformen identifizieren – Device.iOS, , Device.AndroidDevice.WinPhone(veraltet), Device.WinRT (veraltet), Device.UWPund Device.macOS. Ebenso wurden die Device.OnPlatform Überladungen durch die und On die OnPlatform APIs ersetzt.

In C# können plattformspezifische Werte bereitgestellt werden, indem sie eine switch Anweisung für die Device.RuntimePlatform Eigenschaft erstellen und dann Anweisungen für die erforderlichen Plattformen bereitstellen case :

double top;
switch (Device.RuntimePlatform)
{
  case Device.iOS:
    top = 20;
    break;
  case Device.Android:
  case Device.UWP:
  default:
    top = 0;
    break;
}
layout.Margin = new Thickness(5, top, 5, 0);

Die OnPlatform klassen On bieten die gleiche Funktionalität in XAML:

<StackLayout>
  <StackLayout.Margin>
    <OnPlatform x:TypeArguments="Thickness">
      <On Platform="iOS" Value="0,20,0,0" />
      <On Platform="Android, UWP" Value="0,0,0,0" />
    </OnPlatform>
  </StackLayout.Margin>
  ...
</StackLayout>

Die OnPlatform Klasse ist eine generische Klasse, die mit einem x:TypeArguments Attribut instanziiert werden muss, das dem Zieltyp entspricht. In der Klasse On kann das Attribut Platform einen einzelnen string-Wert oder mehrere durch Komma getrennte string-Werte annehmen.

Wichtig

Das Bereitstellen eines falschen Platform Attributwerts in der On Klasse führt nicht zu einem Fehler. Stattdessen wird der Code ausgeführt, ohne dass der plattformspezifische Wert angewendet wird.

Alternativ kann die OnPlatform Markuperweiterung in XAML verwendet werden, um die Darstellung der Benutzeroberfläche pro Plattform anzupassen. Weitere Informationen finden Sie unter OnPlatform-Markuperweiterung.

Device.Idiom

Die Device.Idiom Eigenschaft kann verwendet werden, um Layouts oder Funktionen abhängig vom Gerät zu ändern, auf dem die Anwendung ausgeführt wird. Die TargetIdiom-Enumeration verfügt über folgende Werte:

Telefon – i Telefon, iPod touch und Android-Geräte schmaler als 600 Dips^
Tablet – iPad, Windows-Geräte und Android-Geräte breiter als 600 Dips^
Desktop – wird nur in UWP-Apps auf Windows 10-Desktopcomputern zurückgegeben (gibt Phone auf mobilen Windows-Geräten zurück, einschließlich in Continuum-Szenarien)
TV – Tizen TV-Geräte
Watch – Tizen-Uhrengeräte
Nicht unterstützt – nicht verwendet

^ Dips ist nicht notwendigerweise die physische Pixelanzahl

Die Idiom Eigenschaft ist besonders hilfreich beim Erstellen von Layouts, die größere Bildschirme nutzen, z. B.:

if (Device.Idiom == TargetIdiom.Phone) {
    // layout views vertically
} else {
    // layout views horizontally for a larger display (tablet or desktop)
}

Die OnIdiom Klasse bietet die gleiche Funktionalität in XAML:

<StackLayout>
    <StackLayout.Margin>
        <OnIdiom x:TypeArguments="Thickness">
            <OnIdiom.Phone>0,20,0,0</OnIdiom.Phone>
            <OnIdiom.Tablet>0,40,0,0</OnIdiom.Tablet>
            <OnIdiom.Desktop>0,60,0,0</OnIdiom.Desktop>
        </OnIdiom>
    </StackLayout.Margin>
    ...
</StackLayout>

Die OnIdiom Klasse ist eine generische Klasse, die mit einem x:TypeArguments Attribut instanziiert werden muss, das dem Zieltyp entspricht.

Alternativ kann die OnIdiom Markuperweiterung in XAML verwendet werden, um die Ui-Darstellung basierend auf dem Idiom des Geräts anzupassen, auf dem die Anwendung ausgeführt wird. Weitere Informationen finden Sie unter OnIdiom-Markuperweiterung.

Device.FlowDirection

Der Device.FlowDirection Wert ruft einen FlowDirection Enumerationswert ab, der die aktuelle Flussrichtung darstellt, die vom Gerät verwendet wird. Die Leserichtung ist die Richtung, in der Benutzeroberflächenelemente auf der Seite vom Auge wahrgenommen werden. Diese Enumerationswerte lauten:

In XAML kann der Wert mithilfe der Device.FlowDirectionx:Static Markuperweiterung abgerufen werden:

<ContentPage ... FlowDirection="{x:Static Device.FlowDirection}"> />

Der entsprechende Code in C# lautet:

this.FlowDirection = Device.FlowDirection;

Weitere Informationen zur Flussrichtung finden Sie unter Lokalisierung von rechts nach links.

Device.Styles

Die Styles Eigenschaft enthält integrierte Formatdefinitionen, die auf einige Steuerelemente (z Label. B. ) Style angewendet werden können. Die verfügbaren Formatvorlagen sind:

BodyStyle
CaptionStyle
ListItemDetailTextStyle
ListItemTextStyle
SubtitleStyle
Titlestyle

Device.GetNamedSize

GetNamedSize kann beim Festlegen FontSize im C#-Code verwendet werden:

myLabel.FontSize = Device.GetNamedSize (NamedSize.Small, myLabel);
someLabel.FontSize = Device.OnPlatform (
      24,         // hardcoded size
      Device.GetNamedSize (NamedSize.Medium, someLabel),
      Device.GetNamedSize (NamedSize.Large, someLabel)
);

Device.GetNamedColor

Xamarin.Forms 4.6 bietet Unterstützung für benannte Farben. Eine benannte Farbe ist eine Farbe, die einen anderen Wert aufweist, je nachdem, welcher Systemmodus (z. B. Hell oder Dunkel) auf dem Gerät aktiv ist. Auf Android wird über die R.Color-Klasse auf benannte Farben zugegriffen. Unter iOS werden benannte Farben als Systemfarben bezeichnet. Im Universelle Windows-Plattform werden benannte Farben als XAML-Designressourcen bezeichnet.

Die GetNamedColor Methode kann verwendet werden, um benannte Farben unter Android, iOS und UWP abzurufen. Die Methode verwendet ein string Argument und gibt folgendes Colorzurück:

// Retrieve an Android named color
Color color = Device.GetNamedColor(NamedPlatformColor.HoloBlueBright);

Color.Default wird zurückgegeben, wenn ein Farbname nicht gefunden werden kann oder wenn GetNamedColor er auf einer nicht unterstützten Plattform aufgerufen wird.

Hinweis

Da die GetNamedColor Methode eine Color für eine Plattform spezifische Methode zurückgibt, sollte sie in der Regel in Verbindung mit der Device.RuntimePlatform Eigenschaft verwendet werden.

Die NamedPlatformColor Klasse enthält die Konstanten, die die benannten Farben für Android, iOS und UWP definieren:

Android	iOS	macOS	UWP
`BackgroundDark`	`Label`	`AlternateSelectedControlTextColor`	`SystemAltHighColor`
`BackgroundLight`	`Link`	`ControlAccent`	`SystemAltLowColor`
`Black`	`OpaqueSeparator`	`ControlBackgroundColor`	`SystemAltMediumColor`
`DarkerGray`	`PlaceholderText`	`ControlColor`	`SystemAltMediumHighColor`
`HoloBlueBright`	`QuaternaryLabel`	`DisabledControlTextColor`	`SystemAltMediumLowColor`
`HoloBlueDark`	`SecondaryLabel`	`FindHighlightColor`	`SystemBaseHighColor`
`HoloBlueLight`	`Separator`	`GridColor`	`SystemBaseLowColor`
`HoloGreenDark`	`SystemBlue`	`HeaderTextColor`	`SystemBaseMediumColor`
`HoloGreenLight`	`SystemGray`	`HighlightColor`	`SystemBaseMediumHighColor`
`HoloOrangeDark`	`SystemGray2`	`KeyboardFocusIndicatorColor`	`SystemBaseMediumLowColor`
`HoloOrangeLight`	`SystemGray3`	`Label`	`SystemChromeAltLowColor`
`HoloPurple`	`SystemGray4`	`LabelColor`	`SystemChromeBlackHighColor`
`HoloRedDark`	`SystemGray5`	`Link`	`SystemChromeBlackLowColor`
`HoloRedLight`	`SystemGray6`	`LinkColor`	`SystemChromeBlackMediumColor`
`TabIndicatorText`	`SystemGreen`	`PlaceholderText`	`SystemChromeBlackMediumLowColor`
`Transparent`	`SystemIndigo`	`PlaceholderTextColor`	`SystemChromeDisabledHighColor`
`White`	`SystemOrange`	`QuaternaryLabel`	`SystemChromeDisabledLowColor`
`WidgetEditTextDark`	`SystemPink`	`QuaternaryLabelColor`	`SystemChromeHighColor`
	`SystemPurple`	`SecondaryLabel`	`SystemChromeLowColor`
	`SystemRed`	`SecondaryLabelColor`	`SystemChromeMediumColor`
	`SystemTeal`	`SelectedContentBackgroundColor`	`SystemChromeMediumLowColor`
	`SystemYellow`	`SelectedControlColor`	`SystemChromeWhiteColor`
	`TertiaryLabel`	`SelectedControlTextColor`	`SystemListLowColor`
		`SelectedMenuItemTextColor`	`SystemListMediumColor`
		`SelectedTextBackgroundColor`
		`SelectedTextColor`
		`Separator`
		`SeparatorColor`
		`ShadowColor`
		`SystemBlue`
		`SystemGray`
		`SystemGreen`
		`SystemIndigo`
		`SystemOrange`
		`SystemPink`
		`SystemPurple`
		`SystemRed`
		`SystemTeal`
		`SystemYellow`
		`TertiaryLabel`
		`TertiaryLabelColor`
		`TextBackgroundColor`
		`TextColor`
		`UnderPageBackgroundColor`
		`UnemphasizedSelectedContentBackgroundColor`
		`UnemphasizedSelectedTextBackgroundColor`
		`UnemphasizedSelectedTextColor`
		`WindowBackgroundColor`
		`WindowFrameTextColor`

Device.StartTimer

Die Device Klasse verfügt auch über eine StartTimer Methode, die eine einfache Möglichkeit zum Auslösen zeitabhängiger Aufgaben bietet, die in Xamarin.Forms gemeinsamem Code funktionieren, einschließlich einer .NET Standard-Bibliothek. Übergeben Sie ein TimeSpan , um das Intervall festzulegen, und kehren Sie zurück true , um den Timer nach dem aktuellen Aufruf auszuführen oder false zu beenden.

Device.StartTimer (new TimeSpan (0, 0, 60), () =>
{
    // do something every 60 seconds
    return true; // runs again, or false to stop
});

Wenn der Code innerhalb des Timers mit der Benutzeroberfläche interagiert (z. B. festlegen des Texts eines Label oder anzeigen einer Warnung), sollte er innerhalb eines BeginInvokeOnMainThread Ausdrucks erfolgen (siehe unten).

Hinweis

Bei System.Timers.Timer den Klassen handelt System.Threading.Timer es sich um .NET Standard-Alternativen zur Verwendung der Device.StartTimer Methode.

Interagieren mit der Benutzeroberfläche über Hintergrundthreads

Die meisten Betriebssysteme, einschließlich iOS, Android und der Universelle Windows-Plattform, verwenden ein Einzelthreadingmodell für Code, der die Benutzeroberfläche umfasst. Dieser Thread wird häufig als Standard Thread oder UI-Thread bezeichnet. Ein Ergebnis dieses Modells ist, dass der gesamte Code, der auf Benutzeroberflächenelemente zugreift, im Standard Thread der Anwendung ausgeführt werden muss.

Anwendungen verwenden manchmal Hintergrundthreads, um potenziell lange ausgeführte Vorgänge auszuführen, z. B. das Abrufen von Daten aus einem Webdienst. Wenn Code, der in einem Hintergrundthread ausgeführt wird, auf Benutzeroberflächenelemente zugreifen muss, muss dieser Code im Standard Thread ausgeführt werden.

Die Device Klasse enthält die folgenden static Methoden, die für die Interaktion mit Benutzeroberflächenelementen aus Hintergrundthreads verwendet werden können:

Methode	Argumente	Rückgabe	Zweck
`BeginInvokeOnMainThread`	`Action`	`void`	Ruft einen `Action` im Standard Thread auf und wartet nicht, bis er abgeschlossen ist.
`InvokeOnMainThreadAsync<T>`	`Func<T>`	`Task<T>`	Ruft `Func<T>` auf dem Hauptthread auf, und wartet auf den Abschluss.
`InvokeOnMainThreadAsync`	`Action`	`Task`	Ruft `Action` auf dem Hauptthread auf, und wartet auf den Abschluss.
`InvokeOnMainThreadAsync<T>`	`Func<Task<T>>`	`Task<T>`	Ruft `Func<Task<T>>` auf dem Hauptthread auf, und wartet auf den Abschluss.
`InvokeOnMainThreadAsync`	`Func<Task>`	`Task`	Ruft `Func<Task>` auf dem Hauptthread auf, und wartet auf den Abschluss.
`GetMainThreadSynchronizationContextAsync`		`Task<SynchronizationContext>`	Gibt `SynchronizationContext` für den Hauptthread zurück

Der folgende Code zeigt ein Beispiel für die Verwendung der BeginInvokeOnMainThread Methode:

Device.BeginInvokeOnMainThread (() =>
{
    // interact with UI elements
});

Geräte-API