सी #: पूरा डेस्कटॉप आकार प्राप्त करें?

Question

मैं पूरे डेस्कटॉप का आकार कैसे ढूंढूं? "कार्यक्षेत्र" और "स्क्रीन रिज़ॉल्यूशन" नहीं, दोनों जिनमें से केवल एक स्क्रीन का संदर्भ है। मैं आभासी डेस्कटॉप की कुल चौड़ाई और ऊंचाई को जानना चाहता हूं जिसमें से प्रत्येक मॉनिटर केवल एक हिस्सा दिखा रहा है।

Answer 1

आपके पास दो विकल्प:

1. PresentationFramework.dll

   SystemParameters.VirtualScreenWidth 
   SystemParameters.VirtualScreenHeight 
   

2. सिस्टम।Windows.Forms.dll

   SystemInformation.VirtualScreen.Width 
   SystemInformation.VirtualScreen.Height 
   

पहला विकल्प यदि आप एक WPF आवेदन को विकसित करने का प्रयोग करें।

Answer 2

मुझे लगता है कि यह उत्तर थोड़ा LINQ के साथ अद्यतित करने का समय है, जिससे पूरे डेस्कटॉप आकार को एक अभिव्यक्ति के साथ प्राप्त करना आसान हो जाता है।

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

मेरे मूल जवाब इस प्रकार है:

---

मुझे लगता है कि क्या आप चाहते हैं कुछ इस तरह है:

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

ध्यान रखें कि इस पूरी कहानी नहीं है। कई मॉनीटरों को घिरा होना संभव है, या एक nonrectangular आकार में व्यवस्थित किया जा सकता है। इसलिए, यह हो सकता है कि (minx, miny) और (maxx, maxy) के बीच की सभी जगह दिखाई दे।

संपादित करें:

मैं सिर्फ महसूस किया कि कोड थोड़ा सरल हो सकता है 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

इस सवाल का जवाब नहीं है, लेकिन केवल एक खिड़की प्वाइंट पर अतिरिक्त अंतर्दृष्टि कहते हैं (स्थान) सभी स्क्रीन के भीतर)।

यह पता लगाने के लिए नीचे दिए गए कोड का उपयोग करें कि क्या एक बिंदु (जैसे विंडो का अंतिम ज्ञात स्थान) समग्र डेस्कटॉप की सीमाओं के भीतर है। यदि नहीं, तो विंडो के स्थान को डिफ़ॉल्ट पर रीसेट करें pBaseLoc;

कोड टास्कबार या अन्य टूलबार के लिए खाता नहीं है, यार वहां पर है।

उदाहरण का उपयोग करें: स्टेशन ए से डेटाबेस में विंडो स्थान सहेजें। उपयोगकर्ता स्टेशन बी में 2 मॉनीटर के साथ लॉग करता है और विंडो को दूसरी मॉनीटर पर ले जाता है, नए स्थान को सहेजने के लिए लॉग आउट करता है। स्टेशन ए पर वापस और जब तक उपरोक्त कोड का उपयोग नहीं किया जाता तब तक विंडो दिखाई नहीं देगी।

मेरे आगे संकल्प बचत userID और डेटाबेस या स्थानीय उपयोगकर्ता वरीयता करने के लिए स्टेशन के आईपी (& winLoc) किसी दिए गए एप्लिकेशन के लिए फ़ाइल है, तो उस स्टेशन & अनुप्रयोग के लिए उपयोगकर्ता वरी में लोड लागू किया।

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

की जांच:

SystemInformation.VirtualScreen.Width 
SystemInformation.VirtualScreen.Height 

Answer 5

आप System.Drawing की सीमा का उपयोग कर सकते हैं।

आप इस

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

की तरह एक समारोह बना सकते हैं और कर सकते हैं की तुलना में आप इस तरह एक चर में स्क्रीन एक, दो, आदि प्राप्त कर सकते हैं:

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

सीमा तो आप प्राप्त कर सकते हैं स्क्रीन के:

System.Drawing.Rectangle screen1Bounds = screen1.Bounds; 

इस कोड के साथ आप Width की तरह सभी गुण मिल जाएगा , Height, आदि

Answer 6

इस विधि आयत कि वामपंथियों और ऊपर, के लिए निम्नतम मान और सही और नीचे के लिए उच्चतम मान का उपयोग करके स्क्रीन 'सीमा से सभी शामिल हैं रिटर्न ...

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

मुझे लगता है कि "वास्तविक" स्क्रीन आकार प्राप्त करने का सबसे अच्छा तरीका है, सीधे वीडियो नियंत्रक से मूल्य प्राप्त करना।

---

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

---

यह काम करना चाहिए;) अभिवादन ...

Answer 8

मॉनिटर आप इस का उपयोग कर सकते की शारीरिक पिक्सेल आकार पाने के लिए।

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


}