C#: Obtenir la taille du bureau?

Comment puis-je savoir la taille de l'ensemble du bureau? Pas la "zone de travail" et pas la "résolution d'écran", qui se réfèrent à un seul écran. Je veux savoir le total de la largeur et de la hauteur du bureau virtuel de laquelle chaque moniteur est en ne montrant qu'une partie.

Peut-être que le "bureau complet taille" dépendra de la façon dont les écrans sont positionnés. Vous ne savez pas comment calculer que, mais vous pouvez toujours attraper le nombre d'écrans et de la résolution de chaque écran avec le Système.De Windows.Les formulaires.De l'écran.AllScreens.

InformationsquelleAutor Timwi | 2009-08-22

.net c#desktop screen screen-resolution

127

Vous avez deux options:
1. PresentationFramework.dll
```
SystemParameters.VirtualScreenWidth   
SystemParameters.VirtualScreenHeight
```
2. System.Windows.Forms.dll
```
SystemInformation.VirtualScreen.Width   
SystemInformation.VirtualScreen.Height
```
Utiliser le première option si vous développer une application WPF.
- Plus de réponses de ce genre! Bref, correct et esthétique!
InformationsquelleAutor Dennis

Je pense qu'il est temps d'apporter cette réponse jusqu'à ce jour, avec un peu de LINQ, ce qui le rend facile d'obtenir la totalité de la taille du bureau avec une seule expression.

Console.WriteLine(
    Screen.AllScreens.Select(screen=>screen.Bounds)
    .Aggregate(Rectangle.Union)
    .Size
);

Ma réponse originale à cette question suit:

Je suppose que ce que vous voulez, c'est quelque chose comme ceci:

int minx, miny, maxx, maxy;
minx = miny = int.MaxValue;
maxx = maxy = int.MinValue;

foreach(Screen screen in Screen.AllScreens){
    var bounds = screen.Bounds;
    minx = Math.Min(minx, bounds.X);
    miny = Math.Min(miny, bounds.Y);
    maxx = Math.Max(maxx, bounds.Right);
    maxy = Math.Max(maxy, bounds.Bottom);
}

Console.WriteLine("(width, height) = ({0}, {1})", maxx - minx, maxy - miny);

Garder à l'esprit que ce n'est pas raconter toute l'histoire. Il est possible pour plusieurs moniteurs à être décalés, ou disposés dans une forme non rectangulaire. Par conséquent, il peut être que la totalité de l'espace entre (minx, miny) et (maxx, maxy) est visible.

EDIT:

Je viens de réaliser que le code pourrait être un peu plus simple à l'aide de Rectangle.Union:

Rectangle rect = new Rectangle(int.MaxValue, int.MaxValue, int.MinValue, int.MinValue);

foreach(Screen screen in Screen.AllScreens)
    rect = Rectangle.Union(rect, screen.Bounds);

Console.WriteLine("(width, height) = ({0}, {1})", rect.Width, rect.Height);

Je suis ukrainienne programmeur. Je suis à vérifier que ce code fonctionne à partir de la boîte. Il suffit de copier et coller.

InformationsquelleAutor P Daddy

Vérifier:

SystemInformation.VirtualScreen.Width
SystemInformation.VirtualScreen.Height

InformationsquelleAutor chris LB

Pour obtenir le physique de taille de pixel de l'écran vous pouvez utiliser cette.

static class DisplayTools
{
    [DllImport("gdi32.dll")]
    static extern int GetDeviceCaps(IntPtr hdc, int nIndex);

    private enum DeviceCap
    {
        Desktopvertres = 117,
        Desktophorzres = 118
    }

    public static Size GetPhysicalDisplaySize()
    {
        Graphics g = Graphics.FromHwnd(IntPtr.Zero);
        IntPtr desktop = g.GetHdc();

        int physicalScreenHeight = GetDeviceCaps(desktop, (int)DeviceCap.Desktopvertres);
        int physicalScreenWidth = GetDeviceCaps(desktop, (int)DeviceCap.Desktophorzres);

        return new Size(physicalScreenWidth, physicalScreenHeight);
    }


}

InformationsquelleAutor Andreas

6

Cela ne veut pas répondre à la question, mais simplement ajoute des informations supplémentaires sur une fenêtre du Point (emplacement) dans tous les écrans).

Utiliser le code ci-dessous pour savoir si un Point (par exemple, le dernier Emplacement connu de la fenêtre) est dans les limites de l'ensemble du Bureau. Si pas, réinitialiser la fenêtre de l'Emplacement par défaut pBaseLoc;

Code ne tient pas compte de la barre des tâches ou d'autres Barres d'outils, yer sur yer propre il.

Exemple d'Utilisation: Enregistrer la Fenêtre à l'emplacement d'une base de données à partir de de la station de. Utilisateur se connecte à station B avec 2 moniteurs et déplace la fenêtre vers le 2ème moniteur, les journaux à sauver nouvel emplacement. Retour à de la station de et la fenêtre n'apparaît pas, à moins que le code ci-dessus est utilisé.

