MONITOR Archives - icodebroker

[C#/WPF] Screen 클래스 : AllScreens 정적 속성을 사용해 듀얼 모니터 전체 화면 윈도우 표시하기

■ Screen 클래스의 AllScreens 정적 속성을 사용해 듀얼 모니터에서 전체 화면 윈도우를 표시하는 방법을 보여준다. ▶ MainWindow.xaml


<Window x:Class="TestProject.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Width="800"
    Height="600"
    Title="Screen 클래스 : AllScreens 정적 속성을 사용해 듀얼 모니터 전체 화면 윈도우 표시하기"
    FontFamily="나눔고딕코딩"
    FontSize="16">
    <Grid>
        <Ellipse
            Margin="50"
            Fill="Blue" />
    </Grid>
</Window>

<Window x:Class="TestProject.MainWindow"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Width="800"

Height="600"

Title="Screen 클래스 : AllScreens 정적 속성을 사용해 듀얼 모니터 전체 화면 윈도우 표시하기"

FontFamily="나눔고딕코딩"

FontSize="16">

<Grid>

<Ellipse

Margin="50"

Fill="Blue" />

</Grid>

</Window>

▶ MainWindow.xaml.cs


using System.Drawing;
using System.Windows;
using System.Windows.Forms;

namespace TestProject
{
    /// <summary>
    /// 메인 윈도우
    /// </summary>
    public partial class MainWindow : Window
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainWindow()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainWindow()
        {
            InitializeComponent();

            Loaded += Window_Loaded;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 윈도우 로드시 처리하기 - Window_Loaded(sender, e)

        /// <summary>
        /// 윈도우 로드시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            if(Screen.AllScreens.Length > 1)
            {
                Rectangle totalRectangle = Rectangle.Empty;

                foreach(Screen screen in Screen.AllScreens)
                {
                    totalRectangle = Rectangle.Union(totalRectangle, screen.Bounds);
                }

                Width  = totalRectangle.Width;
                Height = totalRectangle.Height;
                Left   = totalRectangle.Left;
                Top    = totalRectangle.Top;
            }
        }

        #endregion
    }
}

using System.Drawing;

using System.Windows;

using System.Windows.Forms;

namespace TestProject

