una - C#: obtener el tamaño de escritorio completo?

que pc comprar 2018

Question

¿Cómo averiguo el tamaño de todo el escritorio? No es 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.

Answer 1

Comprobar:

SystemInformation.VirtualScreen.Width
SystemInformation.VirtualScreen.Height

Answer 2

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:

Supongo que lo que quieres 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.

EDITAR:

Me acabo de dar 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);

Answer 3

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 ...

Answer 4

Este método devuelve el rectángulo que contiene todos los límites de las pantallas utilizando los valores más bajos para Izquierda y Superior, y los valores más altos para Derecha e Inferior ...

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 5

Esto no responde a la pregunta, sino que simplemente agrega información adicional sobre el Punto (ubicación) de una ventana dentro de todas las pantallas.

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

El código no tiene en cuenta la barra de tareas u otras barras de herramientas, estás ahí.

Ejemplo de uso: guarde la ubicación de la ventana en una base de datos desde la estación A. El usuario inicia sesión en la 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 la estación A y la ventana no se mostrarán a menos que se use el código anterior.

Mi resolución adicional implementó guardar el ID de usuario y la IP de la estación (& winLoc) en la base de datos o el archivo de preferencias locales del usuario para una aplicación determinada, luego cargar el prefijo del usuario para esa estación y 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;

Answer 6

Para obtener el tamaño de píxel físico del monitor, puede usar esto.

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


}

Answer 7

Puede usar los límites del sistema. System.Drawing .

Puedes crear una función como esta

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

y que puede obtener la pantalla uno, dos, etc. en una variable como esta:

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

entonces puedes obtener los límites de la pantalla:

System.Drawing.Rectangle screen1Bounds = screen1.Bounds;

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

Answer 8

Tienes dos opciones:

1. PresentationFramework.dll

   SystemParameters.VirtualScreenWidth   
   SystemParameters.VirtualScreenHeight

2. System.Windows.Forms.dll

   SystemInformation.VirtualScreen.Width   
   SystemInformation.VirtualScreen.Height

Utilice la primera opción si desarrolla una aplicación WPF.