C# Signature:

[DllImport("kernel32.dll")]
    static extern bool GetCurrentConsoleFont(
        IntPtr hConsoleOutput,
        bool bMaximumWindow,
        out CONSOLE_FONT_INFO lpConsoleCurrentFont);

User-Defined Types:

    [StructLayout(LayoutKind.Sequential)]
    public struct CONSOLE_FONT_INFO
    {
        public int nFont;
        public Coord dwFontSize;
    }

Alternative Managed API:

Do you know one? Please contribute it!

Notes:

None.

Sample Code:

Here's a method that uses this method in conjunction with GetConsoleFontSize to return the size of the currently selected console font.

    private Coord GetCurrentFontSize()
    {
      //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_INFO currentFont;
        bool success = GetCurrentConsoleFont(
        _consoleOutputHandle,
        false,
        out currentFont);

       //Use that index to obtain font size    
        Coord coord = GetConsoleFontSize(_consoleOutputHandle, currentFont.nFont);
        return coord;
    }

    //-------------------------------------------------------------------------------------------------------------
    // i was unable to get the above code to work [.NET Framework 4.0, VS 2010] but i wrote
    // this set of functions to do the same thing, hope this helps someone.
    //
    // the nullable return types are gravy; you could of course return bool status values and
    // use out or ref COORD and CONSOLE_FONT_INFO parameters to return the values, if they exist
    //-------------------------------------------------------------------------------------------------------------

    /// <summary>
    /// purpose is to return the current console's COORD font size, if it exists
    /// </summary>
    /// <returns>either the COORD-based font size, or null</returns>
    public static COORD? getConsoleFontSize()
    {
        COORD? RetVal = null;
        CONSOLE_FONT_INFO? consoleFontOrNull = getConsoleFontInfo();

        if (consoleFontOrNull != null)
        {
            CONSOLE_FONT_INFO consoleFont = consoleFontOrNull.Value;
            //Use that index to obtain font size
            RetVal = GetConsoleFontSize(getConsoleOutputHandle(), consoleFont.nFont);
        }

        return RetVal;
    }

    /// <summary>
    /// returns the current console's CONSOLE_FONT_INFO structure, if it exists
    /// </summary>
    /// <returns>either the current console's CONSOLE_FONT_INFO structure, or null</returns>
    public static CONSOLE_FONT_INFO? getConsoleFontInfo()
    {
        CONSOLE_FONT_INFO currentFont;

        //Obtain the current console font index
        bool success = GetCurrentConsoleFont(getConsoleOutputHandle(), false, out currentFont);

        // probably could dispense with the currentFont variable, and just use
        // RetVal.Value in the call, but for clarity and safety's sake i have
        // separated them out
        CONSOLE_FONT_INFO? RetVal = null;

        // if the call succeeded, set the value of the nullable otherwise, leave it null
        if (success)
            RetVal = currentFont;

        return RetVal;
    }

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

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