Xamarin.Forms Klasa urządzenia

Klasa Device zawiera wiele właściwości i metod, które ułatwiają deweloperom dostosowywanie układu i funkcjonalności dla poszczególnych platform.

Oprócz metod i właściwości kodu docelowego w określonych typach sprzętu i rozmiarach klasa zawiera metody, Device które mogą służyć do interakcji z kontrolkami interfejsu użytkownika z wątków w tle. Aby uzyskać więcej informacji, zobacz Interakcja z interfejsem użytkownika z wątków w tle.

Podaj wartości specyficzne dla platformy

Xamarin.Forms Przed wersją 2.3.4 platforma, na którą uruchomiono aplikację, można uzyskać, sprawdzając Device.OS właściwość i porównując ją z wartościami TargetPlatform.iOSTargetPlatform.Android, , TargetPlatform.WinPhonei TargetPlatform.Windows wyliczenia. Podobnie można użyć jednego z Device.OnPlatform przeciążeń w celu zapewnienia wartości specyficznych dla platformy dla kontrolki.

Jednak od Xamarin.Forms wersji 2.3.4 te interfejsy API zostały wycofane i zastąpione. Klasa Device zawiera teraz stałe ciągów publicznych identyfikujące platformy — Device.iOS, , Device.Android(Device.WinPhoneprzestarzałe), (przestarzałe), Device.UWPDevice.WinRT i Device.macOS. Device.OnPlatform Podobnie przeciążenia zostały zastąpione interfejsami OnPlatform API i On .

W języku C#wartości specyficzne dla platformy można podać, tworząc instrukcję switch we Device.RuntimePlatform właściwości, a następnie podając case instrukcje dla wymaganych platform:

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);

Klasy OnPlatform i On zapewniają te same funkcje w języku 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>

Klasa OnPlatform jest klasą ogólną, która musi zostać utworzone za pomocą atrybutu zgodnego z typem x:TypeArguments docelowym. On W klasie Platform atrybut może akceptować pojedynczą string wartość lub wiele wartości rozdzielonych string przecinkami.

Ważne

Podanie nieprawidłowej Platform wartości atrybutu On w klasie nie spowoduje błędu. Zamiast tego kod zostanie wykonany bez zastosowania wartości specyficznej dla platformy.

Alternatywnie OnPlatform rozszerzenie znaczników może służyć w języku XAML do dostosowywania wyglądu interfejsu użytkownika dla poszczególnych platform. Aby uzyskać więcej informacji, zobacz OnPlatform Markup Extension (Rozszerzenie znaczników OnPlatform).

Device.Idiom

Właściwość Device.Idiom może służyć do zmiany układów lub funkcji w zależności od urządzenia, na którym działa aplikacja. Wyliczenie TargetIdiom zawiera następujące wartości:

Telefon — urządzenia iPhone, iPod touch i Android węższe niż 600 dips^
Tablet — urządzenia iPad, urządzenia z systemem Windows i urządzenia z systemem Android szersze niż 600 dips^
Desktop — zwracane tylko w aplikacjach platformy UNIWERSALNEJ systemu Windows na komputerach stacjonarnych z systemem Windows 10 (zwracane Phone na urządzeniach przenośnych z systemem Windows, w tym w scenariuszach Continuum)
TV – urządzenia telewizyjne Tizen
Zegarek — urządzenia zegarków Tizen
Nieobsługiwane — nieużywane

^ dips nie musi być fizyczna liczba pikseli

Właściwość jest szczególnie przydatna Idiom w przypadku tworzenia układów korzystających z większych ekranów, takich jak:

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

Klasa OnIdiom zapewnia te same funkcje w języku 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>

Klasa OnIdiom jest klasą ogólną, która musi zostać utworzone za pomocą atrybutu zgodnego z typem x:TypeArguments docelowym.

Alternatywnie można użyć rozszerzenia znaczników w języku XAML, OnIdiom aby dostosować wygląd interfejsu użytkownika na podstawie idiomu urządzenia, na którym działa aplikacja. Aby uzyskać więcej informacji, zobacz OnIdiom Markup Extension (Rozszerzenie znaczników OnIdiom).

Device.FlowDirection

Wartość Device.FlowDirection pobiera FlowDirection wartość wyliczenia reprezentującą bieżący kierunek przepływu używany przez urządzenie. Kierunek przepływu to kierunek, w którym elementy interfejsu użytkownika na stronie są skanowane przez oko. Wartości wyliczenia to:

W języku Device.FlowDirection XAML wartość można pobrać przy użyciu x:Static rozszerzenia znaczników:

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

Równoważny kod w języku C# to:

this.FlowDirection = Device.FlowDirection;

Aby uzyskać więcej informacji na temat kierunku przepływu, zobacz Lokalizacja od prawej do lewej.

