1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public class CONSOLE_FONT_INFOEX
    {
        private int cbSize;
        public CONSOLE_FONT_INFOEX()
        {
            cbSize = Marshal.SizeOf(typeof(CONSOLE_FONT_INFOEX));
        }
        public int FontIndex;
        public short FontWidth;
        public short FontHeight;
        public int FontFamily;
        public int FontWeight;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
        public string FaceName;
    }

    class ConsoleHelper
    {
        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
        extern static bool GetCurrentConsoleFontEx(IntPtr hConsoleOutput, bool bMaximumWindow, [In, Out] CONSOLE_FONT_INFOEX lpConsoleCurrentFont);

        public static void GetConsoleFont()
        {
            //Need to use reflection to obtain pointer to the console output buffer
            Type consoleType = typeof(Console);

            IntPtr _consoleOutputHandle = (IntPtr)consoleType.InvokeMember(
              "_consoleOutputHandle",
              BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.GetField,
              null,
              null,
              null);

            //Obtain the current console font index
            CONSOLE_FONT_INFOEX currentFont = new CONSOLE_FONT_INFOEX();
            bool success = GetCurrentConsoleFontEx( _consoleOutputHandle, false, currentFont);


            // Hier ein BreakPoint um mir den Inhalt von currentFont anzusehen
        }
    }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:

        /// <summary>
        /// returns the current console's output handle as an IntPtr, if it exists
        /// </summary>
        /// <returns>either the current console's output handle, or IntPtr.Zero</returns>
        public static IntPtr getConsoleOutputHandle()
        {
            Type consoleType = typeof(System.Console);

            // for some reason .InvokeMember wasn't working for me, but this strikes me
            // as a bit more clear anyway.  might just be me.  but, it does seem to work.
            FieldInfo _consoleOutputHandle_fieldinfo =
                consoleType.GetField("_consoleOutputHandle", BindingFlags.NonPublic | BindingFlags.Static);

            IntPtr RetVal;

            // after some testing, i realized that the only time i got a value back for the
            // handle was when i poked around in System.Console in the watch window.  after
            // much playing around i finally found that the following works to initialize
            // the handles.  this may have been my issue with the OP's code as well
            System.Console.BackgroundColor = System.Console.BackgroundColor;

            // this is probably a pretty safe operation as System.Console is a static type,
            // but just to be on the safe side might as well do a little exception handling.
            try
            {
                // since System.Console is a static class/type, you just pass null where an
                // object is requested, apparently. i have checked this in the debugger and
                // it does work, so i'll just take people's word for it.
                RetVal = (IntPtr)_consoleOutputHandle_fieldinfo.GetValue(null);
            }

            // not really doing anything if there's an exception; not much to do. could give a
            // parameter name if you wanted to for logging and such.
            catch (Exception)
            {
                RetVal = IntPtr.Zero;
            }

            return RetVal;
        }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    private class CONSOLE_FONT_INFOEX
    {
        private int cbSize;

        public int FontIndex;
        public short FontWidth;
        public short FontHeight;
        public int FontFamily;
        public int FontWeight;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
        public string FaceName;

        public CONSOLE_FONT_INFOEX()
        {
            cbSize = Marshal.SizeOf(typeof(CONSOLE_FONT_INFOEX));
        }
    }                    

1:

new Font(fontInfo.FaceName, fontInfo.FontHeight)                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:

    public class ConsoleHelper
    {
        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
        private extern static bool GetCurrentConsoleFontEx(IntPtr hConsoleOutput, bool bMaximumWindow, [In, Out] CONSOLE_FONT_INFOEX lpConsoleCurrentFont);

        [DllImport("gdi32.dll", EntryPoint = "GetGlyphIndicesW")]
        private static extern uint GetGlyphIndices([In] IntPtr hdc, [In] [MarshalAs(UnmanagedType.LPTStr)] string lpsz, int c, [Out] ushort[] pgi, uint fl);

        [DllImport("gdi32.dll")]
        private static extern IntPtr SelectObject(IntPtr hdc, IntPtr hgdiobj);

        private const uint GGI_MARK_NONEXISTING_GLYPHS = 0x01;
        private static Graphics _graphics = Graphics.FromImage(new Bitmap(1, 1));


        public static bool DoesGlyphExist(char c)
        {
            var fontInfo = GetCurrentConsoleFontEx();
            return DoesGlyphExist(c, new Font(fontInfo.FaceName, fontInfo.FontHeight));
        }


        public static bool DoesGlyphExist(char c, Font font)
        {
            IntPtr hdc = _graphics.GetHdc();
            ushort[] glyphIndices;

            try
            {
                IntPtr hfont = font.ToHfont();

                SelectObject(hdc, hfont);

                string testString = new string(c, 1);
                glyphIndices = new ushort[testString.Length];

                GetGlyphIndices(hdc, testString, testString.Length, glyphIndices, GGI_MARK_NONEXISTING_GLYPHS);

            }
            finally
            {
                _graphics.ReleaseHdc(hdc);
            }

            return (glyphIndices[0] != 0xffff);
        }

        public static CONSOLE_FONT_INFOEX GetCurrentConsoleFontEx()
        {
            Type consoleType = typeof(Console);
            IntPtr _consoleOutputHandle = getConsoleOutputHandle();

            CONSOLE_FONT_INFOEX currentFont = new CONSOLE_FONT_INFOEX();
            bool success = GetCurrentConsoleFontEx( _consoleOutputHandle, false, currentFont);

            return currentFont;
        }

        private static IntPtr getConsoleOutputHandle()
        {
            Type consoleType = typeof(System.Console);
            FieldInfo _consoleOutputHandle_fieldinfo = consoleType.GetField("_consoleOutputHandle", BindingFlags.NonPublic | BindingFlags.Static);
            Console.BackgroundColor = System.Console.BackgroundColor;

            IntPtr RetVal;

            try
            {
                RetVal = (IntPtr)_consoleOutputHandle_fieldinfo.GetValue(null);
            }
            catch (Exception)
            {
                RetVal = IntPtr.Zero;
            }

            return RetVal;
        }    
    }