C#: ottieni dimensioni desktop complete?

Question

Come si trova la dimensione dell'intero desktop? Non la "zona di lavoro" e non la "risoluzione dello schermo", che si riferiscono entrambi a una sola schermata. Voglio scoprire la larghezza e l'altezza totali del desktop virtuale di cui ogni monitor mostra solo una parte.

Answer 1

si hanno due opzioni:

1. PresentationFramework.dll

   SystemParameters.VirtualScreenWidth 
   SystemParameters.VirtualScreenHeight 
   

2. Sistema.Windows.Forms.dll

   SystemInformation.VirtualScreen.Width 
   SystemInformation.VirtualScreen.Height 
   

Utilizzare la prima opzione di se lo sviluppo di un'applicazione WPF.

Answer 2

Penso che sia il momento di aggiornare questa risposta con un po 'di LINQ, che rende facile ottenere l'intera dimensione del desktop con una singola espressione.

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

La mia risposta originale segue:

---

Credo che ciò che si vuole è qualcosa di simile:

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

Tenete a mente che questo non racconta tutta la storia. È possibile che più monitor siano sfalsati o disposti in una forma non rettangolare. Pertanto, può essere che non tutto lo spazio tra (minx, miny) e (maxx, maxy) sia visibile.

EDIT:

Ho appena realizzato che il codice potrebbe essere un po 'più semplice utilizzando 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); 

Answer 3

Questo non risponde alla domanda, ma semplicemente aggiunge ulteriori indizi su Point di una finestra (posizione) all'interno di tutti gli schermi).

Utilizzare il codice seguente per scoprire se un punto (ad esempio l'ultima posizione nota della finestra) si trova all'interno dei limiti del desktop generale. In caso contrario, ripristinare la posizione della finestra sul valore predefinito pBaseLoc;

Il codice non tiene conto di TaskBar o di altre barre degli strumenti, proprio sul proprio.

Esempio di utilizzo: salvataggio della posizione della finestra in un database dalla stazione A. L'utente accede alla stazione B con 2 monitor e sposta la finestra sul 2o monitor, si scollega salvando la nuova posizione. Torna alla stazione A e la finestra non verrà visualizzata a meno che non si utilizzi il codice sopra riportato.

mio ulteriore determinazione implementato salvare l'ID utente e IP della stazione (& winLoc) a base di dati o preferenze di utenti locali di file per una determinata applicazione, poi vengono caricati in pref utente per quella stazione & 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; 

Answer 4

Check:

SystemInformation.VirtualScreen.Width 
SystemInformation.VirtualScreen.Height 

Answer 5

È possibile utilizzare i limiti di System.Drawing.

È possibile creare una funzione come questa

public System.Windows.Form.Screen[] GetScreens(){ 
    Screen[] screens = Screen.AllScreens; 
    return screens; 
} 

e di quanto si può ottenere la schermata di uno, due, ecc in una variabile come questo:

System.Windows.Form.Screen[] screens = func.GetScreens(); 
System.Windows.Form.Screen screen1 = screens[0]; 

quindi è possibile ottenere i limiti dello schermo:

System.Drawing.Rectangle screen1Bounds = screen1.Bounds; 

Con questo codice si ottengono tutte le proprietà come Width , Height, ecc

Answer 6

Questo metodo restituisce il rettangolo che contiene tutti i limiti schermi utilizzando i valori più bassi di sinistra e in alto e i valori più alti di destra e in basso ...

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

Answer 7

Penso che il modo migliore per ottenere la dimensione dello schermo "reale" sia ottenere i valori direttamente dal controller video.

---

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

---

Questo dovrebbe fare il lavoro;) Saluti ...

Answer 8

per ottenere la dimensione dei pixel fisica del monitor è possibile utilizzare questo.

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


}