C #: Erhalten Sie die vollständige Desktopgröße.

Ich denke, es ist an der Zeit, diese Antwort mit einem kleinen LINQ auf den neuesten Stand zu bringen, wodurch es einfach wird, die gesamte Desktopgröße mit einem einzigen Ausdruck zu erhalten.

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

Meine ursprüngliche Antwort lautet:

Ich denke, was Sie wollen, ist etwa so:

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

Denken Sie daran, dass dies nicht die ganze Geschichte erzählt. Es ist möglich, dass mehrere Monitore versetzt oder in einer nicht rechteckigen Form angeordnet sind. Daher ist es möglich, dass nicht alle Abstände zwischen (minx, miny) und (maxx, maxy) sichtbar sind.

BEARBEITEN:

Ich habe gerade festgestellt, dass der Code mit Rectangle.Union etwas einfacher sein könnte:

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

Prüfen:

SystemInformation.VirtualScreen.Width
SystemInformation.VirtualScreen.Height

Um die physikalische Pixelgröße des Monitors zu ermitteln, können Sie dies verwenden.

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


}

Dies beantwortet die Frage nicht, sondern fügt lediglich einen zusätzlichen Einblick in den Punkt (Position) eines Fensters in allen Bildschirmen hinzu.

Verwenden Sie den nachstehenden Code, um herauszufinden, ob ein Punkt (z. B. der zuletzt bekannte Ort des Fensters) innerhalb der Grenzen des gesamten Desktops liegt. Wenn nicht, setzen Sie den Standort des Fensters auf den Standardwert zurück pBaseLoc ;

Der Code berücksichtigt nicht die Taskleiste oder andere Symbolleisten, da Sie selbst dort besitzen.

Anwendungsbeispiel: Speichern Sie die Position des Fensters in einer Datenbank von Station A . Der Benutzer meldet sich an Station B mit 2 Monitoren an und bewegt das Fenster zum 2. Monitor, meldet den neuen Standort ab. Zurück zu Station A und das Fenster würde nur angezeigt, wenn der oben genannte Code verwendet wird.

Bei meiner weiteren Lösung wurde das Speichern der Benutzer-ID und der IP-Adresse (& winLoc) der Station in einer Datenbank oder in einer lokalen Benutzer-Voreinstellungsdatei für eine bestimmte App implementiert.

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;

Sie können die Begrenzungen von System.Drawing verwenden.

Sie können eine Funktion wie diese erstellen

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

und dann können Sie den Bildschirm eins, zwei usw. in einer Variablen wie dieser erhalten:

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

dann können Sie die Grenzen des Bildschirms erhalten:

System.Drawing.Rectangle screen1Bounds = screen1.Bounds;

Mit diesem Code erhalten Sie alle Eigenschaften wie Width, Height usw.

Diese Methode gibt das Rechteck zurück, das alle Begrenzungen der Bildschirme enthält, indem die niedrigsten Werte für Left und Top und die höchsten Werte für Right und Bottom verwendet werden.

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

Ich denke, der beste Weg, die "echte" Bildschirmgröße zu erhalten, besteht darin, die Werte direkt vom Video-Controller abzurufen.

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

Das sollte den Job erledigen;) Grüße ...

Holen Sie sich die Size einer virtuellen Anzeige ohne Abhängigkeiten

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