A kijelző méretéhez a következőt kell használnia: Screen .PrimaryScreen.Bounds.Size (vagy Screen.GetBounds(myform)).

Ha DPI-t szeretne, használja a DpiX és DpiY tulajdonságai http://msdn.microsoft.com/en-us/library/system.drawing.graphics.aspx" rel="noreferrer">Grafika:

PointF dpi = PointF.Empty;
using(Graphics g = this.CreateGraphics()){
    dpi.X = g.DpiX;
    dpi.Y = g.DpiY;
}

Ó várj! Azt akartad, hogy valódi, tarts egy vonalzót a monitorhoz, és mérj, méretet?! Nem. Nem lehetséges bármely operációs rendszer szolgáltatás használatával. Az operációs rendszer nem ismeri a monitor tényleges méreteit, sem azt, hogy a felhasználó hogyan kalibrálta. Ezen információk egy része elméletileg kimutatható, de nem elég determinisztikus ahhoz, hogy az operációs rendszer megbízhatóan használja, ezért nem.

Kerülendő megoldásként kipróbálhat néhány dolgot.

• Megpróbálhatja lekérdezni a telepített monitor eszköz megjelenítési karakterláncát (nem tudom, hogyan kell ezt megtenni), és megnézheti, hogy abból ki lehet-e elemezni egy értelmes méretet. Például lehet, hogy a monitor egy "ValueBin E17p", és ebből lehet kikövetkeztetni, hogy 17"-es monitor. Természetesen ez a megjelenítési karakterlánc valószínűleg "Plug and Play Monitor". Ez a séma a legjobb esetben is meglehetősen vázlatos.
• Megkérdezheti a felhasználót, hogy milyen méretű monitorral rendelkezik. Talán tudni fogják.

Ha már ismeri (vagy gondolja), hogy ismeri a monitor átlójának méretét, meg kell találnia a fizikai képarányát. Még egyszer, egy-két dolog:

• Tegyük fel, hogy az aktuális képpont-arány megegyezik a monitor fizikai képarányával. Ez azt feltételezi, hogy (A) a felhasználó olyan felbontást választott, amely ideális a monitorjához, és (B) a monitor négyzetes pixelekkel rendelkezik. Nem tudok olyan jelenlegi fogyasztó-orientált számítógép-monitorról, amiben ne lenne négyzetes pixel, de a régebbieken igen, az újabbakon viszont igen.
• Kérdezze meg a felhasználót. Talán tudni fogják.

Ha ismeri (vagy gondolja, tudja), hogy mekkora a monitor átlós mérete és fizikai képaránya, akkor kiszámíthatja a fizikai szélességét és magasságát. A² + B² = C², így néhány számítással jó lesz:

Ha rájött, hogy ez egy 17 hüvelykes monitor, és a jelenlegi felbontása 1280 x 1024:
1280² + 1024² = 2686976
Sqrt(2686976 ) = 1639.1998047828092637409837247032
17" * 1280 / 1639.2 = 13.274768179599804782820888238165" *9 = 138165" *9 = 13,9" *9 = 13,9" *9 = 13,9" 14543679843826256710590532"

Ezzel a fizikai szélesség 13,27 hüvelyk, a fizikai magasság pedig 10,62 hüvelyk. Így a pixelek mérete 13,27" / 1280 = 10,62" / 1024 = 0,01037" vagy körülbelül 0,263 mm.

Természetesen mindez érvénytelen, ha a felhasználó nem rendelkezik megfelelő felbontással, a monitor nem négyzet alakú pixelekkel rendelkezik, vagy régebbi analóg monitorról van szó, és a kezelőszervek nincsenek megfelelően beállítva, hogy a kijelző kitöltse a teljes fizikai területet. képernyő. Vagy ami még rosszabb, lehet projektor is.

Végül talán a legjobb, ha egy kalibrálási lépést hajt végre, ahol a felhasználó valójában a képernyőhöz tart egy vonalzót, és megméri valami méretét. Te tudnál:

• Kérje meg a felhasználót, hogy kattintson az egérrel bármelyik két, egymástól hüvelyknyi (vagy centiméteres) pontra.
• Rajzoljon egy négyzetet a képernyőre, és kérje meg a felhasználót, hogy a fel és le nyilak megnyomásával állítsa be a magasságát, a bal és jobb nyilat pedig a szélességének beállításához, amíg a doboz pontosan egy hüvelykes (vagy centiméteres) négyzet lesz a vonalzójuk szerint.
• Rajzoljon egy dobozt a képernyőre, és kérje meg a felhasználót, hogy mondja meg, hány hüvelyk/centiméter az egyes dimenziókban.

