C# Trying to get for each Display.displays[] the FriendlyName and VendorsName

I am trying to collect information on each Display.displays[].
Current the code gets for each Display.displays[]

• public string Availability { get; set; }
• public int ScreenHeight { get; set; }
• public int ScreenWidth { get; set; }
• public Rect MonitorArea { get; set; }
• public int MonitorTop { get; set; }
• public int MonitorLeft { get; set; }
• public string DeviceName { get; set; }

But I need to also get for each Display.displays[] connected to the system:

• public string FriendlyName { get; set; }
• public string VendorsName { get; set; }

Code (CSharp):

1. using UnityEngine;
2. using System;
3. using System.Collections.Generic;
4. using System.Runtime.InteropServices;
5.  
6. namespace BrotenTech
7. {
8.     /// <summary>
9.     /// Find out about which monitors are made available by the system.
10.     /// </summary>
11.     public abstract class WindowsMultiDisplayTools
12.     {
13.         #region Multi-Display Detection
14.         private delegate bool MonitorEnumDelegate(IntPtr hMonitor, IntPtr hdcMonitor, ref Rect lprcMonitor, IntPtr dwData);
15.  
16.         [DllImport("user32.dll")]
17.         private static extern bool EnumDisplayMonitors(IntPtr hdc, IntPtr lprcClip, MonitorEnumDelegate lpfnEnum, IntPtr dwData);
18.  
19.         [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
20.         private struct MonitorInfo
21.         {
22.             public uint Size;
23.             public RectNative Monitor;
24.             public RectNative WorkArea;
25.             public uint Flags;
26.             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
27.             public string DeviceName;
28.         }
29.  
30.         [StructLayout(LayoutKind.Sequential)]
31.         private struct RectNative
32.         {
33.             public int Left;
34.             public int Top;
35.             public int Right;
36.             public int Bottom;
37.         }
38.  
39.         [DllImport("user32.dll", CharSet = CharSet.Auto)]
40.         private static extern bool GetMonitorInfo(IntPtr hmon, ref MonitorInfo monitorinfo);
41.         #endregion
42.  
43.         /// <summary>
44.         /// The struct that contains the display information
45.         /// </summary>
46.         public class DisplayInfo
47.         {
48.             public string Availability { get; set; }
49.             public int ScreenHeight { get; set; }
50.             public int ScreenWidth { get; set; }
51.             public Rect MonitorArea { get; set; }
52.             public int MonitorTop { get; set; }
53.             public int MonitorLeft { get; set; }
54.             public string DeviceName { get; set; }
55.             public string FriendlyName { get; set; }
56.             public string VendorsName { get; set; }
57.         }
58.  
59.         /// <summary>
60.         /// Returns the number of Displays using the Win32 functions.
61.         /// </summary>
62.         /// <returns>A collection of DisplayInfo with information about each monitor.</returns>
63.         public static List<DisplayInfo> QueryDisplays()
64.         {
65.             var Monitors = new List<DisplayInfo>();
66.  
67.             // Get the all Display Monitors.
68.             EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero,
69.                 delegate (IntPtr hMonitor, IntPtr hdcMonitor, ref Rect lprcMonitor, IntPtr dwData)
70.                 {
71.                     MonitorInfo monitor = new MonitorInfo();
72.                     monitor.Size = (uint)Marshal.SizeOf(monitor);
73.                     monitor.DeviceName = null;
74.                     bool Success = GetMonitorInfo(hMonitor, ref monitor);
75.                     if (Success)
76.                     {
77.                         DisplayInfo displayinfo = new DisplayInfo();
78.                         displayinfo.ScreenWidth = monitor.Monitor.Right - monitor.Monitor.Left;
79.                         displayinfo.ScreenHeight = monitor.Monitor.Bottom - monitor.Monitor.Top;
80.                         displayinfo.MonitorArea = new Rect(monitor.Monitor.Left, monitor.Monitor.Top, displayinfo.ScreenWidth, displayinfo.ScreenHeight);
81.                         displayinfo.MonitorTop = monitor.Monitor.Top;
82.                         displayinfo.MonitorLeft = monitor.Monitor.Left;
83.                         displayinfo.Availability = monitor.Flags.ToString();
84.                         displayinfo.DeviceName = monitor.DeviceName;
85.                         displayinfo.FriendlyName = QueryDisplaysFriendlyName(monitor.DeviceName);
86.                         displayinfo.VendorsName = QueryDisplaysVendorName(monitor.DeviceName);
87.                         Monitors.Add(displayinfo);
88.                     }
89.                     return true;
90.                 }, IntPtr.Zero);
91.             return Monitors;
92.         }
93.         /// <summary>
94.         /// Returns the Friendly Name of a target Display using the Win32 functions.
95.         /// </summary>
96.         /// <returns>A string of with FriendlyName from DeviceName.</returns>
97.         private static string QueryDisplaysFriendlyName(string DeviceName)
98.         {
99.             string FriendlyName = null;
100.            
101.             // Get Friendly Name for the Device code goes here.
102.  
103.  
104.             return FriendlyName;
105.         }
106.         /// <summary>
107.         /// Returns the Vendors Name of a target Display using the Win32 functions.
108.         /// </summary>
109.         /// <returns>A string of with VendorName from DeviceName.</returns>
110.         private static string QueryDisplaysVendorName(string DeviceName)
111.         {
112.             string VendorName = null;
113.  
114.             // Get Vendors Name for the Device code goes here.
115.  
116.  
117.             return VendorName;
118.         }
119.     }
120. }

 

Please give me an example!
How can i get DeviceName of each monitor?
Thanks

 

bump