Device.Styles

Właściwość Styles zawiera wbudowane definicje stylów, które można zastosować do niektórych kontrolek (takich jak Label) Style właściwości. Dostępne style to:

Styl ciała
CaptionStyle
ListItemDetailTextStyle
ListItemTextStyle
Styl podtytułu
Styl tytułu

Device.GetNamedSize

GetNamedSize można użyć podczas ustawiania FontSize w kodzie języka C#:

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 wprowadza obsługę nazwanych kolorów. Nazwany kolor to kolor, który ma inną wartość w zależności od tego, który tryb systemowy (na przykład jasny lub ciemny) jest aktywny na urządzeniu. W systemie Android dostęp do nazwanych kolorów uzyskuje się za pośrednictwem klasy R.Color . W systemie iOS nazwane kolory są nazywane kolorami systemu. Na platforma uniwersalna systemu Windows nazwane kolory są nazywane zasobami motywu XAML.

Metoda może służyć do pobierania GetNamedColor nazwanych kolorów w systemach Android, iOS i UWP. Metoda przyjmuje string argument i zwraca wartość Color:

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

Color.Default zostanie zwrócona, gdy nie można odnaleźć nazwy koloru lub gdy GetNamedColor jest wywoływana na nieobsługiwanej platformie.

Uwaga

GetNamedColor Ponieważ metoda zwraca wartość specyficzną Color dla platformy, zwykle powinna być używana w połączeniu z właściwością Device.RuntimePlatform .

Klasa NamedPlatformColor zawiera stałe, które definiują nazwane kolory dla systemów Android, iOS i UWP:

Android	iOS	macOS	Platforma 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

Klasa Device ma również metodę StartTimer , która zapewnia prosty sposób wyzwalania zadań zależnych od czasu, które działają we wspólnym kodzie, w Xamarin.Forms tym biblioteki .NET Standard. Przekaż element , TimeSpan aby ustawić interwał i wrócić true , aby zachować czasomierz uruchomiony lub false zatrzymać go po bieżącej wywołaniu.

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

Jeśli kod wewnątrz czasomierza wchodzi w interakcję z interfejsem użytkownika (np. ustawieniem tekstu Label obiektu lub wyświetleniem alertu), należy go wykonać wewnątrz BeginInvokeOnMainThread wyrażenia (patrz poniżej).

Uwaga

Klasy System.Timers.Timer i System.Threading.Timer to alternatywy dla platformy .NET Standard przy użyciu Device.StartTimer metody .

Interakcja z interfejsem użytkownika z wątków w tle

Większość systemów operacyjnych, w tym systemów iOS, Android i platforma uniwersalna systemu Windows, używa modelu jednowątkowego dla kodu obejmującego interfejs użytkownika. Ten wątek jest często nazywany głównym wątkiem lub wątkiem interfejsu użytkownika. Konsekwencją tego modelu jest to, że cały kod, który uzyskuje dostęp do elementów interfejsu użytkownika, musi być uruchamiany w głównym wątku aplikacji.

Aplikacje czasami używają wątków w tle do wykonywania potencjalnie długotrwałych operacji, takich jak pobieranie danych z usługi internetowej. Jeśli kod działający w wątku w tle musi uzyskać dostęp do elementów interfejsu użytkownika, musi on uruchomić ten kod w głównym wątku.

Klasa Device zawiera następujące static metody, które mogą służyć do interakcji z elementami interfejsu użytkownika z wątków tła:

Method	Argumenty	Zwraca	Purpose
`BeginInvokeOnMainThread`	`Action`	`void`	Wywołuje element `Action` w wątku głównym i nie czeka na jego ukończenie.
`InvokeOnMainThreadAsync<T>`	`Func<T>`	`Task<T>`	Wywołuje element `Func<T>` w wątku głównym i czeka na jego ukończenie.
`InvokeOnMainThreadAsync`	`Action`	`Task`	Wywołuje element `Action` w wątku głównym i czeka na jego ukończenie.
`InvokeOnMainThreadAsync<T>`	`Func<Task<T>>`	`Task<T>`	Wywołuje element `Func<Task<T>>` w wątku głównym i czeka na jego ukończenie.
`InvokeOnMainThreadAsync`	`Func<Task>`	`Task`	Wywołuje element `Func<Task>` w wątku głównym i czeka na jego ukończenie.
`GetMainThreadSynchronizationContextAsync`		`Task<SynchronizationContext>`	Zwraca wartość `SynchronizationContext` dla głównego wątku.

Poniższy kod przedstawia przykład użycia BeginInvokeOnMainThread metody :

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

Interfejs API urządzenia

Last updated on 2020-07-20

Udostępnij za pomocą