Bármit csinál is, ne várja el, hogy az eredmények 100%-ban pontosak legyenek. Túl sok tényező játszik szerepet az Ön (vagy a felhasználó) számára ahhoz, hogy ez minden alkalommal pontosan helyes legyen.

Ne feledje, hogy a 96 dpi általában elég közel van a pontossághoz. A nem vetített képernyőkön a modern pixelek általában körülbelül 0,25 mm-esek, adok vagy vesznek, így általában körülbelül 100 fizikai pixel hüvelykenként, adj vagy veszel, ha a monitor a megfelelőre van állítva. natív felbontás. (Természetesen ez egy hatalmas általánosítás, és nem vonatkozik minden monitorra. Az Eee PC-k például körülbelül 0,19 mm-es pixelekkel rendelkeznek, ha jól emlékszem a specifikációkra.)

elnézést, ehhez az információért a P/Invoke-hoz kell fordulnia.

Íme a link, amelyet egy ideje használtam hozzá: http://www.davidthielen.info/programming/2007/05/get_screen_dpi_.html

Ezt úgy ellenőrizheti, hogy manuálisan kiszámolja a képernyő méretét

cos(45)*LCD_SCREEN_DIAGONAL_IN_INCHES/sqrt(HORZ_RES^2 + VERT_RES^2)

Ez megadná a pixelszélességet hüvelykben

A GetDeviceCaps P/Invoke-ozható szerezz néhány számot, de soha nem tudtam, hogy ennyire megbízhatóak lennének...

A kijelző fizikai méreteit a rendszerleíró adatbázisban tárolt EDID információk segítségével szerezheti meg. A megfelelő monitor rendszerleíró kulcsát az EnumDisplayDevices windows API-hívás segítségével szerezheti be.

A képernyőobjektum fizikai méretei :

TL;DR

A WPF valódi mérete = pixel * DPI nagyítás

DPI nagyítás:

Matrix dpiMagnification
= PresentationSource.FromVisual(MyUserControl).CompositionTarget.TransformToDevice;
double magnificationX = dpiMagnification.M11;
double magnificationY = dpiMagnification.M22;

Vita

Még 2020-ban is gondjaim voltak ennek a kérdésnek a megoldásával. Amikor 2009-ben feltették/válaszolták ezt a kérdést, a .NET C# valószínűleg a Windows Forms-ot jelentette. De a WPF a mai de facto etalon...

A "valódi méret" kérdésével valószínűleg már rájött, hogy az operációs rendszer a tényleges pixelekkel (mondjuk 1366x768-mal, amiről tudomásom szerint a szokásos laptopfelbontások) és a DPI-vel (nehéz megtalálni) végez számításokat, hogy megadja a vezérlés valódi értékét. méret. És olyan alkalmazást próbál létrehozni, amely különböző monitorokra skálázható.

Ez a tényleges DPI-szám rejtettnek tűnik, de normalizálták (százalékra konvertálták). Tegyük fel, hogy 100% = 96 DPI, csak azért, mert a tényleges szám már nem számít. Az emberek egyszerűen növelhetik a rendszerszintű szövegméretet, ha a Windows 10 rendszeren az Asztal elemet választják, majd jobb gombbal kattintanak > Megjelenítési beállítások > Méretezés és elrendezés szakasz > módosítják a szöveg és egyéb elemek nagyításának százalékos arányát.

A pixeleket más módon is megkeresheti, és a pixelt többszörözheti/oszthatja a DPI-százalékkal, hogy megkapja a valódi méretet. Például egy UserControl-t szeretnék egy WPF-ablak vászoneleme köré húzni az egérrel. A felhasználói vezérlő pixelszámát és az egér xy-koordinátáit kikapcsolta a normalizált DPI. Annak érdekében, hogy az egér a felhasználói vezérlővel azonos sebességgel mozogjon, a következőket használom:

double newXCoord = System.Windows.Forms.Cursor.Position.X;
double newYCoord = System.Windows.Forms.Cursor.Position.Y;
double deltaX = newXCoord - oldXCoord;
double deltaY = newYCoord - oldYCoord;

double magnificationX = 1;
double magnificationY = 1;
Matrix dpiMagnification
= PresentationSource.FromVisual(visual).CompositionTarget.TransformToDevice;
if (magnificationMatrix != null)
{
    magnificationX = dpiMagnification.M11;
    magnificationY = dpiMagnification.M22;
}
PixelsFromLeft += deltaX / m_magnificationX;
PixelsFromTop += deltaY / m_magnificationY;