Comment obtenir/de détecter la taille de l'écran de Xamarin.Les formes?

Je suis en train de réécrire une application que j'ai écrit pour iOS. J'allais écrire une version d'android, mais pensé qu'Il serait mieux pour faire de cette occasion pour utiliser Xamarin.Les formulaires. Faire une page à la fois, maintenant, je suis bloqué sur une page où j'ai besoin d'obtenir la largeur de l'écran et de la hauteur. Quelqu'un sait-il l'équivalent de l'iOS " Vue.Cadre.Largeur de Xamarin.Les formes?

InformationsquelleAutor dmc | 2014-06-28

4

Il n'y a pas actuellement un moyen de Xamarin.Les formulaires de lui-même, mais nous l'avons mis en œuvre comme PCL interface compatible de Xamarin.Les formulaires.Les laboratoires de laquelle vous pouvez obtenir à partir de NuGet ou de code source à partir de GitHub.

https://github.com/XForms/Xamarin-Forms-Labs

IDevice a IDisplay propriété de l'information; la hauteur, la largeur, la densité de pixel pour X & Y et un couple de méthodes d'extension pour calculer la taille en pouces.

Exemple de page pour obtenir des informations de l'appareil:

https://github.com/XForms/Xamarin-Forms-Labs/blob/master/samples/Xamarin.Forms.Labs.Sample/Pages/Services/ExtendedDeviceInfoPage.cs
```
        #region Display information
        var display = device.Display;
        var displayFrame = new Frame();
        if (display != null)
        {
            displayFrame.Content = new StackLayout()
            {
                Children =
                {
                    new Label() { Text = display.ToString() },
                    new Label() { Text = string.Format("Screen width is\t {0:0.0} inches.", display.ScreenWidthInches()) },
                    new Label() { Text = string.Format("Screen height is\t {0:0.0} inches.", display.ScreenHeightInches()) },
                    new Label() { Text = string.Format("Screen diagonal size is\t {0:0.0} inches.", display.ScreenSizeInches()) }
                            }
                        };
        }
        else
        {
            displayFrame.Content = new Label() { TextColor = Color.Red, Text = "Device does not contain display information." };
        }

        stack.Children.Add(displayFrame); 
        #endregion
```
Création exact, pouce par pouce cadre sur toutes les plateformes indépendamment des propriétés d'affichage:

