2009-08-22 28 views
65

¿Cómo averiguo el tamaño de todo el escritorio? No el "área de trabajo" y no la "resolución de pantalla", que se refieren a una sola pantalla. Quiero averiguar el ancho y alto total del escritorio virtual del cual cada monitor muestra solo una parte.C#: ¿Tiene el tamaño de escritorio completo?

+2

Tal vez el "tamaño de escritorio completo" dependerá de cómo estén colocadas las pantallas. No estoy seguro de cómo calcular eso, pero aún puede ver el número de pantallas y la resolución de cada pantalla con System.Windows.Forms.Screen.AllScreens. – Havenard

Respuesta

119

tiene dos opciones:

  1. PresentationFramework.dll

    SystemParameters.VirtualScreenWidth 
    SystemParameters.VirtualScreenHeight 
    
  2. Sistema.Windows.Forms.dll

    SystemInformation.VirtualScreen.Width 
    SystemInformation.VirtualScreen.Height 
    

Uso del primera opción si el desarrollo de una aplicación de WPF.

+0

¡Más respuestas como esta! Corto, correcto y estéticamente agradable! – Bitterblue

26

Creo que es hora de actualizar esta respuesta con un pequeño LINQ, que hace que sea fácil obtener todo el tamaño del escritorio con una sola expresión.

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

Mi respuesta original sigue:


Creo que lo que quiere es algo como esto:

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

Tenga en cuenta que esto no cuenta toda la historia. Es posible que varios monitores estén escalonados o dispuestos en una forma no rectangular. Por lo tanto, es posible que no todo el espacio entre (minx, miny) y (maxx, maxy) sea visible.

EDIT:

me he dado cuenta de que el código podría ser un poco más simple usando 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); 
+2

Soy programador ucraniano. Estoy verificando que este código funciona desde la caja. Solo copia y pega. –

5

Esto no responde a la pregunta, sino que simplemente permite incorporar más información sobre Punto de una ventana (ubicación) dentro de todas las pantallas).

Utilice el código siguiente para averiguar si un punto (por ejemplo, la última ubicación conocida de la ventana) se encuentra dentro de los límites del escritorio general. De lo contrario, restablezca la Ubicación de la ventana al valor predeterminado pBaseLoc;

El código no tiene en cuenta la barra de tareas u otras barras de herramientas, yer allí.

Ejemplo de uso: guarde la ubicación de la ventana en una base de datos de estación A. El usuario inicia sesión en estación B con 2 monitores y mueve la ventana al segundo monitor, cierra la sesión para guardar la nueva ubicación. Volver a estación A y la ventana no se mostrará a menos que se use el código anterior.

Mi mayor resolución implementada salvar el ID de usuario y la IP de la estación (& WINLOC) a la base de datos o preferencias del usuario locales para presentar una aplicación dada, entonces cargan en pref usuario para esa estación & aplicación.

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; 
+6

Si * sabes * que esto no responde la pregunta, ¿por qué lo publicas como respuesta a la pregunta? ¿No debería la primera oración haber sonado una alarma? – Timwi

+1

Por otro lado, esto es exactamente lo que estaba buscando cuando vine a buscar sobre este tema –

14

Comprobar:

SystemInformation.VirtualScreen.Width 
SystemInformation.VirtualScreen.Height 
0

Puede usar los límites de System.Drawing.

Puede crear una función como esta

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

y que se puede obtener la pantalla de uno, dos, etc., en una variable de la siguiente manera:

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

entonces se puede obtener de los límites de la pantalla:

System.Drawing.Rectangle screen1Bounds = screen1.Bounds; 

Con este código obtendrá todas las propiedades como Width , Height, etc.

0

Este método devuelve el rectángulo que contiene todos los límites de las pantallas mediante el uso de los valores más bajos de izquierda y superior, y los valores más altos de la derecha y abajo ...

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

Por favor explique un poco. –

+0

Pasa por todas las pantallas. Si el borde izquierdo es menor que la variable 'l', establece 'l' a este nuevo valor, si el borde inferior es mayor que 'b', entonces establece eso. El resultado final es l, t, r, b se establecen en los bordes izquierdo, superior, derecho e inferior de todo el escritorio visible. – dynamichael

0

Creo que la mejor manera de obtener el tamaño de pantalla "real" es obtener los valores directamente del controlador de 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); 
       } 
      } 
     } 
} 

Esto debería hacer el trabajo;) Saludos ...

4

Para obtener el tamaño de píxel físico del monitor se puede utilizar este.

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


} 
Cuestiones relacionadas