{

/// <summary>

/// 메인 윈도우

/// </summary>

public partial class MainWindow : Window

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainWindow()

/// <summary>

/// 생성자

/// </summary>

public MainWindow()

{

InitializeComponent();

Loaded += Window_Loaded;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 윈도우 로드시 처리하기 - Window_Loaded(sender, e)

/// <summary>

/// 윈도우 로드시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void Window_Loaded(object sender, RoutedEventArgs e)

{

if(Screen.AllScreens.Length > 1)

{

Rectangle totalRectangle = Rectangle.Empty;

foreach(Screen screen in Screen.AllScreens)

{

totalRectangle = Rectangle.Union(totalRectangle, screen.Bounds);

}

Width = totalRectangle.Width;

Height = totalRectangle.Height;

Left = totalRectangle.Left;

Top = totalRectangle.Top;

}

#endregion

}

※

[C#/WPF] 모니터 추가/제거시 이벤트 처리하기

■ 모니터 추가/제거시 이벤트를 처리하는 방법을 보여준다. ▶ MainWindow.xaml


<Window x:Class="TestProject.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Width="800"
    Height="600"
    Title="모니터 추가/제거시 이벤트 처리하기"
    FontFamily="나눔고딕코딩"
    FontSize="16">
    <Grid>
        <ListBox Name="listBox"
            Width="300"
            Height="200" />
    </Grid>
</Window>

<Window x:Class="TestProject.MainWindow"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Width="800"

Height="600"

Title="모니터 추가/제거시 이벤트 처리하기"

FontFamily="나눔고딕코딩"

FontSize="16">

<Grid>

<ListBox Name="listBox"

Width="300"

Height="200" />

</Grid>

</Window>

▶ MainWindow.xaml.cs


using System;
using System.Windows;
using System.Windows.Interop;

namespace TestProject
{
    /// <summary>
    /// 메인 윈도우
    /// </summary>
    public partial class MainWindow : Window
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// WM_DISPLAYCHANGE
        /// </summary>
        private const uint WM_DISPLAYCHANGE = 0x007e;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainWindow()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainWindow()
        {
            InitializeComponent();
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Protected

        #region 소스 초기화시 처리하기 - OnSourceInitialized(e)

        /// <summary>
        /// 소스 초기화시 처리하기
        /// </summary>
        /// <param name="e">이벤트 인자</param>
        protected override void OnSourceInitialized(EventArgs e)
        {
            base.OnSourceInitialized(e);

            HwndSource hwndSource = PresentationSource.FromVisual(this) as HwndSource;

            hwndSource.AddHook(WndProc);
        }

        #endregion

        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 윈도우 프로시저 처리하기 - WndProc(windowHandle, message, wordParameter, longParameter, handled)

        /// <summary>
        /// 윈도우 프로시저 처리하기
        /// </summary>
        /// <param name="windowHandle">윈도우 핸들</param>
        /// <param name="message">메시지</param>
        /// <param name="wordParameter">WORD 매개 변수</param>
        /// <param name="longParameter">LONG 매개 변수</param>
        /// <param name="handled">처리 여부</param>
        /// <returns>처리 결과</returns>
        private IntPtr WndProc(IntPtr windowHandle, int message, IntPtr wordParameter, IntPtr longParameter, ref bool handled)
        {
            if(message == WM_DISPLAYCHANGE)
            {
                int value1 = wordParameter.ToInt32();
                int value2 = longParameter.ToInt32();

                int  bitCountPerPixel = value1;
                uint width            = (uint)(value2 & 0xffff);
                uint height           = (uint)(value2 >> 16);

                this.listBox.Items.Add($"WM_DISPLAYCHANGE : {bitCountPerPixel}, {width}×{height}");
            }

            return IntPtr.Zero;
        }

        #endregion
    }
}

using System;

using System.Windows;

using System.Windows.Interop;

namespace TestProject

{

/// <summary>

/// 메인 윈도우

/// </summary>

public partial class MainWindow : Window

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// WM_DISPLAYCHANGE

/// </summary>

private const uint WM_DISPLAYCHANGE = 0x007e;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainWindow()

/// <summary>

/// 생성자

/// </summary>

public MainWindow()

{

InitializeComponent();

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Protected

#region 소스 초기화시 처리하기 - OnSourceInitialized(e)

/// <summary>

/// 소스 초기화시 처리하기

/// </summary>

/// <param name="e">이벤트 인자</param>

protected override void OnSourceInitialized(EventArgs e)

{

base.OnSourceInitialized(e);

HwndSource hwndSource = PresentationSource.FromVisual(this) as HwndSource;

hwndSource.AddHook(WndProc);

}

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 윈도우 프로시저 처리하기 - WndProc(windowHandle, message, wordParameter, longParameter, handled)

/// <summary>

/// 윈도우 프로시저 처리하기

/// </summary>

/// <param name="windowHandle">윈도우 핸들</param>

/// <param name="message">메시지</param>

/// <param name="wordParameter">WORD 매개 변수</param>

/// <param name="longParameter">LONG 매개 변수</param>

/// <param name="handled">처리 여부</param>

/// <returns>처리 결과</returns>

private IntPtr WndProc(IntPtr windowHandle, int message, IntPtr wordParameter, IntPtr longParameter, ref bool handled)

{

if(message == WM_DISPLAYCHANGE)

{

int value1 = wordParameter.ToInt32();

int value2 = longParameter.ToInt32();

int bitCountPerPixel = value1;

uint width = (uint)(value2 & 0xffff);

uint height = (uint)(value2 >> 16);

this.listBox.Items.Add($"WM_DISPLAYCHANGE : {bitCountPerPixel}, {width}×{height}");

}

return IntPtr.Zero;

}

#endregion

}

TestProject.zip

[C#/COMMON] 연결된 모니터 수 구하기

■ 연결된 모니터 수를 구하는 방법을 보여준다. ▶ ScreenHelper.cs


using System;
using System.Runtime.InteropServices;

namespace TestProject
{
    public static class ScreenHelper
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Structure
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 사각형 - RECTANGLE

        /// <summary>
        /// 사각형
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        private struct RECTANGLE
        {
            //////////////////////////////////////////////////////////////////////////////////////////////////// Field
            ////////////////////////////////////////////////////////////////////////////////////////// Public

            #region Field

            /// <summary>
            /// 왼쪽
            /// </summary>
            public int Left;

            /// <summary>
            /// 위쪽
            /// </summary>
            public int Top;

            /// <summary>
            /// 오른쪽
            /// </summary>
            public int Right;

            /// <summary>
            /// 아래쪽
            /// </summary>
            public int Bottom;

            #endregion
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Delegate
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 모니터 열거 프로시저 - MonitorEnumProc(desktopHandle, deviceContextHandle, rectangle, data)

        /// <summary>
        /// 모니터 열거 프로시저
        /// </summary>
        /// <param name="desktopHandle">데스크톱 핸들</param>
        /// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>
        /// <param name="rectangle">사각형</param>
        /// <param name="data">데이터</param>
        private delegate void MonitorEnumProc
        (
            IntPtr        desktopHandle,
            IntPtr        deviceContextHandle,
            ref RECTANGLE rectangle,
            int           data
        );

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Import
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 디스플레이 모니터 열거하기 - EnumDisplayMonitors(deviceContextHandle, rectangleHandle, callback, data)

        /// <summary>
        /// 디스플레이 모니터 열거하기
        /// </summary>
        /// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>
        /// <param name="rectangleHandle">사각형 핸들</param>
        /// <param name="callback">콜백</param>
        /// <param name="data">데이터</param>
        /// <returns>처리 결과</returns>
        [DllImport("user32.dll")]
        private static extern bool EnumDisplayMonitors
        (
            IntPtr          deviceContextHandle,
            IntPtr          rectangleHandle,
            MonitorEnumProc callback,
            int             data
        );

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 모니터 카운트 구하기 - GetMonitorCount()

        /// <summary>
        /// 모니터 카운트 구하기
        /// </summary>
        /// <returns>모니터 카운트</returns>
        public static int GetMonitorCount()
        {
            int monitorCount = 0;

            MonitorEnumProc callback = (IntPtr desktopHandle, IntPtr deviceContextHandle, ref RECTANGLE rectangle, int data) => ++monitorCount;

            if(EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, callback, 0))
            {
                return monitorCount;
            }
            else
            {
                return -1;
            }
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

using System;

using System.Runtime.InteropServices;

namespace TestProject

{

public static class ScreenHelper

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Structure

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 사각형 - RECTANGLE

/// <summary>

/// 사각형

/// </summary>

[StructLayout(LayoutKind.Sequential)]

private struct RECTANGLE

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Public

#region Field

/// <summary>

/// 왼쪽

/// </summary>

public int Left;

/// <summary>

/// 위쪽

/// </summary>

public int Top;

/// <summary>

/// 오른쪽

/// </summary>

public int Right;

/// <summary>

/// 아래쪽

/// </summary>

public int Bottom;

#endregion

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Delegate

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 모니터 열거 프로시저 - MonitorEnumProc(desktopHandle, deviceContextHandle, rectangle, data)

/// <summary>

/// 모니터 열거 프로시저

/// </summary>

/// <param name="desktopHandle">데스크톱 핸들</param>

/// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>

/// <param name="rectangle">사각형</param>

/// <param name="data">데이터</param>

private delegate void MonitorEnumProc

(

IntPtr desktopHandle,

IntPtr deviceContextHandle,

ref RECTANGLE rectangle,

int data

);

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Import

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 디스플레이 모니터 열거하기 - EnumDisplayMonitors(deviceContextHandle, rectangleHandle, callback, data)

/// <summary>

/// 디스플레이 모니터 열거하기

/// </summary>

/// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>

/// <param name="rectangleHandle">사각형 핸들</param>

/// <param name="callback">콜백</param>

/// <param name="data">데이터</param>

/// <returns>처리 결과</returns>

[DllImport("user32.dll")]

private static extern bool EnumDisplayMonitors

(

IntPtr deviceContextHandle,

IntPtr rectangleHandle,

MonitorEnumProc callback,

int data

);

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region 모니터 카운트 구하기 - GetMonitorCount()

/// <summary>

/// 모니터 카운트 구하기

/// </summary>

/// <returns>모니터 카운트</returns>

public static int GetMonitorCount()

{

int monitorCount = 0;

MonitorEnumProc callback = (IntPtr desktopHandle, IntPtr deviceContextHandle, ref RECTANGLE rectangle, int data) => ++monitorCount;

if(EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, callback, 0))

{

return monitorCount;

}

else

{

return -1;

}

#endregion

}

▶ Program.cs


using System;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            int monitorCount = ScreenHelper.GetMonitorCount();

            Console.WriteLine($"모니터 수 : {monitorCount}");
        }

        #endregion
    }
}

using System;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

int monitorCount = ScreenHelper.GetMonitorCount();

Console.WriteLine($"모니터 수 : {monitorCount}");

}

#endregion

}

TestProject.zip

[C#/WPF] 모니터 정보 구하기

■ 모니터 정보를 구하는 방법을 보여준다. ▶ POINT.cs


using System.Runtime.InteropServices;

namespace TestProject
{
    /// <summary>
    /// 포인트
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct POINT
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region Field

        /// <summary>
        /// X
        /// </summary>
        public int X;

        /// <summary>
        /// Y
        /// </summary>
        public int Y;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - POINT(x, y)

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="x">X</param>
        /// <param name="y">Y</param>
        public POINT(int x, int y)
        {
            X = x;
            Y = y;
        }

        #endregion
    }
}

using System.Runtime.InteropServices;

namespace TestProject

{

/// <summary>

/// 포인트

/// </summary>

[StructLayout(LayoutKind.Sequential)]

public struct POINT

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Public

#region Field

/// <summary>

/// X

/// </summary>

public int X;

/// <summary>

/// Y

/// </summary>

public int Y;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - POINT(x, y)

/// <summary>

/// 생성자

/// </summary>

/// <param name="x">X</param>

/// <param name="y">Y</param>

public POINT(int x, int y)

{

X = x;

Y = y;

}

#endregion

}

▶ RECTANGLE.cs


using System.Runtime.InteropServices;
using System.Windows;

namespace TestProject
{
    /// <summary>
    /// 사각형
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct RECTANGLE
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region Field

        /// <summary>
        /// 왼쪽
        /// </summary>
        public int Left;

        /// <summary>
        /// 위쪽
        /// </summary>
        public int Top;

        /// <summary>
        /// 오른쪽
        /// </summary>
        public int Right;

        /// <summary>
        /// 아래쪽
        /// </summary>
        public int Bottom;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Property
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 크기 - Size

        /// <summary>
        /// 크기
        /// </summary>
        public Size Size
        {
            get
            {
                return new Size
                (
                    Right  - Left,
                    Bottom - Top
                );
            }
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - RECTANGLE(left, top, right, bottom)

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="left">왼쪽</param>
        /// <param name="top">위쪽</param>
        /// <param name="right">오른쪽</param>
        /// <param name="bottom">아래쪽</param>
        public RECTANGLE(int left, int top, int right, int bottom)
        {
            Left   = left;
            Top    = top;
            Right  = right;
            Bottom = bottom;
        }

        #endregion
        #region 생성자 - RECTANGLE(source)

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="source">소스 사각형</param>
        public RECTANGLE(Rect source)
        {
            Left   = (int)source.Left;
            Top    = (int)source.Top;
            Right  = (int)source.Right;
            Bottom = (int)source.Bottom;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 사각형 구하기 - GetRectangle(x, y, width, height)

        /// <summary>
        /// 사각형 구하기
        /// </summary>
        /// <param name="x">X</param>
        /// <param name="y">Y</param>
        /// <param name="width">너비</param>
        /// <param name="height">높이</param>
        /// <returns>사각형</returns>
        public static RECTANGLE GetRectangle(int x, int y, int width, int height)
        {
            return new RECTANGLE(x, y, x + width, y + height);
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

using System.Runtime.InteropServices;

using System.Windows;

namespace TestProject

{

/// <summary>

/// 사각형

/// </summary>

[StructLayout(LayoutKind.Sequential)]

public struct RECTANGLE

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Public

#region Field

/// <summary>

/// 왼쪽

/// </summary>

public int Left;

/// <summary>

/// 위쪽

/// </summary>

public int Top;

/// <summary>

/// 오른쪽

/// </summary>

public int Right;

/// <summary>

/// 아래쪽

/// </summary>

public int Bottom;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Property

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 크기 - Size

/// <summary>

/// 크기

/// </summary>

public Size Size

{

get

{

return new Size

(

Right - Left,

Bottom - Top

);

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - RECTANGLE(left, top, right, bottom)

/// <summary>

/// 생성자

/// </summary>

/// <param name="left">왼쪽</param>

/// <param name="top">위쪽</param>

/// <param name="right">오른쪽</param>

/// <param name="bottom">아래쪽</param>

public RECTANGLE(int left, int top, int right, int bottom)

{

Left = left;

Top = top;

Right = right;

Bottom = bottom;

}

#endregion

#region 생성자 - RECTANGLE(source)

/// <summary>

/// 생성자

/// </summary>

/// <param name="source">소스 사각형</param>

public RECTANGLE(Rect source)

{

Left = (int)source.Left;

Top = (int)source.Top;

Right = (int)source.Right;

Bottom = (int)source.Bottom;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region 사각형 구하기 - GetRectangle(x, y, width, height)

/// <summary>

/// 사각형 구하기

/// </summary>

/// <param name="x">X</param>

/// <param name="y">Y</param>

/// <param name="width">너비</param>

/// <param name="height">높이</param>

/// <returns>사각형</returns>

public static RECTANGLE GetRectangle(int x, int y, int width, int height)

{

return new RECTANGLE(x, y, x + width, y + height);

}

#endregion

}

▶ MONITOR_INFORMATION.cs


using System.Runtime.InteropServices;

namespace TestProject
{
    /// <summary>
    /// 모니터 정보
    /// </summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto, Pack = 4)]
    public class MONITOR_INFORMATION
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region Field

        /// <summary>
        /// 크기
        /// </summary>
        public int Size = Marshal.SizeOf(typeof(MONITOR_INFORMATION));

        /// <summary>
        /// 디스플레이 사각형
        /// </summary>
        public RECTANGLE DisplayRectangle = new RECTANGLE();

        /// <summary>
        /// 작업 영역 사각형
        /// </summary>
        public RECTANGLE WorkingAreaRectangle = new RECTANGLE();

        /// <summary>
        /// 플래그
        /// </summary>
        public int Flag = 0;

        /// <summary>
        /// 장치명
        /// </summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
        public char[] DeviceName = new char[32];

        #endregion
    }
}

using System.Runtime.InteropServices;

namespace TestProject

{

/// <summary>

/// 모니터 정보

/// </summary>

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto, Pack = 4)]

public class MONITOR_INFORMATION

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Public

#region Field

/// <summary>

/// 크기

/// </summary>

public int Size = Marshal.SizeOf(typeof(MONITOR_INFORMATION));

/// <summary>

/// 디스플레이 사각형

/// </summary>

public RECTANGLE DisplayRectangle = new RECTANGLE();

/// <summary>

/// 작업 영역 사각형

/// </summary>

public RECTANGLE WorkingAreaRectangle = new RECTANGLE();

/// <summary>

/// 플래그

/// </summary>

public int Flag = 0;

/// <summary>

/// 장치명

/// </summary>

[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]

public char[] DeviceName = new char[32];

#endregion

}

▶ SystemInformation.cs


using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Windows;

namespace TestProject
{
    /// <summary>
    /// 시스템 정보
    /// </summary>
    public static class SystemInformation
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Import
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 시스템 구성 설정 구하기 - GetSystemMetrics(index)

        /// <summary>
        /// 시스템 구성 설정 구하기
        /// </summary>
        /// <param name="index">인덱스</param>
        /// <returns>시스템 구성 설정</returns>
        [DllImport("user32", ExactSpelling = true, CharSet = CharSet.Auto)]
        [ResourceExposure(ResourceScope.None)]
        private static extern int GetSystemMetrics(int index);

        #endregion
        #region 시스템 매개 변수 정보 처리하기 - SystemParametersInfo(action, parameter, rectangle, update)

        /// <summary>
        /// 시스템 매개 변수 정보 처리하기
        /// </summary>
        /// <param name="action">액션</param>
        /// <param name="parameter">매개 변수</param>
        /// <param name="rectangle">사각형</param>
        /// <param name="update">업데이트</param>
        /// <returns>처리 결과</returns>
        [DllImport("user32", CharSet = CharSet.Auto)]
        [ResourceExposure(ResourceScope.None)]
        private static extern bool SystemParametersInfo(int action, int parameter, ref RECTANGLE rectangle, int update);

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// SM_CXSCREEN
        /// </summary>
        private const int SM_CXSCREEN = 0;

        /// <summary>
        /// SM_CYSCREEN
        /// </summary>
        private const int SM_CYSCREEN = 1;

        /// <summary>
        /// SPI_GETWORKAREA
        /// </summary>
        private const int SPI_GETWORKAREA = 48;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Property
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 가상 화면 사각형 - VirtualScreenRectangle

        /// <summary>
        /// 가상 화면 사각형
        /// </summary>
        public static Rect VirtualScreenRectangle
        {
            get
            {
                Size size = new Size
                (
                    GetSystemMetrics(SM_CXSCREEN),
                    GetSystemMetrics(SM_CYSCREEN)
                );

                return new Rect(0, 0, size.Width, size.Height);
            }
        }

        #endregion
        #region 작업 영역 사각형 - WorkingAreaRectangle

        /// <summary>
        /// 작업 영역 사각형
        /// </summary>
        public static Rect WorkingAreaRectangle
        {
            get
            {
                RECTANGLE rectangle = new RECTANGLE();

                SystemParametersInfo(SPI_GETWORKAREA, 0, ref rectangle, 0);

                return new Rect
                (
                    rectangle.Left,
                    rectangle.Top,
                    rectangle.Right  - rectangle.Left,
                    rectangle.Bottom - rectangle.Top
                );
            }
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

using System.Runtime.InteropServices;

using System.Runtime.Versioning;

using System.Windows;

namespace TestProject

{

/// <summary>

/// 시스템 정보

/// </summary>

public static class SystemInformation

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Import

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 시스템 구성 설정 구하기 - GetSystemMetrics(index)

/// <summary>

/// 시스템 구성 설정 구하기

/// </summary>

/// <param name="index">인덱스</param>

/// <returns>시스템 구성 설정</returns>

[DllImport("user32", ExactSpelling = true, CharSet = CharSet.Auto)]

[ResourceExposure(ResourceScope.None)]

private static extern int GetSystemMetrics(int index);

#endregion

#region 시스템 매개 변수 정보 처리하기 - SystemParametersInfo(action, parameter, rectangle, update)

/// <summary>

/// 시스템 매개 변수 정보 처리하기

/// </summary>

/// <param name="action">액션</param>

/// <param name="parameter">매개 변수</param>

/// <param name="rectangle">사각형</param>

/// <param name="update">업데이트</param>

/// <returns>처리 결과</returns>

[DllImport("user32", CharSet = CharSet.Auto)]

[ResourceExposure(ResourceScope.None)]

private static extern bool SystemParametersInfo(int action, int parameter, ref RECTANGLE rectangle, int update);

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// SM_CXSCREEN

/// </summary>

private const int SM_CXSCREEN = 0;

/// <summary>

/// SM_CYSCREEN

/// </summary>

private const int SM_CYSCREEN = 1;

/// <summary>

/// SPI_GETWORKAREA

/// </summary>

private const int SPI_GETWORKAREA = 48;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Property

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region 가상 화면 사각형 - VirtualScreenRectangle

/// <summary>

/// 가상 화면 사각형

/// </summary>

public static Rect VirtualScreenRectangle

{

get

{

Size size = new Size

(

GetSystemMetrics(SM_CXSCREEN),

GetSystemMetrics(SM_CYSCREEN)

);

return new Rect(0, 0, size.Width, size.Height);

}

#endregion

#region 작업 영역 사각형 - WorkingAreaRectangle

/// <summary>

/// 작업 영역 사각형

/// </summary>

public static Rect WorkingAreaRectangle

{

get

{

RECTANGLE rectangle = new RECTANGLE();

SystemParametersInfo(SPI_GETWORKAREA, 0, ref rectangle, 0);

return new Rect

(

rectangle.Left,

rectangle.Top,

rectangle.Right - rectangle.Left,

rectangle.Bottom - rectangle.Top

);

}

#endregion

}

▶ Screen.cs


using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Windows;

namespace TestProject
{
    /// <summary>
    /// 화면
    /// </summary>
    public class Screen
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Class
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 모니터 열거 콜백 - MonitorEnumCallback

        /// <summary>
        /// 모니터 열거 콜백
        /// </summary>
        private class MonitorEnumCallback
        {
            //////////////////////////////////////////////////////////////////////////////////////////////////// Property
            ////////////////////////////////////////////////////////////////////////////////////////// Public

            #region 화면 리스트 - ScreenList

            /// <summary>
            /// 화면 리스트
            /// </summary>
            public List<Screen> ScreenList { get; private set; }

            #endregion

            //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
            ////////////////////////////////////////////////////////////////////////////////////////// Public

            #region 생성자 - MonitorEnumCallback()

            /// <summary>
            /// 생성자
            /// </summary>
            public MonitorEnumCallback()
            {
                ScreenList = new List<Screen>();
            }

            #endregion

            //////////////////////////////////////////////////////////////////////////////////////////////////// Method
            ////////////////////////////////////////////////////////////////////////////////////////// Public

            #region 콜백 처리하기 - Callback(monitorHandle, deviceContextHandle, monitorRectangleHandle, dataHandle)

            /// <summary>
            /// 콜백 처리하기
            /// </summary>
            /// <param name="monitorHandle">모니터 핸들</param>
            /// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>
            /// <param name="monitorRectangleHandle">모니터 사각형 핸들</param>
            /// <param name="dataHandle">데이터 핸들</param>
            /// <returns>처리 결과</returns>
            public bool Callback(IntPtr monitorHandle, IntPtr deviceContextHandle, IntPtr monitorRectangleHandle, IntPtr dataHandle)
            {
                ScreenList.Add(new Screen(monitorHandle, deviceContextHandle));

                return true;
            }

            #endregion
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Delegate
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 모니터 열거 프로시저 대리자 - MonitorEnumProc(monitorHandle, deviceContextHandle, monitorRectangleHandle, dataHandle)

        /// <summary>
        /// 모니터 열거 프로시저 대리자
        /// </summary>
        /// <param name="monitorHandle">모니터 핸들</param>
        /// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>
        /// <param name="monitorRectangleHandle">모니터 사각형 핸들</param>
        /// <param name="dataHandle">데이터 핸들</param>
        /// <returns>처리 결과</returns>
        private delegate bool MonitorEnumProc
        (
            IntPtr monitorHandle,
            IntPtr deviceContextHandle,
            IntPtr monitorRectangleHandle,
            IntPtr dataHandle
        );

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Import
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 시스템 구성 설정 구하기 - GetSystemMetrics(index)

        /// <summary>
        /// 시스템 구성 설정 구하기
        /// </summary>
        /// <param name="index">인덱스</param>
        /// <returns>시스템 구성 설정</returns>
        [DllImport("user32", ExactSpelling = true, CharSet = CharSet.Auto)]
        [ResourceExposure(ResourceScope.None)]
        private static extern int GetSystemMetrics(int index);

        #endregion
        #region 모니터 정보 구하기 - GetMonitorInfo(monitorHandleRef, monitorInformation)

        /// <summary>
        /// 모니터 정보 구하기
        /// </summary>
        /// <param name="monitorHandleRef">모니터 핸들 참조</param>
        /// <param name="monitorInformation">모니터 정보</param>
        /// <returns>처리 결과</returns>
        [DllImport("user32", CharSet = CharSet.Auto)]
        [ResourceExposure(ResourceScope.None)]
        private static extern bool GetMonitorInfo(HandleRef monitorHandleRef, [In, Out] MONITOR_INFORMATION monitorInformation);

        #endregion
        #region 디스플레이 모니터 열거하기 - EnumDisplayMonitors(deviceContextHandle, clippingRectangleHandle, monitorEnumProc, dataHandle

        /// <summary>
        /// 디스플레이 모니터 열거하기
        /// </summary>
        /// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>
        /// <param name="clippingRectangleHandle">클리핑 사각형 핸들</param>
        /// <param name="monitorEnumProc">모니터 열거 프로시저</param>
        /// <param name="dataHandle">데이터 핸들</param>
        /// <returns>처리 결과</returns>
        [DllImport("user32", ExactSpelling = true)]
        [ResourceExposure(ResourceScope.None)]
        private static extern bool EnumDisplayMonitors
        (
            HandleRef       deviceContextHandle,
            IntPtr          clippingRectangleHandle,
            MonitorEnumProc monitorEnumProc,
            IntPtr          dataHandle
        );

        #endregion
        #region 윈도우에서 모니터 핸들 구하기 - MonitorFromWindow(windowHandleRef, flag)

        /// <summary>
        /// 윈도우에서 모니터 핸들 구하기
        /// </summary>
        /// <param name="windowHandleRef">윈도우 핸들 참조</param>
        /// <param name="flag">플래그</param>
        /// <returns>윈도우 핸들</returns>
        [DllImport("user32", ExactSpelling = true)]
        [ResourceExposure(ResourceScope.None)]
        private static extern IntPtr MonitorFromWindow(HandleRef windowHandleRef, int flag);

        #endregion
        #region 포인트에서 모니터 핸들 구하기 - MonitorFromPoint(point, flag)

        /// <summary>
        /// 포인트에서 모니터 핸들 구하기
        /// </summary>
        /// <param name="point">포인트</param>
        /// <param name="flag">플래그</param>
        /// <returns>모니터 핸들</returns>
        [DllImport("user32", ExactSpelling = true)]
        [ResourceExposure(ResourceScope.None)]
        private static extern IntPtr MonitorFromPoint(POINT point, int flag);

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// NULL 핸들 참조
        /// </summary>
        private static readonly HandleRef _nullHandleRef = new HandleRef(null, IntPtr.Zero);

        /// <summary>
        /// 멀티 모니터 지원 여부
        /// </summary>
        private static bool _multiMonitorSupport;

        #endregion

        ////////////////////////////////////////////////////////////////////////////////////////// Instance
        //////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// SM_CMONITORS
        /// </summary>
        private const int SM_CMONITORS = 80;

        /// <summary>
        /// PRIMARY_MONITOR
        /// </summary>
        private const int PRIMARY_MONITOR = unchecked((int)0xBAADF00D);

        /// <summary>
        /// MONITORINFOF_PRIMARY
        /// </summary>
        private const int MONITORINFOF_PRIMARY = 0x00000001;

        /// <summary>
        /// MONITOR_DEFAULTTONEAREST
        /// </summary>
        private const int MONITOR_DEFAULTTONEAREST = 0x00000002;

        /// <summary>
        /// 모니터 핸들
        /// </summary>
        private readonly IntPtr monitorHandle;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Property
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 모든 화면 열거 가능형 - AllScreenEnumerable

        /// <summary>
        /// 모든 화면 열거 가능형
        /// </summary>
        public static IEnumerable<Screen> AllScreenEnumerable
        {
            get
            {
                if(_multiMonitorSupport)
                {
                    MonitorEnumCallback monitorEnumCallback = new MonitorEnumCallback();

                    MonitorEnumProc monitorEnumProc = new MonitorEnumProc(monitorEnumCallback.Callback);

                    EnumDisplayMonitors(_nullHandleRef, IntPtr.Zero, monitorEnumProc, IntPtr.Zero);

                    if(monitorEnumCallback.ScreenList.Count > 0)
                    {
                        return monitorEnumCallback.ScreenList.Cast<Screen>();
                    }
                }

                return new[] { new Screen((IntPtr)PRIMARY_MONITOR) };
            }
        }

        #endregion
        #region 기본 화면 - PrimaryScreen

        /// <summary>
        /// 기본 화면
        /// </summary>
        public static Screen PrimaryScreen
        {
            get
            {
                if(_multiMonitorSupport)
                {
                    return AllScreenEnumerable.FirstOrDefault(screen => screen.Primary);
                }

                return new Screen((IntPtr)PRIMARY_MONITOR);
            }
        }

        #endregion

        ////////////////////////////////////////////////////////////////////////////////////////// Instance
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 장치명 - DeviceName

        /// <summary>
        /// 장치명
        /// </summary>
        public string DeviceName { get; private set; }

        #endregion
        #region 기본 장치 여부 - Primary

        /// <summary>
        /// 기본 장치 여부
        /// </summary>
        public bool Primary { get; private set; }

        #endregion
        #region 테두리 사각형 - BoundRectangle

        /// <summary>
        /// 테두리 사각형
        /// </summary>
        public Rect BoundRectangle { get; private set; }

        #endregion
        #region 작업 영역 사각형 - WorkingAreaRectangle

        /// <summary>
        /// 작업 영역 사각형
        /// </summary>
        public Rect WorkingAreaRectangle
        {
            get
            {
                if(!_multiMonitorSupport || this.monitorHandle == (IntPtr)PRIMARY_MONITOR)
                {
                    return SystemInformation.WorkingAreaRectangle;
                }

                MONITOR_INFORMATION monitorInformation = new MONITOR_INFORMATION();

                GetMonitorInfo(new HandleRef(null, this.monitorHandle), monitorInformation);

                return new Rect
                (
                    monitorInformation.WorkingAreaRectangle.Left,
                    monitorInformation.WorkingAreaRectangle.Top,
                    monitorInformation.WorkingAreaRectangle.Right  - monitorInformation.WorkingAreaRectangle.Left,
                    monitorInformation.WorkingAreaRectangle.Bottom - monitorInformation.WorkingAreaRectangle.Top
                );
            }
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Static

        #region 생성자 - Screen()

        /// <summary>
        /// 생성자
        /// </summary>
        static Screen()
        {
            _multiMonitorSupport = GetSystemMetrics(SM_CMONITORS) != 0;
        }

        #endregion

        ////////////////////////////////////////////////////////////////////////////////////////// Instance
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 생성자 - Screen(monitorHandle, deviceContextHandle)

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="monitorHandle"></param>
        /// <param name="deviceContextHandle"></param>
        private Screen(IntPtr monitorHandle, IntPtr deviceContextHandle)
        {
            if(!_multiMonitorSupport || monitorHandle == (IntPtr)PRIMARY_MONITOR)
            {
                DeviceName     = "DISPLAY";
                Primary        = true;
                BoundRectangle = SystemInformation.VirtualScreenRectangle;
            }
            else
            {
                MONITOR_INFORMATION monitorInformation = new MONITOR_INFORMATION();

                GetMonitorInfo(new HandleRef(null, monitorHandle), monitorInformation);

                DeviceName     = new string(monitorInformation.DeviceName).TrimEnd((char)0);
                Primary        = ((monitorInformation.Flag & MONITORINFOF_PRIMARY) != 0);
                BoundRectangle = new Rect
                (
                    monitorInformation.DisplayRectangle.Left,
                    monitorInformation.DisplayRectangle.Top,
                    monitorInformation.DisplayRectangle.Right  - monitorInformation.DisplayRectangle.Left,
                    monitorInformation.DisplayRectangle.Bottom - monitorInformation.DisplayRectangle.Top
                );
            }

            this.monitorHandle = monitorHandle;
        }

        #endregion
        #region 생성자 - Screen(monitorHandle)

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="monitorHandle">모니터 핸들</param>
        private Screen(IntPtr monitorHandle) : this(monitorHandle, IntPtr.Zero)
        {
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 화면 구하기 - GetScreen(windowHandle)

        /// <summary>
        /// 화면 구하기
        /// </summary>
        /// <param name="windowHandle">윈도우 핸들</param>
        /// <returns>화면</returns>
        public static Screen GetScreen(IntPtr windowHandle)
        {
            if(_multiMonitorSupport)
            {
                return new Screen(MonitorFromWindow(new HandleRef(null, windowHandle), 2));
            }

            return new Screen((IntPtr)PRIMARY_MONITOR);
        }

        #endregion
        #region 화면 구하기 - GetScreen(point)

        /// <summary>
        /// 화면 구하기
        /// </summary>
        /// <param name="point">포인트</param>
        /// <returns>화면</returns>
        public static Screen GetScreen(Point point)
        {
            if(_multiMonitorSupport)
            {
                POINT temporaryPoint = new POINT((int)point.X, (int)point.Y);

                return new Screen(MonitorFromPoint(temporaryPoint, MONITOR_DEFAULTTONEAREST));
            }

            return new Screen((IntPtr)PRIMARY_MONITOR);
        }

        #endregion

        ////////////////////////////////////////////////////////////////////////////////////////// Method
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 동일 여부 구하기 - Equals(source)

        /// <summary>
        /// 동일 여부 구하기
        /// </summary>
        /// <param name="source">소스 객체</param>
        /// <returns>동일 여부</returns>
        public override bool Equals(object source)
        {
            Screen screen = source as Screen;

            if(screen != null)
            {
                if(this.monitorHandle == screen.monitorHandle)
                {
                    return true;
                }
            }

            return false;
        }

        #endregion
        #region 해시 코드 구하기 - GetHashCode()

        /// <summary>
        /// 해시 코드 구하기
        /// </summary>
        /// <returns>해시 코드</returns>
        public override int GetHashCode()
        {
            return (int)this.monitorHandle;
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

using System;

using System.Collections.Generic;

using System.Linq;

using System.Runtime.InteropServices;

using System.Runtime.Versioning;

using System.Windows;

namespace TestProject

{

/// <summary>

/// 화면

/// </summary>

public class Screen

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Class

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 모니터 열거 콜백 - MonitorEnumCallback

/// <summary>

/// 모니터 열거 콜백

/// </summary>

private class MonitorEnumCallback

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Property

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 화면 리스트 - ScreenList

/// <summary>

/// 화면 리스트

/// </summary>

public List<Screen> ScreenList { get; private set; }

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MonitorEnumCallback()

/// <summary>

/// 생성자

/// </summary>

public MonitorEnumCallback()

{

ScreenList = new List<Screen>();

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 콜백 처리하기 - Callback(monitorHandle, deviceContextHandle, monitorRectangleHandle, dataHandle)

/// <summary>

/// 콜백 처리하기

/// </summary>

/// <param name="monitorHandle">모니터 핸들</param>

/// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>

/// <param name="monitorRectangleHandle">모니터 사각형 핸들</param>

/// <param name="dataHandle">데이터 핸들</param>

/// <returns>처리 결과</returns>

public bool Callback(IntPtr monitorHandle, IntPtr deviceContextHandle, IntPtr monitorRectangleHandle, IntPtr dataHandle)

{

ScreenList.Add(new Screen(monitorHandle, deviceContextHandle));

return true;

}

#endregion

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Delegate

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 모니터 열거 프로시저 대리자 - MonitorEnumProc(monitorHandle, deviceContextHandle, monitorRectangleHandle, dataHandle)

/// <summary>

/// 모니터 열거 프로시저 대리자

/// </summary>

/// <param name="monitorHandle">모니터 핸들</param>

/// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>

/// <param name="monitorRectangleHandle">모니터 사각형 핸들</param>

/// <param name="dataHandle">데이터 핸들</param>

/// <returns>처리 결과</returns>

private delegate bool MonitorEnumProc

(

IntPtr monitorHandle,

IntPtr deviceContextHandle,

IntPtr monitorRectangleHandle,

IntPtr dataHandle

);

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Import

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 시스템 구성 설정 구하기 - GetSystemMetrics(index)

/// <summary>

/// 시스템 구성 설정 구하기

/// </summary>

/// <param name="index">인덱스</param>

/// <returns>시스템 구성 설정</returns>

[DllImport("user32", ExactSpelling = true, CharSet = CharSet.Auto)]

[ResourceExposure(ResourceScope.None)]

private static extern int GetSystemMetrics(int index);

#endregion

#region 모니터 정보 구하기 - GetMonitorInfo(monitorHandleRef, monitorInformation)

/// <summary>

/// 모니터 정보 구하기

/// </summary>

/// <param name="monitorHandleRef">모니터 핸들 참조</param>

/// <param name="monitorInformation">모니터 정보</param>

/// <returns>처리 결과</returns>

[DllImport("user32", CharSet = CharSet.Auto)]

[ResourceExposure(ResourceScope.None)]

private static extern bool GetMonitorInfo(HandleRef monitorHandleRef, [In, Out] MONITOR_INFORMATION monitorInformation);

#endregion

#region 디스플레이 모니터 열거하기 - EnumDisplayMonitors(deviceContextHandle, clippingRectangleHandle, monitorEnumProc, dataHandle

/// <summary>

/// 디스플레이 모니터 열거하기

/// </summary>

/// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>

/// <param name="clippingRectangleHandle">클리핑 사각형 핸들</param>

/// <param name="monitorEnumProc">모니터 열거 프로시저</param>

/// <param name="dataHandle">데이터 핸들</param>

/// <returns>처리 결과</returns>

[DllImport("user32", ExactSpelling = true)]

[ResourceExposure(ResourceScope.None)]

private static extern bool EnumDisplayMonitors

(

HandleRef deviceContextHandle,

IntPtr clippingRectangleHandle,

MonitorEnumProc monitorEnumProc,

IntPtr dataHandle

);

#endregion

#region 윈도우에서 모니터 핸들 구하기 - MonitorFromWindow(windowHandleRef, flag)

/// <summary>

/// 윈도우에서 모니터 핸들 구하기

/// </summary>

/// <param name="windowHandleRef">윈도우 핸들 참조</param>

/// <param name="flag">플래그</param>

/// <returns>윈도우 핸들</returns>

[DllImport("user32", ExactSpelling = true)]

[ResourceExposure(ResourceScope.None)]

private static extern IntPtr MonitorFromWindow(HandleRef windowHandleRef, int flag);

#endregion

#region 포인트에서 모니터 핸들 구하기 - MonitorFromPoint(point, flag)

/// <summary>

/// 포인트에서 모니터 핸들 구하기

/// </summary>

/// <param name="point">포인트</param>

/// <param name="flag">플래그</param>

/// <returns>모니터 핸들</returns>

[DllImport("user32", ExactSpelling = true)]

[ResourceExposure(ResourceScope.None)]

private static extern IntPtr MonitorFromPoint(POINT point, int flag);

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// NULL 핸들 참조

/// </summary>

private static readonly HandleRef _nullHandleRef = new HandleRef(null, IntPtr.Zero);

/// <summary>

/// 멀티 모니터 지원 여부

/// </summary>

private static bool _multiMonitorSupport;

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Instance

//////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// SM_CMONITORS

/// </summary>

private const int SM_CMONITORS = 80;

/// <summary>

/// PRIMARY_MONITOR

/// </summary>

private const int PRIMARY_MONITOR = unchecked((int)0xBAADF00D);

/// <summary>

/// MONITORINFOF_PRIMARY

/// </summary>

private const int MONITORINFOF_PRIMARY = 0x00000001;

/// <summary>

/// MONITOR_DEFAULTTONEAREST

/// </summary>

private const int MONITOR_DEFAULTTONEAREST = 0x00000002;

/// <summary>

/// 모니터 핸들

/// </summary>

private readonly IntPtr monitorHandle;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Property

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region 모든 화면 열거 가능형 - AllScreenEnumerable

/// <summary>

/// 모든 화면 열거 가능형

/// </summary>

public static IEnumerable<Screen> AllScreenEnumerable

{

get

{

if(_multiMonitorSupport)

{

MonitorEnumCallback monitorEnumCallback = new MonitorEnumCallback();

MonitorEnumProc monitorEnumProc = new MonitorEnumProc(monitorEnumCallback.Callback);

EnumDisplayMonitors(_nullHandleRef, IntPtr.Zero, monitorEnumProc, IntPtr.Zero);

if(monitorEnumCallback.ScreenList.Count > 0)

{

return monitorEnumCallback.ScreenList.Cast<Screen>();

}

return new[] { new Screen((IntPtr)PRIMARY_MONITOR) };

}

#endregion

#region 기본 화면 - PrimaryScreen

/// <summary>

/// 기본 화면

/// </summary>

public static Screen PrimaryScreen

{

get

{

if(_multiMonitorSupport)

{

return AllScreenEnumerable.FirstOrDefault(screen => screen.Primary);

}

return new Screen((IntPtr)PRIMARY_MONITOR);

}

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Instance

//////////////////////////////////////////////////////////////////////////////// Public

#region 장치명 - DeviceName

/// <summary>

/// 장치명

/// </summary>

public string DeviceName { get; private set; }

#endregion

#region 기본 장치 여부 - Primary

/// <summary>

/// 기본 장치 여부

/// </summary>

public bool Primary { get; private set; }

#endregion

#region 테두리 사각형 - BoundRectangle

/// <summary>

/// 테두리 사각형

/// </summary>

public Rect BoundRectangle { get; private set; }

#endregion

#region 작업 영역 사각형 - WorkingAreaRectangle

/// <summary>

/// 작업 영역 사각형

/// </summary>

public Rect WorkingAreaRectangle

{

get

{

if(!_multiMonitorSupport || this.monitorHandle == (IntPtr)PRIMARY_MONITOR)

{

return SystemInformation.WorkingAreaRectangle;

}

MONITOR_INFORMATION monitorInformation = new MONITOR_INFORMATION();

GetMonitorInfo(new HandleRef(null, this.monitorHandle), monitorInformation);

return new Rect

(

monitorInformation.WorkingAreaRectangle.Left,

monitorInformation.WorkingAreaRectangle.Top,

monitorInformation.WorkingAreaRectangle.Right - monitorInformation.WorkingAreaRectangle.Left,

monitorInformation.WorkingAreaRectangle.Bottom - monitorInformation.WorkingAreaRectangle.Top

);

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Static

#region 생성자 - Screen()

/// <summary>

/// 생성자

/// </summary>

static Screen()

{

_multiMonitorSupport = GetSystemMetrics(SM_CMONITORS) != 0;

}

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Instance

//////////////////////////////////////////////////////////////////////////////// Private

#region 생성자 - Screen(monitorHandle, deviceContextHandle)

/// <summary>

/// 생성자

/// </summary>

/// <param name="monitorHandle"></param>

/// <param name="deviceContextHandle"></param>

private Screen(IntPtr monitorHandle, IntPtr deviceContextHandle)

{

if(!_multiMonitorSupport || monitorHandle == (IntPtr)PRIMARY_MONITOR)

{

DeviceName = "DISPLAY";

Primary = true;

BoundRectangle = SystemInformation.VirtualScreenRectangle;

}

else

{

MONITOR_INFORMATION monitorInformation = new MONITOR_INFORMATION();

GetMonitorInfo(new HandleRef(null, monitorHandle), monitorInformation);

DeviceName = new string(monitorInformation.DeviceName).TrimEnd((char)0);

Primary = ((monitorInformation.Flag & MONITORINFOF_PRIMARY) != 0);

BoundRectangle = new Rect

(

monitorInformation.DisplayRectangle.Left,

monitorInformation.DisplayRectangle.Top,

monitorInformation.DisplayRectangle.Right - monitorInformation.DisplayRectangle.Left,

monitorInformation.DisplayRectangle.Bottom - monitorInformation.DisplayRectangle.Top

);

}

this.monitorHandle = monitorHandle;

}

#endregion

#region 생성자 - Screen(monitorHandle)

/// <summary>

/// 생성자

/// </summary>

/// <param name="monitorHandle">모니터 핸들</param>

private Screen(IntPtr monitorHandle) : this(monitorHandle, IntPtr.Zero)

{

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region 화면 구하기 - GetScreen(windowHandle)

/// <summary>

/// 화면 구하기

/// </summary>

/// <param name="windowHandle">윈도우 핸들</param>

/// <returns>화면</returns>

public static Screen GetScreen(IntPtr windowHandle)

{

if(_multiMonitorSupport)

{

return new Screen(MonitorFromWindow(new HandleRef(null, windowHandle), 2));

}

return new Screen((IntPtr)PRIMARY_MONITOR);

}

#endregion

#region 화면 구하기 - GetScreen(point)

/// <summary>

/// 화면 구하기

/// </summary>

/// <param name="point">포인트</param>

/// <returns>화면</returns>

public static Screen GetScreen(Point point)

{

if(_multiMonitorSupport)

{

POINT temporaryPoint = new POINT((int)point.X, (int)point.Y);

return new Screen(MonitorFromPoint(temporaryPoint, MONITOR_DEFAULTTONEAREST));

}

return new Screen((IntPtr)PRIMARY_MONITOR);

}

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Method

//////////////////////////////////////////////////////////////////////////////// Public

#region 동일 여부 구하기 - Equals(source)

/// <summary>

/// 동일 여부 구하기

/// </summary>

/// <param name="source">소스 객체</param>

/// <returns>동일 여부</returns>

public override bool Equals(object source)

{

Screen screen = source as Screen;

if(screen != null)

{

if(this.monitorHandle == screen.monitorHandle)

{

return true;

}

return false;

}

#endregion

#region 해시 코드 구하기 - GetHashCode()

/// <summary>

/// 해시 코드 구하기

/// </summary>

/// <returns>해시 코드</returns>

public override int GetHashCode()

{

return (int)this.monitorHandle;

}

#endregion

}

▶

[C#/COMMON] 모니터 정보 구하기

■ 모니터 정보를 구하는 방법을 보여준다. ▶ RECTANGLE.cs


using System.Runtime.InteropServices;

namespace TestProject
{
    /// <summary>
    /// 사각형
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct RECTANGLE
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region Field

        /// <summary>
        /// 왼쪽
        /// </summary>
        public int Left;

        /// <summary>
        /// 위쪽
        /// </summary>
        public int Top;

        /// <summary>
        /// 오른쪽
        /// </summary>
        public int Right;

        /// <summary>
        /// 아래쪽
        /// </summary>
        public int Bottom;

        #endregion
    }
}

using System.Runtime.InteropServices;

namespace TestProject

{

/// <summary>

/// 사각형

/// </summary>

[StructLayout(LayoutKind.Sequential)]

public struct RECTANGLE

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Public

#region Field

/// <summary>

/// 왼쪽

/// </summary>

public int Left;

/// <summary>

/// 위쪽

/// </summary>

public int Top;

/// <summary>

/// 오른쪽

/// </summary>

public int Right;

/// <summary>

/// 아래쪽

/// </summary>

public int Bottom;

#endregion

}

▶ MONITOR_INFORMATION.cs


using System.Runtime.InteropServices;

namespace TestProject
{
    /// <summary>
    /// 모니터 정보
    /// </summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto, Pack = 4)]
    public class MONITOR_INFORMATION
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region Field

        /// <summary>
        /// 크기
        /// </summary>
        public int Size = Marshal.SizeOf(typeof(MONITOR_INFORMATION));

        /// <summary>
        /// 디스플레이 사각형
        /// </summary>
        public RECTANGLE DisplayRectangle = new RECTANGLE();

        /// <summary>
        /// 작업 영역 사각형
        /// </summary>
        public RECTANGLE WorkingAreaRectangle = new RECTANGLE();

        /// <summary>
        /// 플래그
        /// </summary>
        public int Flag = 0;

        /// <summary>
        /// 장치명
        /// </summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
        public char[] DeviceName = new char[32];

        #endregion
    }
}

using System.Runtime.InteropServices;

namespace TestProject

{

/// <summary>

/// 모니터 정보

/// </summary>

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto, Pack = 4)]

public class MONITOR_INFORMATION

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Public

#region Field

/// <summary>

/// 크기

/// </summary>

public int Size = Marshal.SizeOf(typeof(MONITOR_INFORMATION));

/// <summary>

/// 디스플레이 사각형

/// </summary>

public RECTANGLE DisplayRectangle = new RECTANGLE();

/// <summary>

/// 작업 영역 사각형

/// </summary>

public RECTANGLE WorkingAreaRectangle = new RECTANGLE();

/// <summary>

/// 플래그

/// </summary>

public int Flag = 0;

/// <summary>

/// 장치명

/// </summary>

[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]

public char[] DeviceName = new char[32];

#endregion

}

▶ Monitor.cs


using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;

namespace TestProject
{
    /// <summary>
    /// 모니터
    /// </summary>
    public class Monitor
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Class
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 모니터 열거 콜백 - MonitorEnumCallback

        /// <summary>
        /// 모니터 열거 콜백
        /// </summary>
        private class MonitorEnumCallback
        {
            ////////////////////////////////////////////////////////////////////////////////////////// Property
            //////////////////////////////////////////////////////////////////////////////// Public

            #region 모니터 리스트 - MonitorList

            /// <summary>
            /// 모니터 리스트
            /// </summary>
            public List<Monitor> MonitorList { get; private set; }

            #endregion

            ////////////////////////////////////////////////////////////////////////////////////////// Constructor
            //////////////////////////////////////////////////////////////////////////////// Public

            #region 생성자 - MonitorEnumCallback()

            /// <summary>
            /// 생성자
            /// </summary>
            public MonitorEnumCallback()
            {
                MonitorList = new List<Monitor>();
            }

            #endregion

            ////////////////////////////////////////////////////////////////////////////////////////// Method
            //////////////////////////////////////////////////////////////////////////////// Public

            #region 콜백 처리하기 - Callback(monitorHandle, deviceContextHandle, monitorRectangleHandle, dataHandle)

            /// <summary>
            /// 콜백 처리하기
            /// </summary>
            /// <param name="monitorHandle">모니터 핸들</param>
            /// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>
            /// <param name="monitorRectangleHandle">모니터 사각형 핸들</param>
            /// <param name="dataHandle">데이터 핸들</param>
            /// <returns>처리 결과</returns>
            public bool Callback(IntPtr monitorHandle, IntPtr deviceContextHandle, IntPtr monitorRectangleHandle, IntPtr dataHandle)
            {
                MonitorList.Add(new Monitor(monitorHandle, deviceContextHandle));

                return true;
            }

            #endregion
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Delegate
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 모니터 열거 프로시저 대리자 - MonitorEnumProc(monitorHandle, deviceContextHandle, monitorRectangleHandle, dataHandle)

        /// <summary>
        /// 모니터 열거 프로시저 대리자
        /// </summary>
        /// <param name="monitorHandle">모니터 핸들</param>
        /// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>
        /// <param name="monitorRectangleHandle">모니터 사각형 핸들</param>
        /// <param name="dataHandle">데이터 핸들</param>
        /// <returns>처리 결과</returns>
        private delegate bool MonitorEnumProc(IntPtr monitorHandle, IntPtr deviceContextHandle, IntPtr monitorRectangleHandle, IntPtr dataHandle);

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Import
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 모니터 정보 구하기 - GetMonitorInfo(monitorHandleRef, monitorInfo)

        /// <summary>
        /// 모니터 정보 구하기
        /// </summary>
        /// <param name="monitorHandleRef">모니터 참조 핸들</param>
        /// <param name="monitorInfo">모니터 정보</param>
        /// <returns>처리 결과</returns>
        [DllImport("user32", CharSet = CharSet.Auto)]
        [ResourceExposure(ResourceScope.None)]
        private static extern bool GetMonitorInfo(HandleRef monitorHandleRef, [In, Out]MONITOR_INFORMATION monitorInfo);

        #endregion
        #region 디스플레이 모니터 열거하기 - EnumDisplayMonitors(deviceContextHandle, clippingRectangleHandle, monitorEnumProc, dataHandle)

        /// <summary>
        /// 디스플레이 모니터 열거하기
        /// </summary>
        /// <param name="deviceContextHandle">디바이스 컨텍스 핸들</param>
        /// <param name="clippingRectangleHandle">클리핑 사각형 핸들</param>
        /// <param name="monitorEnumProc">모니터 열거 프로시저</param>
        /// <param name="dataHandle">데이터 핸들</param>
        /// <returns>처리 결과</returns>
        [DllImport("user32", ExactSpelling = true)]
        [ResourceExposure(ResourceScope.None)]
        private static extern bool EnumDisplayMonitors
        (
            HandleRef       deviceContextHandle,
            IntPtr          clippingRectangleHandle,
            MonitorEnumProc monitorEnumProc,
            IntPtr          dataHandle
        );

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region Field

        /// <summary>
        /// NULL 참조 핸들
        /// </summary>
        public static HandleRef NullHandleRef = new HandleRef(null, IntPtr.Zero);

        #endregion

        ////////////////////////////////////////////////////////////////////////////////////////// Instance
        //////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// 주 장치를 위한 모니터 정보
        /// </summary>
        private const int MONITOR_INFORMATION_FOR_PRIMARY = 0x00000001;

        #endregion

        ////////////////////////////////////////////////////////////////////////////////////////// Property
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 경계 사각형 - BoundRectangle

        /// <summary>
        /// 경계 사각형
        /// </summary>
        public System.Windows.Rect BoundRectangle { get; private set; }

        #endregion
        #region 작업 영역 사각형 - WorkingAreaRectangle

        /// <summary>
        /// 작업 영역 사각형
        /// </summary>
        public System.Windows.Rect WorkingAreaRectangle { get; private set; }

        #endregion
        #region 장치명 - DeviceName

        /// <summary>
        /// 장치명
        /// </summary>
        public string DeviceName { get; private set; }

        #endregion
        #region 주 장치 여부 - IsPrimary

        /// <summary>
        /// 주 장치 여부
        /// </summary>
        public bool IsPrimary { get; private set; }

        #endregion

        ////////////////////////////////////////////////////////////////////////////////////////// Constructor
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 생성자 - Monitor(monitorHandle, deviceContextHandle)

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="monitorHandle">모니터 핸들</param>
        /// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>
        private Monitor(IntPtr monitorHandle, IntPtr deviceContextHandle)
        {
            MONITOR_INFORMATION monitorInformation = new MONITOR_INFORMATION();

            GetMonitorInfo(new HandleRef(null, monitorHandle), monitorInformation);

            BoundRectangle = new System.Windows.Rect
            (
                monitorInformation.DisplayRectangle.Left,
                monitorInformation.DisplayRectangle.Top,
                monitorInformation.DisplayRectangle.Right  - monitorInformation.DisplayRectangle.Left,
                monitorInformation.DisplayRectangle.Bottom - monitorInformation.DisplayRectangle.Top
            );

            WorkingAreaRectangle = new System.Windows.Rect
            (
                monitorInformation.WorkingAreaRectangle.Left,
                monitorInformation.WorkingAreaRectangle.Top,
                monitorInformation.WorkingAreaRectangle.Right  - monitorInformation.WorkingAreaRectangle.Left,
                monitorInformation.WorkingAreaRectangle.Bottom - monitorInformation.WorkingAreaRectangle.Top
            );

            IsPrimary  = ((monitorInformation.Flag & MONITOR_INFORMATION_FOR_PRIMARY) != 0);
            DeviceName = new string(monitorInformation.DeviceName).TrimEnd((char)0);
        }

        #endregion

        ////////////////////////////////////////////////////////////////////////////////////////// Method
        //////////////////////////////////////////////////////////////////////////////// Static
        ////////////////////////////////////////////////////////////////////// Public

        #region 모든 모니터 열거 가능형 - AllMonitorEnumerable

        /// <summary>
        /// 모든 모니터 열거 가능형
        /// </summary>
        public static IEnumerable<Monitor> AllMonitorEnumerable
        {
            get
            {
                MonitorEnumCallback callback = new MonitorEnumCallback();

                MonitorEnumProc monitorEnumProc = new MonitorEnumProc(callback.Callback);

                EnumDisplayMonitors(NullHandleRef, IntPtr.Zero, monitorEnumProc, IntPtr.Zero);

                return callback.MonitorList.Cast<Monitor>();
            }
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

using System;

using System.Collections.Generic;

using System.Linq;

using System.Runtime.InteropServices;

using System.Runtime.Versioning;

namespace TestProject

{

/// <summary>

/// 모니터

/// </summary>

public class Monitor

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Class

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 모니터 열거 콜백 - MonitorEnumCallback

/// <summary>

/// 모니터 열거 콜백

/// </summary>

private class MonitorEnumCallback

{

////////////////////////////////////////////////////////////////////////////////////////// Property

//////////////////////////////////////////////////////////////////////////////// Public

#region 모니터 리스트 - MonitorList

/// <summary>

/// 모니터 리스트

/// </summary>

public List<Monitor> MonitorList { get; private set; }

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Constructor

//////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MonitorEnumCallback()

/// <summary>

/// 생성자

/// </summary>

public MonitorEnumCallback()

{

MonitorList = new List<Monitor>();

}

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Method

//////////////////////////////////////////////////////////////////////////////// Public

#region 콜백 처리하기 - Callback(monitorHandle, deviceContextHandle, monitorRectangleHandle, dataHandle)

/// <summary>

/// 콜백 처리하기

/// </summary>

/// <param name="monitorHandle">모니터 핸들</param>

/// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>

/// <param name="monitorRectangleHandle">모니터 사각형 핸들</param>

/// <param name="dataHandle">데이터 핸들</param>

/// <returns>처리 결과</returns>

public bool Callback(IntPtr monitorHandle, IntPtr deviceContextHandle, IntPtr monitorRectangleHandle, IntPtr dataHandle)

{

MonitorList.Add(new Monitor(monitorHandle, deviceContextHandle));

return true;

}

#endregion

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Delegate

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 모니터 열거 프로시저 대리자 - MonitorEnumProc(monitorHandle, deviceContextHandle, monitorRectangleHandle, dataHandle)

/// <summary>

/// 모니터 열거 프로시저 대리자

/// </summary>

/// <param name="monitorHandle">모니터 핸들</param>

/// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>

/// <param name="monitorRectangleHandle">모니터 사각형 핸들</param>

/// <param name="dataHandle">데이터 핸들</param>

/// <returns>처리 결과</returns>

private delegate bool MonitorEnumProc(IntPtr monitorHandle, IntPtr deviceContextHandle, IntPtr monitorRectangleHandle, IntPtr dataHandle);

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Import

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 모니터 정보 구하기 - GetMonitorInfo(monitorHandleRef, monitorInfo)

/// <summary>

/// 모니터 정보 구하기

/// </summary>

/// <param name="monitorHandleRef">모니터 참조 핸들</param>

/// <param name="monitorInfo">모니터 정보</param>

/// <returns>처리 결과</returns>

[DllImport("user32", CharSet = CharSet.Auto)]

[ResourceExposure(ResourceScope.None)]

private static extern bool GetMonitorInfo(HandleRef monitorHandleRef, [In, Out]MONITOR_INFORMATION monitorInfo);

#endregion

#region 디스플레이 모니터 열거하기 - EnumDisplayMonitors(deviceContextHandle, clippingRectangleHandle, monitorEnumProc, dataHandle)

/// <summary>

/// 디스플레이 모니터 열거하기

/// </summary>

/// <param name="deviceContextHandle">디바이스 컨텍스 핸들</param>

/// <param name="clippingRectangleHandle">클리핑 사각형 핸들</param>

/// <param name="monitorEnumProc">모니터 열거 프로시저</param>

/// <param name="dataHandle">데이터 핸들</param>

/// <returns>처리 결과</returns>

[DllImport("user32", ExactSpelling = true)]

[ResourceExposure(ResourceScope.None)]

private static extern bool EnumDisplayMonitors

(

HandleRef deviceContextHandle,

IntPtr clippingRectangleHandle,

MonitorEnumProc monitorEnumProc,

IntPtr dataHandle

);

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region Field

/// <summary>

/// NULL 참조 핸들

/// </summary>

public static HandleRef NullHandleRef = new HandleRef(null, IntPtr.Zero);

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Instance

//////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// 주 장치를 위한 모니터 정보

/// </summary>

private const int MONITOR_INFORMATION_FOR_PRIMARY = 0x00000001;

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Property

//////////////////////////////////////////////////////////////////////////////// Public

#region 경계 사각형 - BoundRectangle

/// <summary>

/// 경계 사각형

/// </summary>

public System.Windows.Rect BoundRectangle { get; private set; }

#endregion

#region 작업 영역 사각형 - WorkingAreaRectangle

/// <summary>

/// 작업 영역 사각형

/// </summary>

public System.Windows.Rect WorkingAreaRectangle { get; private set; }

#endregion

#region 장치명 - DeviceName

/// <summary>

/// 장치명

/// </summary>

public string DeviceName { get; private set; }

#endregion

#region 주 장치 여부 - IsPrimary

/// <summary>

/// 주 장치 여부

/// </summary>

public bool IsPrimary { get; private set; }

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Constructor

//////////////////////////////////////////////////////////////////////////////// Private

#region 생성자 - Monitor(monitorHandle, deviceContextHandle)

/// <summary>

/// 생성자

/// </summary>

/// <param name="monitorHandle">모니터 핸들</param>

/// <param name="deviceContextHandle">디바이스 컨텍스트 핸들</param>

private Monitor(IntPtr monitorHandle, IntPtr deviceContextHandle)

{

MONITOR_INFORMATION monitorInformation = new MONITOR_INFORMATION();

GetMonitorInfo(new HandleRef(null, monitorHandle), monitorInformation);

BoundRectangle = new System.Windows.Rect

(

monitorInformation.DisplayRectangle.Left,

monitorInformation.DisplayRectangle.Top,

monitorInformation.DisplayRectangle.Right - monitorInformation.DisplayRectangle.Left,

monitorInformation.DisplayRectangle.Bottom - monitorInformation.DisplayRectangle.Top

);

WorkingAreaRectangle = new System.Windows.Rect

(

monitorInformation.WorkingAreaRectangle.Left,

monitorInformation.WorkingAreaRectangle.Top,

monitorInformation.WorkingAreaRectangle.Right - monitorInformation.WorkingAreaRectangle.Left,

monitorInformation.WorkingAreaRectangle.Bottom - monitorInformation.WorkingAreaRectangle.Top

);

IsPrimary = ((monitorInformation.Flag & MONITOR_INFORMATION_FOR_PRIMARY) != 0);

DeviceName = new string(monitorInformation.DeviceName).TrimEnd((char)0);

}

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Method

//////////////////////////////////////////////////////////////////////////////// Static

////////////////////////////////////////////////////////////////////// Public

#region 모든 모니터 열거 가능형 - AllMonitorEnumerable

/// <summary>

/// 모든 모니터 열거 가능형

/// </summary>

public static IEnumerable<Monitor> AllMonitorEnumerable

{

get

{

MonitorEnumCallback callback = new MonitorEnumCallback();

MonitorEnumProc monitorEnumProc = new MonitorEnumProc(callback.Callback);

EnumDisplayMonitors(NullHandleRef, IntPtr.Zero, monitorEnumProc, IntPtr.Zero);

return callback.MonitorList.Cast<Monitor>();

}

#endregion

}

▶ Program.cs


using System;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            foreach(Monitor monitor in Monitor.AllMonitorEnumerable)
            {
                Console.WriteLine(monitor.DeviceName);
            }
        }

        #endregion
    }
}

using System;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

foreach(Monitor monitor in Monitor.AllMonitorEnumerable)

{

Console.WriteLine(monitor.DeviceName);

}

#endregion

}

TestProject.zip

[C#/WINFORM] Screen 클래스 : 모니터 핸들 구하기

■ Screen 클래스를 사용해 모니터 핸들을 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Windows.Forms;

#region 모니터 핸들 구하기 - GetMonitorHandle(screen)

/// <summary>
/// 모니터 핸들 구하기
/// </summary>
/// <param name="screen">화면</param>
/// <returns>모니터 핸들</returns>
public IntPtr GetMonitorHandle(Screen screen)
{
    IntPtr monitorHandle = MonitorFromPoint(screen.Bounds.Location, 0);

    return monitorHandle;
}

#endregion
#region 모니터 핸들 구하기 - GetMonitorHandle(screenIndex)

/// <summary>
/// 모니터 핸들 구하기
/// </summary>
/// <param name="screenIndex">화면 인덱스</param>
/// <returns>모니터 핸들</returns>
public IntPtr GetMonitorHandle(int screenIndex)
{
    Screen screen = Screen.AllScreens[screenIndex];

    IntPtr monitorHandle = GetMonitorHandle(screen);

    return monitorHandle;
}

#endregion

#region 포인트에서 모니터 구하기 - MonitorFromPoint(point, flag)

/// <summary>
/// 포인트에서 모니터 구하기
/// </summary>
/// <param name="point">포인트</param>
/// <param name="flag">플래그</param>
/// <returns>모니터 핸들</returns>
[DllImport("user32", CharSet = CharSet.Auto, ExactSpelling = true)]
private static extern IntPtr MonitorFromPoint(Point point, uint flag);

#endregion

using System;

using System.Drawing;

using System.Runtime.InteropServices;

using System.Windows.Forms;

#region 모니터 핸들 구하기 - GetMonitorHandle(screen)

/// <summary>

/// 모니터 핸들 구하기

/// </summary>

/// <param name="screen">화면</param>

/// <returns>모니터 핸들</returns>

public IntPtr GetMonitorHandle(Screen screen)

{

IntPtr monitorHandle = MonitorFromPoint(screen.Bounds.Location, 0);

return monitorHandle;

}

#endregion

#region 모니터 핸들 구하기 - GetMonitorHandle(screenIndex)

/// <summary>

/// 모니터 핸들 구하기

/// </summary>

/// <param name="screenIndex">화면 인덱스</param>

/// <returns>모니터 핸들</returns>

public IntPtr GetMonitorHandle(int screenIndex)

{

Screen screen = Screen.AllScreens[screenIndex];

IntPtr monitorHandle = GetMonitorHandle(screen);

return monitorHandle;

}

#endregion

#region 포인트에서 모니터 구하기 - MonitorFromPoint(point, flag)

/// <summary>

/// 포인트에서 모니터 구하기

/// </summary>

/// <param name="point">포인트</param>

/// <param name="flag">플래그</param>

/// <returns>모니터 핸들</returns>

[DllImport("user32", CharSet = CharSet.Auto, ExactSpelling = true)]

private static extern IntPtr MonitorFromPoint(Point point, uint flag);

#endregion

[C#/COMMON] 모니터 화면 끄기/켜기

■ 모니터 화면을 끄거나 켜는 방법을 보여준다. ▶ MonitorHelper.cs


using System;
using System.Runtime.InteropServices;
using System.Threading;

namespace TestProject
{
    /// <summary>
    /// 모니터 헬퍼
    /// </summary>
    public static class MonitorHelper
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Import
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 메시지 보내기 - SendMessage(windowHandle, message, wordParameter, longParameter)

        /// <summary>
        /// 메시지 보내기
        /// </summary>
        /// <param name="windowHandle">윈도우 핸들</param>
        /// <param name="message">메시지</param>
        /// <param name="wordParameter">WORD 매개 변수</param>
        /// <param name="longParameter">LONG 매개 변수</param>
        /// <returns>처리 결과</returns>
        [DllImport("user32.dll")]
        private static extern IntPtr SendMessage(IntPtr windowHandle, int message, IntPtr wordParameter, IntPtr longParameter);

        #endregion
        #region 마우스 이벤트 발생시키기 - mouse_event(flag, deltaX, deltaY, data, extraInformation)

        /// <summary>
        /// 마우스 이벤트 발생시키기
        /// </summary>
        /// <param name="flag">플래그</param>
        /// <param name="deltaX">델타 X</param>
        /// <param name="deltaY">델타 Y</param>
        /// <param name="data">데이터</param>
        /// <param name="extraInformation">부가 정보</param>
        [DllImport("user32.dll")]
        private static extern void mouse_event(int flag, int deltaX, int deltaY, int data, UIntPtr extraInformation);

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// WM_SYS_COMMAND
        /// </summary>
        private const int WM_SYS_COMMAND = 0x0112;

        /// <summary>
        /// SC_MONITOR_POWER
        /// </summary>
        private const int SC_MONITOR_POWER = 0xf170;

        /// <summary>
        /// MONITOR_SHUT_OFF
        /// </summary>
        private const int MONITOR_SHUT_OFF = 2;

        /// <summary>
        /// MOUSE_EVENT_FLAG_MOVE
        /// </summary>
        private const int MOUSE_EVENT_FLAG_MOVE = 0x0001;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 모니터 전원 끄기 - MonitorPowerOff()

        /// <summary>
        /// 모니터 전원 끄기
        /// </summary>
        public static void MonitorPowerOff()
        {
            SendMessage((IntPtr)0xffff, WM_SYS_COMMAND, (IntPtr)SC_MONITOR_POWER, (IntPtr)MONITOR_SHUT_OFF);
        }

        #endregion
        #region 모니터 전원 켜기 - MonitorPowerOn()

        /// <summary>
        /// 모니터 전원 켜기
        /// </summary>
        public static void MonitorPowerOn()
        {
            mouse_event(MOUSE_EVENT_FLAG_MOVE, 0, 1, 0, UIntPtr.Zero);

            Thread.Sleep(40);

            mouse_event(MOUSE_EVENT_FLAG_MOVE, 0, -1, 0, UIntPtr.Zero);
        }

        #endregion
    }
}

100

101

102

103

104

105

using System;

using System.Runtime.InteropServices;

using System.Threading;

namespace TestProject

{

/// <summary>

/// 모니터 헬퍼

/// </summary>

public static class MonitorHelper

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Import

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 메시지 보내기 - SendMessage(windowHandle, message, wordParameter, longParameter)

/// <summary>

/// 메시지 보내기

/// </summary>

/// <param name="windowHandle">윈도우 핸들</param>

/// <param name="message">메시지</param>

/// <param name="wordParameter">WORD 매개 변수</param>

/// <param name="longParameter">LONG 매개 변수</param>

/// <returns>처리 결과</returns>

[DllImport("user32.dll")]

private static extern IntPtr SendMessage(IntPtr windowHandle, int message, IntPtr wordParameter, IntPtr longParameter);

#endregion

#region 마우스 이벤트 발생시키기 - mouse_event(flag, deltaX, deltaY, data, extraInformation)

/// <summary>

/// 마우스 이벤트 발생시키기

/// </summary>

/// <param name="flag">플래그</param>

/// <param name="deltaX">델타 X</param>

/// <param name="deltaY">델타 Y</param>

/// <param name="data">데이터</param>

/// <param name="extraInformation">부가 정보</param>

[DllImport("user32.dll")]

private static extern void mouse_event(int flag, int deltaX, int deltaY, int data, UIntPtr extraInformation);

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// WM_SYS_COMMAND

/// </summary>

private const int WM_SYS_COMMAND = 0x0112;

/// <summary>

/// SC_MONITOR_POWER

/// </summary>

private const int SC_MONITOR_POWER = 0xf170;

/// <summary>

/// MONITOR_SHUT_OFF

/// </summary>

private const int MONITOR_SHUT_OFF = 2;

/// <summary>

/// MOUSE_EVENT_FLAG_MOVE

/// </summary>

private const int MOUSE_EVENT_FLAG_MOVE = 0x0001;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region 모니터 전원 끄기 - MonitorPowerOff()

/// <summary>

/// 모니터 전원 끄기

/// </summary>

public static void MonitorPowerOff()

{

SendMessage((IntPtr)0xffff, WM_SYS_COMMAND, (IntPtr)SC_MONITOR_POWER, (IntPtr)MONITOR_SHUT_OFF);

}

#endregion

#region 모니터 전원 켜기 - MonitorPowerOn()

/// <summary>

/// 모니터 전원 켜기

/// </summary>

public static void MonitorPowerOn()

{

mouse_event(MOUSE_EVENT_FLAG_MOVE, 0, 1, 0, UIntPtr.Zero);

Thread.Sleep(40);

mouse_event(MOUSE_EVENT_FLAG_MOVE, 0, -1, 0, UIntPtr.Zero);

}

#endregion

}

▶ Program.cs


using System.Threading;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            while(true)
            {
                MonitorHelper.MonitorPowerOff();

                Thread.Sleep(5000);

                MonitorHelper.MonitorPowerOn();

                Thread.Sleep(5000);
            }
        }

        #endregion
    }
}

using System.Threading;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

while(true)

{

MonitorHelper.MonitorPowerOff();

Thread.Sleep(5000);

MonitorHelper.MonitorPowerOn();

Thread.Sleep(5000);

}

#endregion

}

TestProject.zip

[C#/WPF] 듀얼 모니터 보조 화면 윈도우 열기

■ 듀얼 모니터에서 보조 화면 윈도우를 여는 방법을 보여준다. ▶ MainWindow.xaml.cs


using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace TestProject
{
    /// <summary>
    /// 메인 윈도우
    /// </summary>
    public partial class MainWindow : Window
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainWindow()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainWindow()
        {
            InitializeComponent();

            this.openButton.Click += openButton_Click;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 듀얼 모니터 보조 화면 창 열기 버튼 클릭시 처리하기 - openButton_Click(sender, e)

        /// <summary>
        /// 듀얼 모니터 보조 화면 창 열기 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void openButton_Click(object sender, RoutedEventArgs e)
        {
            System.Drawing.Rectangle rectangle = System.Windows.Forms.Screen.AllScreens[1].WorkingArea;

            Window window = new Window();

            window.Left                  = rectangle.Left;
            window.Top                   = rectangle.Top;
            window.Width                 = rectangle.Width;
            window.Height                = rectangle.Height;
            window.WindowStartupLocation = WindowStartupLocation.Manual;
            window.WindowState           = WindowState.Normal;
            window.WindowStyle           = WindowStyle.None;
            window.Topmost               = true;
            window.Owner                 = this;
            window.FontFamily            = new FontFamily("나눔고딕코딩");
            window.FontSize              = 16;

            Grid grid = new Grid();

            window.Content = grid;

            Button closeButton = new Button();

            closeButton.HorizontalAlignment = HorizontalAlignment.Center;
            closeButton.VerticalAlignment   = VerticalAlignment.Center;
            closeButton.Width               = 100;
            closeButton.Height              = 30;
            closeButton.Content             = "닫기";

            closeButton.Click += closeButton_Click;

            grid.Children.Add(closeButton);

            window.Show();

            window.WindowState = WindowState.Maximized;
        }

        #endregion
        #region 닫기 버튼 클릭시 처리하기 - closeButton_Click(sender, e)

        /// <summary>
        /// 닫기 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void closeButton_Click(object sender, RoutedEventArgs e)
        {
            Button button = sender as Button;

            ((button.Parent as Grid).Parent as Window).Close();
        }

        #endregion
    }
}

using System.Windows;

using System.Windows.Controls;

using System.Windows.Media;

namespace TestProject

{

/// <summary>

/// 메인 윈도우

/// </summary>

public partial class MainWindow : Window

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainWindow()

/// <summary>

/// 생성자

/// </summary>

public MainWindow()

{

InitializeComponent();

this.openButton.Click += openButton_Click;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 듀얼 모니터 보조 화면 창 열기 버튼 클릭시 처리하기 - openButton_Click(sender, e)

/// <summary>

/// 듀얼 모니터 보조 화면 창 열기 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void openButton_Click(object sender, RoutedEventArgs e)

{

System.Drawing.Rectangle rectangle = System.Windows.Forms.Screen.AllScreens[1].WorkingArea;

Window window = new Window();

window.Left = rectangle.Left;

window.Top = rectangle.Top;

window.Width = rectangle.Width;

window.Height = rectangle.Height;

window.WindowStartupLocation = WindowStartupLocation.Manual;

window.WindowState = WindowState.Normal;

window.WindowStyle = WindowStyle.None;

window.Topmost = true;

window.Owner = this;

window.FontFamily = new FontFamily("나눔고딕코딩");

window.FontSize = 16;

Grid grid = new Grid();

window.Content = grid;

Button closeButton = new Button();

closeButton.HorizontalAlignment = HorizontalAlignment.Center;

closeButton.VerticalAlignment = VerticalAlignment.Center;

closeButton.Width = 100;

closeButton.Height = 30;

closeButton.Content = "닫기";

closeButton.Click += closeButton_Click;

grid.Children.Add(closeButton);

window.Show();

window.WindowState = WindowState.Maximized;

}

#endregion

#region 닫기 버튼 클릭시 처리하기 - closeButton_Click(sender, e)

/// <summary>

/// 닫기 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void closeButton_Click(object sender, RoutedEventArgs e)

{

Button button = sender as Button;

((button.Parent as Grid).Parent as Window).Close();

}

#endregion

}

TestProject.zip

[C#/WPF] 듀얼 모니터에서 두번째 화면에 윈도우 표시하기

■ 듀얼 모니터에서 두번째 화면에 윈도우를 표시하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Windows;

if(System.Windows.Forms.SystemInformation.MonitorCount > 1)
{
    System.Drawing.Rectangle secondaryScreenRectangle = System.Windows.Forms.Screen.AllScreens[1].WorkingArea;

    Window window = new Window();

    window.Show();  // Show 메소드와 속성 설정의 순서가 중요하다.

    window.WindowStartupLocation = WindowStartupLocation.Manual;
    window.Left                  = secondaryScreenRectangle.Left;
    window.Top                   = secondaryScreenRectangle.Top;
    window.Width                 = secondaryScreenRectangle.Width;
    window.Height                = secondaryScreenRectangle.Height;
    window.WindowState           = WindowState.Maximized;
}

using System.Windows;

if(System.Windows.Forms.SystemInformation.MonitorCount > 1)

{

System.Drawing.Rectangle secondaryScreenRectangle = System.Windows.Forms.Screen.AllScreens[1].WorkingArea;

Window window = new Window();

window.Show(); // Show 메소드와 속성 설정의 순서가 중요하다.

window.WindowStartupLocation = WindowStartupLocation.Manual;

window.Left = secondaryScreenRectangle.Left;

window.Top = secondaryScreenRectangle.Top;

window.Width = secondaryScreenRectangle.Width;

window.Height = secondaryScreenRectangle.Height;

window.WindowState = WindowState.Maximized;

}

[C#/WINFORM] Screen 클래스 : AllScreens 정적 속성을 사용해 다른 모니터에서 폼 표시하기

■ Screen 클래스의 AllScreens 정적 속성을 사용해 다른 모니터에서 폼을 표시하는 방법을 보여준다. ▶ MainForm.cs


using System;
using System.Drawing;
using System.Windows.Forms;

namespace TestProject
{
    public partial class MainForm : Form
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainForm()
        {
            InitializeComponent();

            this.testButton.Click += testButton_Click;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 테스트 버튼 클릭시 처리하기 - testButton_Click(sender, e)

        /// <summary>
        /// 테스트 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void testButton_Click(object sender, EventArgs e)
        {
            Screen[] screenArray = Screen.AllScreens;

            if(screenArray.Length > 1)
            {
                Screen screen = (screenArray[0].WorkingArea.Contains(Location)) ? screenArray[1] : screenArray[0];

                Form form = new Form();

                form.Show(); // Show 메소드와 속성 설정의 순서가 중요하다.

                form.Location    = new Point(screen.Bounds.Left, 0);
                form.WindowState = FormWindowState.Maximized;
            }
        }

        #endregion
    }
}

using System;

using System.Drawing;

using System.Windows.Forms;

namespace TestProject

{

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

this.testButton.Click += testButton_Click;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 테스트 버튼 클릭시 처리하기 - testButton_Click(sender, e)

/// <summary>

/// 테스트 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void testButton_Click(object sender, EventArgs e)

{

Screen[] screenArray = Screen.AllScreens;

if(screenArray.Length > 1)

{

Screen screen = (screenArray[0].WorkingArea.Contains(Location)) ? screenArray[1] : screenArray[0];

Form form = new Form();

form.Show(); // Show 메소드와 속성 설정의 순서가 중요하다.

form.Location = new Point(screen.Bounds.Left, 0);

form.WindowState = FormWindowState.Maximized;

}

#endregion

}

TestProject.zip

[C#/COMMON] SendMessage API 함수 : 모니터 화면 끄기/켜기

■ SendMessage API 함수를 사용해 모니터 화면을 끄고 켜는 방법을 보여준다. ▶ WIN32Helper.cs


using System.Runtime.InteropServices;

namespace TestProject
{
    /// <summary>
    /// WIN32 헬퍼
    /// </summary>
    public static class WIN32Helper
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Import
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 메시지 보내기 - SendMessage(windowHandle, message, wordParameter, longParameter)

        /// <summary>
        /// 메시지 보내기
        /// </summary>
        /// <param name="windowHandle">윈도우 핸들</param>
        /// <param name="message">메시지</param>
        /// <param name="wordParameter">WORD 매개 변수</param>
        /// <param name="longParameter">LONG 매개 변수</param>
        /// <returns>처리 결과</returns>
        [DllImport("user32")]
        private static extern int SendMessage(int windowHandle, short message, int wordParameter, int longParameter);

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// HWND_BROADCAST
        /// </summary>
        private const int HWND_BROADCAST = 0xffff;

        /// <summary>
        /// SC_MONITORPOWER
        /// </summary>
        private const int SC_MONITORPOWER = 0xf170;

        /// <summary>
        /// WM_SYSCOMMAND
        /// </summary>
        private const short WM_SYSCOMMAND = 0x0112;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 모니터 전원 끄기 - MonitorPowerOff()

        /// <summary>
        /// 모니터 전원 끄기
        /// </summary>
        public static void MonitorPowerOff()
        {
            SendMessage(HWND_BROADCAST, WM_SYSCOMMAND, SC_MONITORPOWER, -1);
        }

        #endregion
        #region 모니터 전원 켜기 - MonitorPowerOn()

        /// <summary>
        /// 모니터 전원 켜기
        /// </summary>
        public static void MonitorPowerOn()
        {
            SendMessage(HWND_BROADCAST, WM_SYSCOMMAND, SC_MONITORPOWER, 2);
        }

        #endregion
    }
}

using System.Runtime.InteropServices;

namespace TestProject

{

/// <summary>

/// WIN32 헬퍼

/// </summary>

public static class WIN32Helper

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Import

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 메시지 보내기 - SendMessage(windowHandle, message, wordParameter, longParameter)

/// <summary>

/// 메시지 보내기

/// </summary>

/// <param name="windowHandle">윈도우 핸들</param>

/// <param name="message">메시지</param>

/// <param name="wordParameter">WORD 매개 변수</param>

/// <param name="longParameter">LONG 매개 변수</param>

/// <returns>처리 결과</returns>

[DllImport("user32")]

private static extern int SendMessage(int windowHandle, short message, int wordParameter, int longParameter);

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// HWND_BROADCAST

/// </summary>

private const int HWND_BROADCAST = 0xffff;

/// <summary>

/// SC_MONITORPOWER

/// </summary>

private const int SC_MONITORPOWER = 0xf170;

/// <summary>

/// WM_SYSCOMMAND

/// </summary>

private const short WM_SYSCOMMAND = 0x0112;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region 모니터 전원 끄기 - MonitorPowerOff()

/// <summary>

/// 모니터 전원 끄기

/// </summary>

public static void MonitorPowerOff()

{

SendMessage(HWND_BROADCAST, WM_SYSCOMMAND, SC_MONITORPOWER, -1);

}

#endregion

#region 모니터 전원 켜기 - MonitorPowerOn()

/// <summary>

/// 모니터 전원 켜기

/// </summary>

public static void MonitorPowerOn()

{

SendMessage(HWND_BROADCAST, WM_SYSCOMMAND, SC_MONITORPOWER, 2);

}

#endregion

}

▶ Program.cs


using System;
using System.Threading;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            Console.Title = "SendMessage API 함수 : 모니터 화면 끄기/켜기";

            WIN32Helper.MonitorPowerOff();

            Thread.Sleep(5000);

            WIN32Helper.MonitorPowerOn();
        }

        #endregion
    }
}

using System;

using System.Threading;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

Console.Title = "SendMessage API 함수 : 모니터 화면 끄기/켜기";

WIN32Helper.MonitorPowerOff();

Thread.Sleep(5000);

WIN32Helper.MonitorPowerOn();

}

#endregion

}

TestProject.zip

[C#/SILVERLIGHT] Application 클래스 : 듀얼 모니터에서 전체 화면 모드 유지하기

■ Application 클래스를 사용해 듀얼 모니터에서 전체 화면 모드를 유지하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Windows;
using System.Windows.Interop;

#region 전체 화면 고정하기 - PinFullScreen()

/// <summary>
/// 전체 화면 고정하기
/// </summary>
public void PinFullScreen()
{
    Application.Current.Host.Content.FullScreenOptions = FullScreenOptions.StaysFullScreenWhenUnfocused;
    Application.Current.Host.Content.IsFullScreen      = true;
}

#endregion

using System.Windows;

using System.Windows.Interop;

#region 전체 화면 고정하기 - PinFullScreen()

/// <summary>

/// 전체 화면 고정하기

/// </summary>

public void PinFullScreen()

{

Application.Current.Host.Content.FullScreenOptions = FullScreenOptions.StaysFullScreenWhenUnfocused;

Application.Current.Host.Content.IsFullScreen = true;

}

#endregion