https://github.com/XForms/Xamarin-Forms-Labs/blob/master/samples/Xamarin.Forms.Labs.Sample/Pages/Services/AbsoluteLayoutWithDisplayInfoPage.cs
```
public class AbsoluteLayoutWithDisplayInfoPage : ContentPage
{
    public AbsoluteLayoutWithDisplayInfoPage(IDisplay display)
    {
        this.Title = "Absolute Layout With Display Info";
        var abs = new AbsoluteLayout();
        var inchX = display.WidthRequestInInches(1);
        var inchY = display.HeightRequestInInches(1);
        var originX = display.WidthRequestInInches(display.ScreenWidthInches() / 2);
        var originY = display.HeightRequestInInches(display.ScreenHeightInches() / 2);

        abs.Children.Add(new Label() { Text = "1\"x\"1\" blue frame" });

        abs.Children.Add(new Frame()
            {
                BackgroundColor = Color.Navy,
            },
            new Rectangle(originX - inchX/2, originY - inchY/2, inchX, inchY));

        abs.Children.Add(new Frame()
            {
                BackgroundColor = Color.White
            },
            new Rectangle(originX - inchX/16, originY - inchY/16, inchX/8, inchY/8));

        this.Content = abs;
    }
}
```
Pour obtenir les informations sur l'appareil soit mis à votre DI résolveur ou utiliser un statique conteneur. Tous les 3 plates-formes ont un singleton appareil appels statiques CurrentDevice propriété:
```
resolverContainer.Register<IDevice>(t => WindowsPhoneDevice.CurrentDevice)
resolverContainer.Register<IDevice>(t => AppleDevice.CurrentDevice)
resolverContainer.Register<IDevice>(t => AndroidDevice.CurrentDevice)
```
- Merci @SKall , je ne vais pas faire mon application la PCL - mais je vais assurez-vous de jeter un oeil et voir si je peux obtenir quelques idées. Merci!!!!
- Le code fonctionne si à l'aide d'un code partagé ou PCL. Sur le partage de code, vous n'avez pas besoin de DI, il suffit d'utiliser les drapeaux de compilation pour obtenir l'appareil actuel.
- Merci @SKall , vais essayer ce matin.
- Salut @SKall, j'ai enfin essayé ce matin mais a rencontré quelque chose de bizarre. d'affichage.ScreenWidthInches() renvoie toujours 640 sur l'iphone, qui n'a pas de sens parce que je sais que la largeur ne doit être à plus de 300. Ce que j'essaie de faire est de tenir dans 4 boutons à l'intérieur du téléphone, les images (il faut du bouton de largeur = largeur de l'écran / 4). Ai-je raté quelque chose? Pensées?
- Pouvez-vous me dire quel est le PhoneType est (de Téléphone.La Version)? Si c'est l'iPhone puis IDevice doit être de type Téléphone au moment de l'exécution. Vous pouvez également appeler la méthode statique de AppleDevice.GetSystemProperty("hw.la machine"); pour obtenir la version du matériel de la chaîne. Qui serait me dire si il y a un problème d'identification de l'appareil.
- Salut @SKall, Téléphone.Version est iPhone5CDMA
- La largeur de l'affichage pour iPhone 5 est de 640 pixels. ScreenWidthInches() doit retourner 2.31 (pouces).
- Salut @SKall, Vraiment désolé de vous déranger mate. Petite question , coz je suis un peu perdu ici. Avant je l'ai fait, mes boutons " widthRequest était de 75. J'ai eu 4 boutons d'ajustement de l'écran parfaitement avec 5 bouton de lacunes. Maintenant, à partir de 640, comment puis-je convertir que pour le faire fonctionner comme avant? Quand je dis d'affichage.WudthRequestInInches(1), je suis 163. Comment puis-je convertir affichage.La largeur? Est-il une méthode de travail, je manque ici?
- Vous obtenez la largeur en pouces (2.31) et de diviser le résultat par 4. Alors appeler dans WidthRequestInInches(2.31 / 4), qui vous donnera le 1/4 de la longueur de la largeur de l'écran demande à utiliser avec Xamarin.Les formulaires. Déduire le rembourrage que vous souhaitez appliquer. Vous pouvez également consulter la page d'exemple ici: github.com/XForms/Xamarin-Forms-Labs/blob/master/samples/...
- Génial! Qui a travaillé @SKall, merci!... J'ai effectivement pu faire mes boutons tenir dans l'écran à l'aide de la FillAndExpand horizontale options (mais la largeur ne sont même pas - comme certains sont plus larges et certains sont plus minces...ce qui fait l'air mieux que ce que j'attendais), MAIS encore besoin d'réelle de la largeur de l'écran afin que je puisse calculer la hauteur de mes boutons pour faire proportion de leur largeur. Merci s'accoupler!
InformationsquelleAutor SKall
30

Mise à jour: Vous pouvez utiliser Xamarin.Essentials package nuget pour cela et pour bien d'autres raisons.
```
var width = DeviceDisplay.MainDisplayInfo.Width;
var height = DeviceDisplay.MainDisplayInfo.Height;
```
Vieille réponse:

Il y a un moyen facile d'obtenir la largeur de l'écran et de la hauteur en Xamarin.Forms et l'accès à l'échelle mondiale à partir de partout dans votre application. J'aimerais faire quelque chose comme ceci:

1. Créer deux membres du public dans votre Application.cs:
```
public static class App
{
    public static int ScreenWidth;
    public static int ScreenHeight;
    ...
}
```
2. Définir les valeurs de votre MainActivity.cs (Android) ou votre AppDelegate.cs (iOS):

Android:
```
protected override void OnCreate(Bundle bundle)
{
    ...

    App.ScreenWidth = (int)Resources.DisplayMetrics.WidthPixels; //real pixels
    App.ScreenHeight = (int)Resources.DisplayMetrics.HeightPixels; //real pixels

    //App.ScreenWidth = (int)(Resources.DisplayMetrics.WidthPixels /Resources.DisplayMetrics.Density); //device independent pixels
    //App.ScreenHeight = (int)(Resources.DisplayMetrics.HeightPixels /Resources.DisplayMetrics.Density); //device independent pixels

    ...
}
```
iOS:
```
public override bool FinishedLaunching(UIApplication app, NSDictionary options)
{
    ...

    App.ScreenWidth = (int)UIScreen.MainScreen.Bounds.Width;
    App.ScreenHeight = (int)UIScreen.MainScreen.Bounds.Height;

    ...
}
```
- App.cs n'est pas statique
- Avant De Xamarin.Les formes de la version 1.3.x il était. D'une façon encore plus précise est décrite dans notre livre sur la xforms-kickstarter.com sous faisant Référence à la taille de l'écran.
- Sur Android je suggère d'utiliser: var pixels = Ressources.DisplayMetrics.WidthPixels; // dip pixels var échelle = Ressources.DisplayMetrics.Densité; int dps = (int)((pixels - 0,5 f) / échelle); App.ScreenWidth = dps; pixels = Ressources.DisplayMetrics.HeightPixels; // dip pixels dps = (int)((pixels - 0,5 f) / échelle); App.ScreenHeight = dps; // dip pixels
InformationsquelleAutor kaolick
6

Si vous utilisez xamarin forms, vous pouvez trouver la largeur et la hauteur de l'écran actuel dans la bibliothèque de classes portable(pcl) comme ci-dessous.

Pour la Largeur que vous utilisez ce pcl,
```
Application.Current.MainPage.Width
```
Pour la taille, vous pouvez le faire en mode d'émulation pcl,
```
Application.Current.MainPage.Height
```
- Je suis l'exception d'exécution " Objet de référence non définie à une instance d'un objet.".
- cela vous donne la largeur et la hauteur que vous définissez. pas de l'écran de l'appareil tailles. vous pouvez ajouter dans le code xaml width=5000 et, vous retournez à 5000. vous devez aller natif pour obtenir de réels de taille d'écran.
InformationsquelleAutor Tushar patel

Recette

Créer un nouveau Xamarin.Application Android nommée ScreenSize.
Edit Principal.axml de sorte qu'il contienne deux TextViews:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <TextView
        android:text="Screen Width:"
        android:textAppearance="?android:attr/textAppearanceLarge"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:id="@+id/screenWidthDp" />
    <TextView
        android:text="Screen Height:"
        android:textAppearance="?android:attr/textAppearanceLarge"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:id="@+id/screenHeightDp" />
</LinearLayout>

Modifier Activity1.cs, modifiez le code dans OnCreate suivantes:

![entrez la description de l'image ici][1]
private int ConvertPixelsToDp(float pixelValue)
{
var dp = (int) ((pixelValue)/Ressources.DisplayMetrics.La densité);
retour dp;
}
Exécuter l'application. Selon l'appareil, il affichera l'écran de la hauteur et la largeur. La capture d'écran suivante est à partir d'un Galaxy Nexus:

[lien image] http://i.stack.imgur.com/TQhba.png

J'étais à la recherche de "Xamarin.Les formes" pour cela, mais merci.

InformationsquelleAutor TheEmperorDeveloper

Dans votre Application fichier définir un public statique de la variable

public static Size ScreenSize;

Il faut initialiser la variable à la fois sous IOS et Android avant d'appeler l'App constructeur. Pour IOS, en FinishedLaunching méthode

App.ScreenSize = new Size(UIScreen.MainScreen.Bounds.Width, UIScreen.MainScreen.Bounds.Height);

et Pour Android, en fonction OnCreate

            App.ScreenSize = new Xamarin.Forms.Size((int)(Resources.DisplayMetrics.WidthPixels / Resources.DisplayMetrics.Density), (int)(Resources.DisplayMetrics.HeightPixels / Resources.DisplayMetrics.Density));

InformationsquelleAutor sof98789

0

Mise à jour pour les futurs développeurs d'essayer de faire ce qui, soit n'ont pas regardé ou raté. La Page de la classe hérite de VisualElement, qui a désormais deux propriétés (qui se trouvent être peut être liée pour une utilisation dans le code XAML):

Largeur Obtient la rendu la largeur de cet élément. C'est une lecture peut être liée uniquement à la propriété.
Hauteur Obtient la rendu la hauteur de cet élément. C'est une lecture peut être liée uniquement à la propriété.

dans votre page code-behind, vous faites juste quelque chose comme:
```
var myWidth = this.Width;
var myHeight = this.Height;
```
si vous avez besoin de savoir si c'modifications, utilisez la SizeChanged événement:
```
public MyPage()
{
    SizeChanged += OnSizeChanged;
}

private void OnSizeChanged(object sender, EventArgs e)
{
    var myWidth = this.Width;
    var myHeight = this.Height;
}
```
ref: Microsoft Docs

InformationsquelleAutor Duane

Vous devez vous connecter pour publier un commentaire.