Me résoudre mise en œuvre d'enregistrer le nom d'utilisateur et IP de la station (& winLoc) à la base de données d'utilisateurs locaux ou fichiers de préférence pour une application donnée, puis les charger dans user pref pour la station & app.
```
Point pBaseLoc = new Point(40, 40)
int x = -500, y = 140;
Point pLoc = new Point(x, y);
bool bIsInsideBounds = false;

foreach (Screen s in Screen.AllScreens)
{
    bIsInsideBounds = s.Bounds.Contains(pLoc);
    if (bIsInsideBounds) { break; }
}//foreach (Screen s in Screen.AllScreens)

if (!bIsInsideBounds) { pLoc = pBaseLoc;  }

this.Location = pLoc;
```
- Si vous savoir que ceci ne répond pas à la question, pourquoi êtes-vous afficher comme une réponse à la question? Ne devrait pas la première phrase, de faire sonner une cloche d'alarme?
- Sur cette autre part, c'est exactement ce que je cherchais quand je suis à la recherche sur ce sujet
InformationsquelleAutor TechStuffBC
1

Vous pouvez utiliser les Limites de System.Drawing.

Vous pouvez créer une fonction comme ceci
```
public System.Windows.Form.Screen[] GetScreens(){
    Screen[] screens = Screen.AllScreens;
    return screens;
}
```
et que vous pouvez obtenir à l'écran un, deux, etc. dans une variable comme ceci:
```
System.Windows.Form.Screen[] screens = func.GetScreens();
System.Windows.Form.Screen screen1 = screens[0];
```
ensuite, vous pouvez obtenir les limites de l'écran:
```
System.Drawing.Rectangle screen1Bounds = screen1.Bounds;
```
Avec ce code, vous obtiendrez toutes les propriétés comme Width, Height, etc.

InformationsquelleAutor JD - DC TECH

Je pense que la meilleure façon d'obtenir la "vraie" taille de l'écran, c'est d'obtenir directement les valeurs de la vidéo-contrôleur.

    using System;
    using System.Management;
    using System.Windows.Forms;

    namespace MOS
    {
        public class ClassMOS
        {
            public static void Main()
            {
                try
                {
                    ManagementObjectSearcher searcher = 
                        new ManagementObjectSearcher("root\\CIMV2", 
                        "SELECT * FROM Win32_VideoController"); 

                    foreach (ManagementObject queryObj in searcher.Get())
                    {
                        Console.WriteLine("CurrentHorizontalResolution: {0}", queryObj["CurrentHorizontalResolution"]);
                        Console.WriteLine("-----------------------------------");
                        Console.WriteLine("CurrentVerticalResolution: {0}", queryObj["CurrentVerticalResolution"]);
                    }
                }
                catch (ManagementException e)
                {
                    MessageBox.Show("An error occurred while querying for WMI data: " + e.Message);
                }
            }
        }
}

Cela devrait faire l'affaire 😉
Salutations ...

InformationsquelleAutor core.tweaks

Cette méthode retourne le rectangle qui contient tous les écrans' limites en utilisant les valeurs les plus faibles pour en Haut et à Gauche, et les valeurs les plus élevées pour la Droite et en Bas...

static Rectangle GetDesktopBounds() {
   var l = int.MaxValue;
   var t = int.MaxValue;
   var r = int.MinValue;
   var b = int.MinValue;
   foreach(var screen in Screen.AllScreens) {
      if(screen.Bounds.Left   < l) l = screen.Bounds.Left  ;
      if(screen.Bounds.Top    < t) t = screen.Bounds.Top   ;
      if(screen.Bounds.Right  > r) r = screen.Bounds.Right ;
      if(screen.Bounds.Bottom > b) b = screen.Bounds.Bottom;
   }
   return Rectangle.FromLTRB(l, t, r, b);
}

Veuillez expliquer un peu.
Il parcourt tous les écrans. Si le côté gauche est inférieure à celui de la variable " l "elle définit des" l " à cette nouvelle valeur, si le bord inférieur est plus grand que 'b' elle définit ensuite que. Le résultat final est l, t, r, b sont à gauche, en haut, à droite, et en bas de votre bureau.

InformationsquelleAutor dynamichael

Obtenir le Taille d'un affichage virtuel, sans dépendances

public enum SystemMetric
{
    VirtualScreenWidth = 78, //CXVIRTUALSCREEN 0x0000004E 
    VirtualScreenHeight = 79, //CYVIRTUALSCREEN 0x0000004F 
}

[DllImport("user32.dll")]
public static extern int GetSystemMetrics(SystemMetric metric);

public static Size GetVirtualDisplaySize()
{
    var width = GetSystemMetrics(SystemMetric.VirtualScreenWidth);
    var height = GetSystemMetrics(SystemMetric.VirtualScreenHeight);

    return new Size(width, height);
}

InformationsquelleAutor Konstantin S.

Vous devez vous connecter pour publier un commentaire.