Xamarin.Forms Classe Device

La Device classe contiene una serie di proprietà e metodi che consentono agli sviluppatori di personalizzare il layout e le funzionalità in base alla piattaforma.

Oltre a metodi e proprietà per impostare come destinazione il codice a tipi e dimensioni hardware specifici, la Device classe include metodi che possono essere usati per interagire con i controlli dell'interfaccia utente dai thread in background. Per altre informazioni, vedere Interagire con l'interfaccia utente dai thread in background.

Specificare valori specifici della piattaforma

Prima della Xamarin.Forms versione 2.3.4, la piattaforma in cui era in esecuzione l'applicazione poteva essere ottenuta esaminando la Device.OS proprietà e confrontandola con i TargetPlatform.iOSvalori di enumerazione , TargetPlatform.AndroidTargetPlatform.WinPhone, e TargetPlatform.Windows . Analogamente, uno degli Device.OnPlatform overload può essere usato per fornire valori specifici della piattaforma a un controllo .

Tuttavia, dalla Xamarin.Forms versione 2.3.4 queste API sono state deprecate e sostituite. La Device classe contiene ora costanti di stringa pubblica che identificano le piattaforme , Device.iOS, Device.WinPhoneDevice.Android(deprecate), (deprecate), Device.UWPDevice.WinRT e Device.macOS. Analogamente, gli Device.OnPlatform overload sono stati sostituiti con le OnPlatform API e On .

In C#, i valori specifici della piattaforma possono essere forniti creando un'istruzione switch sulla Device.RuntimePlatform proprietà e quindi fornendo case istruzioni per le piattaforme necessarie:

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

Le OnPlatform classi e On forniscono le stesse funzionalità 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>

La OnPlatform classe è una classe generica di cui è necessario creare un'istanza con un x:TypeArguments attributo corrispondente al tipo di destinazione. On Nella classe l'attributo Platform può accettare un singolo string valore o più valori delimitati da string virgole.

Importante

Se si specifica un valore di attributo non corretto Platform nella On classe, non verrà generato un errore. Il codice verrà invece eseguito senza applicare il valore specifico della piattaforma.

In alternativa, l'estensione OnPlatform di markup può essere usata in XAML per personalizzare l'aspetto dell'interfaccia utente in base alla piattaforma. Per altre informazioni, vedere Estensione di markup OnPlatform.

Device.Idiom

La Device.Idiom proprietà può essere usata per modificare layout o funzionalità a seconda del dispositivo in cui è in esecuzione l'applicazione. L'enumerazione TargetIdiom contiene i valori seguenti:

Telefono : dispositivi iPhone, iPod touch e Android più stretti di 600 dips^
Tablet : iPad, dispositivi Windows e dispositivi Android più ampi di 600 dips^
Desktop: restituito solo nelle app UWP nei computer desktop Windows 10 (restituisce Phone nei dispositivi Windows mobili, inclusi gli scenari Continuum)
TV - Dispositivi Tv Tizen
Orologio - Dispositivi di controllo Tizen
Non supportato : non usato

^ dips non è necessariamente il numero di pixel fisici

La Idiom proprietà è particolarmente utile per la creazione di layout che sfruttano schermi più grandi, come illustrato di seguito:

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

La OnIdiom classe fornisce la stessa funzionalità 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>

La OnIdiom classe è una classe generica di cui è necessario creare un'istanza con un x:TypeArguments attributo corrispondente al tipo di destinazione.

In alternativa, l'estensione OnIdiom di markup può essere usata in XAML per personalizzare l'aspetto dell'interfaccia utente in base all'idioma del dispositivo in cui è in esecuzione l'applicazione. Per altre informazioni, vedere Estensione di markup OnIdiom.

Device.FlowDirection

Il Device.FlowDirection valore recupera un FlowDirection valore di enumerazione che rappresenta la direzione corrente del flusso utilizzata dal dispositivo. La direzione del flusso è la direzione in cui gli elementi dell'interfaccia utente della pagina vengono analizzati dall'occhio del lettore. I valori dell'enumerazione sono:

In XAML il Device.FlowDirection valore può essere recuperato usando l'estensione di x:Static markup:

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

Il codice equivalente in C# è:

this.FlowDirection = Device.FlowDirection;

Per altre informazioni sulla direzione del flusso, vedere Localizzazione da destra a sinistra.

