Screen.AllScreen ne donne pas le nombre de moniteurs correct

Je suis en train de faire quelque chose comme ça dans mon programme:

Int32 currentMonitorCount = Screen.AllScreens.Length;

if  (currentMonitorCount < 2)
{
   //Put app in single screen mode.
}
else
{
   //Put app in dual screen mode.
}

Il est TRÈS important de mon application reconnaît la façon dont la plupart des moniteurs sont connectés.

Cependant, après que j'ai brancher/débrancher le moniteur une couple de fois, l'Écran.AllScreens.Longueur renvoie toujours la valeur '2'.

Mon moniteur sait qu'il n'est pas connecté (il a est entré " power save mode), et le panneau de contrôle sait qu'il n'est pas connecté (il montre qu'un seul moniteur).

Donc ce qui me manque? Comment faire je comprendre qu'il n'y a qu'un seul moniteur?

source d'informationauteur DanTheMan | 2011-02-16

.net c#multiple-monitors windows-7 winforms

J'ai eu un coup d'oeil à la source (n'oubliez pas que nous pouvons le faire en utilisant le MME Symbole de serveurs). AllScreens utilise non géré API pour obtenir les écrans sur les première d'accès, puis stocke le résultat dans une variable statique pour une utilisation ultérieure.

La conséquence de cela est que si le nombre de moniteurs changements alors que votre programme est en cours d'exécution; puis Screen.AllScreens ne sera pas ramasser le changement.

La façon la plus simple de contourner ce serait probablement pour appeler la non géré API directement.
(Ou vous pourriez être mal, et utiliser la réflexion pour définir la statique screens champ à null avant de demander. Ne pas le faire).

Edit:

Si vous avez juste besoin de connaître le nombre, de vérifier si vous pouvez utiliser System.Windows.Forms.SystemInformation.MonitorCount (comme suggéré dans les commentaires) avant d'aller le P/Invoke route. Cela appelle GetSystemMetrics directement, et c'est probablement correctement mis à jour.

Si vous trouvez que vous avez besoin de le faire à l'aide de P/Invoke, ici est un exemple qui illustre l'utilisation de la non géré API en C#:

using System;
using System.Runtime.InteropServices;

class Program
{
    public static void Main()
    {
        int monCount = 0;
        Rect r = new Rect();
        MonitorEnumProc callback = (IntPtr hDesktop, IntPtr hdc, ref Rect prect, int d) => ++monCount > 0;                                       
        if (EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, callback, 0))
            Console.WriteLine("You have {0} monitors", monCount);
        else
            Console.WriteLine("An error occured while enumerating monitors");

    }
    [DllImport("user32")]
    private static extern bool EnumDisplayMonitors(IntPtr hdc, IntPtr lpRect, MonitorEnumProc callback, int dwData);

    private delegate bool MonitorEnumProc(IntPtr hDesktop, IntPtr hdc, ref Rect pRect, int dwData);

    [StructLayout(LayoutKind.Sequential)]
    private struct Rect
    {
        public int left;
        public int top;
        public int right;
        public int bottom;
    }
}

Bâtiment sur la réponse précédente par driis, c'est la façon dont j'ai géré ça. Il est à noter que le code suivant vit dans mon Programme.cs fichier.

D'abord les liens vers des ressources externes et des structures de données:

    [DllImport("user32")]
    private static extern bool EnumDisplayMonitors(IntPtr hdc, IntPtr lpRect, MonitorEnumProc callback, int dwData);

    private delegate bool MonitorEnumProc(IntPtr hDesktop, IntPtr hdc, ref Rect pRect, int dwData);

    [StructLayout(LayoutKind.Sequential)]
    private struct Rect
    {
        public int left;
        public int top;
        public int right;
        public int bottom;
    }

Maintenant créer un objet simple pour contenir d'informations sur le moniteur:

public class MonitorInfo
{
    public bool IsPrimary = false;
    public Rectangle Bounds = new Rectangle();
}

Et un conteneur pour ces objets:

    public static List<MonitorInfo> ActualScreens = new List<MonitorInfo>();

et une méthode pour actualiser le conteneur:

    public static void RefreshActualScreens()
    {
        ActualScreens.Clear();
        MonitorEnumProc callback = (IntPtr hDesktop, IntPtr hdc, ref Rect prect, int d) =>
        {
            ActualScreens.Add(new MonitorInfo()
                {
                    Bounds = new Rectangle()
                    {
                        X = prect.left,
                        Y = prect.top,
                        Width = prect.right - prect.left,
                        Height = prect.bottom - prect.top,
                    },
                    IsPrimary = (prect.left == 0) && (prect.top == 0),
                });

            return true;
        };

        EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, callback, 0);
    }

Puis plus tard sur un Formulaire, Si je voulais détecter qu'un écran a été ajouté ou supprimé ...

    private const int WM_DISPLAYCHANGE = 0x007e;

    protected override void WndProc(ref Message message)
    {
        base.WndProc(ref message);

        if (message.Msg == WM_DISPLAYCHANGE)
        {
            Program.RefreshActualScreens();
            //do something really interesting here
        }
    }

Peut-être quelques fautes de frappe, mais c'est l'idée de base. Bonne chance!

1

J'avais regarder le code de l'Écran de la classe ( dans ici )

Voir la ligne 120, Écran.AllScreens utiliser le champ de l'Écran.les écrans de temp.
Et dans ma solution, je suis utiliser la réflexion de l'api de prendre un peu de changement à l'Écran de la classe!!
Je suis propre Écrans.les écrans avant de rappeler l'Écran.AllScreen.
```
typeof(Screen).GetField("screens", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic).SetValue(null, null);
//it is code for clean private field
```

Vous devez vous connecter pour publier un commentaire.