Récupère la largeur de l'écran en xamarin forms

Je suis entrain de créer un Xamarin Forms projet et je me suis coincé dans la recherche de la largeur de l'écran en fonction de l'autre appareil.

Je sais combien il peut être fait dans android et ios, mais ont besoin d'un moyen pour trouver la largeur de portable.

OriginalL'auteur Tushar patel | 2016-08-11

34

Vous pouvez essayer ce Application.Current.MainPage.Width dans mon cas, cela a fonctionné et je suis capable de trouver l'appareil largeur portable de projet lui-même.

Cela ne fonctionne pas pour moi, j'obtiens une exception de pointeur null 🙁
Que serait probablement l'équivalent d'un peu de taper cette.Largeur directement. Du cycle de vie, le timing est pertinente ici.

OriginalL'auteur Parth Patel
20

Code commun (dans l'App.xaml.cs)
```
public static int ScreenHeight {get; set;}
public static int ScreenWidth {get; set;}
```
Android (MainActivity.cs, dans la méthode OnCreate)
```
App.ScreenHeight = (int) (Resources.DisplayMetrics.HeightPixels /Resources.DisplayMetrics.Density);
App.ScreenWidth = (int) (Resources.DisplayMetrics.WidthPixels /Resources.DisplayMetrics.Density);
```
iOS (dans AppDelegate.cs, dans le FinishedLaunching méthode)
```
App.ScreenHeight = (int)UIScreen.MainScreen.Bounds.Height;
App.ScreenWidth = (int)UIScreen.MainScreen.Bounds.Width;
```
Donc D'Application.ScreenHeight et App.ScreenWidth sera initialisé lors de l'Application sera lancée, alors vous serez en mesure de les utiliser n'importe où dans le code commun.

cela renvoie 0 pour moi
sur iOS, c'est, semble fonctionner sur android
Fonctionne mieux que Xamarin.Essentials (ce qui m'a donné assez de nombres aléatoires)!

OriginalL'auteur Nicolas Bodin-Ripert
12

Je sais que c'est un vieux thread mais vaut la peine de mentionner que récemment Xamarin.Essentials NuGet emballage a été libéré et il est utile de classe DeviceDisplay qu'il doit gérer cette tâche pour vous.

La documentation peut être trouvée ici.

Exemple d'utilisation:
```
//Get Metrics
var mainDisplayInfo = DeviceDisplay.MainDisplayInfo;

//Orientation (Landscape, Portrait, Square, Unknown)
var orientation = mainDisplayInfo.Orientation;

//Rotation (0, 90, 180, 270)
var rotation = mainDisplayInfo.Rotation;

//Width (in pixels)
var width = mainDisplayInfo.Width;

//Height (in pixels)
var height = mainDisplayInfo.Height;

//Screen density
var density = mainDisplayInfo.Density;
```
DeviceDisplay.ScreenMetrics semble avoir été renommé DeviceDisplay.MainDisplayInfo.
Juste mis à jour, merci!
J'ai dû diviser mainDisplayInfo.Width/Height par mainDisplayInfo.Density pour obtenir les valeurs que je cherchais.

OriginalL'auteur EvZ
5

Vous pouvez utiliser la Largeur de la propriété lorsque vous êtes dans un ContentPage. Par exemple,
```
protected override void OnAppearing()
{
    base.OnAppearing();
    double w = this.Width;
}
```
Noter que cette fonction est définie lors de la Mise en page de phase. Donc, vous ne pouvez l'utiliser que lorsque la page est initialisé, sinon, il est de -1.

https://developer.xamarin.com/api/property/Xamarin.Forms.VisualElement.Width/

vous pourriez avoir à attendre la Tâche.Delay(1000); pour la Largeur à apparaître...
De la tâche.Le retard n'est pas un bon moyen d'attente pour obtenir des propriétés de taille. Au lieu de cela, je voudrais plutôt vous abonnant à la EventHandler 'SizeChanged' d'un point de vue comme ça: SizeChanged += (sender, e) => {...};

OriginalL'auteur Khoa Tran
1

Une autre approche serait d'utiliser l'override "OnSizeAllocated" pour votre page, puis prenez de la hauteur et la largeur en fonction des modifications sur l'écran de l'utilisateur. Vous pouvez créer une classe statique pour définir la hauteur et la largeur de votre écran, à chaque fois, il change, puis d'y accéder à partir de cette classe en cas de besoin.

La classe statique pour créer et accéder à la dimension de l'appareil:
```
public static class ScreenDimensions
{
    public static double Height { get; set; }
    public static double Width { get; set; }
}
```
Remplacer afin d'obtenir les dimensions de l'écran:
```
protected override void OnSizeAllocated(double width, double height)
{
    base.OnSizeAllocated(width, height);
    ScreenDimensions.Height = height;
    ScreenDimensions.Width = width;
}
```
OriginalL'auteur Sparsha Bhattarai

Je voudrais créer un statique de la structure dans le code partagé, afin que je puisse accéder à l'écran de la largeur/hauteur des valeurs facilement (ainsi que le fait de faire des liaisons dans le xAML)

La structure dans l'application de l'espace de noms (par exemple. en Application.xaml.cs):

using System;
using Xamarin.Forms;

namespace YourAppName
{
    public static class HelperFunction
    {
        ... 

        public struct Constant
        {
            public static double ScreenWidth = Application.Current.MainPage.Width;
            public static double ScreenHeight = Application.Current.MainPage.Height;
        }

        ...
    }
}

de la récupération de la largeur de l'écran en C#:

var labelWidth = Constant.ScreenHeight * 0.2;
//then do something with labelWidth

De la récupération de la largeur de l'écran en XAML:

<Label Text="Text with insane font size" FontSize="{Binding Source={x:Static local:Constant.ScreenWidth}}"/>

OriginalL'auteur Patrick

Je Suppose que le meilleur moyen est d'utiliser les xamarin.les formulaires.Informations sur le périphérique.

               Size size = Device.Info.PixelScreenSize;

            if (size.Width <= 720 && size.Height <= 1280)
            {
                stkLayoutTop.Margin = new Thickness(5, 30, 10, 0);
            }
            else
            {
                stkLayoutTop.Margin = new Thickness(5, 50, 10, 0);
            }

OriginalL'auteur Igor Monteiro

Vous devez vous connecter pour publier un commentaire.