Device.Styles

La Styles proprietà contiene definizioni di stile predefinite che possono essere applicate a alcune proprietà dei controlli, ad esempio Label. Style Gli stili disponibili sono:

BodyStyle
CaptionStyle
ListItemDetailTextStyle
ListItemTextStyle
SubtitleStyle
TitleStyle

Device.GetNamedSize

GetNamedSize può essere usato quando si imposta FontSize nel codice 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 introduce il supporto per i colori denominati. Un colore denominato è un colore che ha un valore diverso a seconda della modalità di sistema (ad esempio, chiaro o scuro) nel dispositivo. In Android, i colori denominati sono accessibili tramite la classe R.Color . In iOS i colori denominati sono denominati colori di sistema. Nella piattaforma UWP (Universal Windows Platform) i colori denominati sono denominati risorse del tema XAML.

Il GetNamedColor metodo può essere usato per recuperare i colori denominati in Android, iOS e UWP. Il metodo accetta un string argomento e restituisce un oggetto Color:

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

Color.Default verrà restituito quando non è possibile trovare un nome di colore o quando GetNamedColor viene richiamato su una piattaforma non supportata.

Nota

Poiché il GetNamedColor metodo restituisce un Color oggetto specifico di una piattaforma, in genere deve essere usato insieme alla Device.RuntimePlatform proprietà .

La NamedPlatformColor classe contiene le costanti che definiscono i colori denominati per Android, iOS e UWP:

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

La Device classe include anche un metodo che fornisce un StartTimer modo semplice per attivare attività dipendenti dal tempo che funzionano nel Xamarin.Forms codice comune, inclusa una libreria .NET Standard. Passare un TimeSpan oggetto per impostare l'intervallo e tornare true a mantenere il timer in esecuzione o false per arrestarlo dopo la chiamata corrente.

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

Se il codice all'interno del timer interagisce con l'interfaccia utente ,ad esempio impostando il testo di un Label oggetto o visualizzando un avviso, deve essere eseguito all'interno di un'espressione BeginInvokeOnMainThread (vedere di seguito).

Nota

Le System.Timers.Timer classi e System.Threading.Timer sono alternative .NET Standard all'uso del Device.StartTimer metodo .

Interagire con l'interfaccia utente dai thread in background

La maggior parte dei sistemi operativi, tra cui iOS, Android e il piattaforma UWP (Universal Windows Platform), usa un modello a threading singolo per il codice che coinvolge l'interfaccia utente. Questo thread viene spesso chiamato thread principale o thread dell'interfaccia utente. Una conseguenza di questo modello è che tutto il codice che accede agli elementi dell'interfaccia utente deve essere eseguito nel thread principale dell'applicazione.

Le applicazioni talvolta usano thread in background per eseguire operazioni potenzialmente a esecuzione prolungata, ad esempio il recupero di dati da un servizio Web. Se il codice in esecuzione in un thread in background deve accedere agli elementi dell'interfaccia utente, deve eseguire tale codice nel thread principale.

La Device classe include i metodi seguenti static che possono essere usati per interagire con gli elementi dell'interfaccia utente dai thread in background:

metodo	Argomenti	Valori restituiti	Scopo
`BeginInvokeOnMainThread`	`Action`	`void`	Richiama un oggetto `Action` nel thread principale e non attende il completamento.
`InvokeOnMainThreadAsync<T>`	`Func<T>`	`Task<T>`	Richiama un oggetto `Func<T>` sul thread principale e ne attende il completamento.
`InvokeOnMainThreadAsync`	`Action`	`Task`	Richiama un oggetto `Action` sul thread principale e ne attende il completamento.
`InvokeOnMainThreadAsync<T>`	`Func<Task<T>>`	`Task<T>`	Richiama un oggetto `Func<Task<T>>` sul thread principale e ne attende il completamento.
`InvokeOnMainThreadAsync`	`Func<Task>`	`Task`	Richiama un oggetto `Func<Task>` sul thread principale e ne attende il completamento.
`GetMainThreadSynchronizationContextAsync`		`Task<SynchronizationContext>`	Restituisce l'oggetto `SynchronizationContext` per il thread principale.

Il codice seguente illustra un esempio di utilizzo del BeginInvokeOnMainThread metodo :

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

API del dispositivo

Last updated on 2020-07-20

Condividi tramite