Kann man in einer ConsoleApp mit Fonts arbeiten?

Hallo ich bin eher Anfänger -also seht mir bitte einiges nach 😃

Ich habe vor 2 Wochen ein Programm mit FreePascal geschrieben. Doch nun bei der Grafikdarstellung stoße ich an die Grenzen von Pascal und bin zu C# gekommen. (ich arbeite mit Visual Studio 2017)

Es geht darum, dass ich einen Text (string) mit einer bestimmten Schriftart und Schriftgrösse messen will. Also wie breit der Text in Pixeln ist, wenn ich ihn mit z.B. Tahoma, 26, bold ausgebe.
Angezeigt muss der Text gar nicht werden. Ich gebe meiner Funktion nur den Font und den Textstring und er misst die Breite und gibt mir den Wert als Integer zurück. Hier folgenden dirty Code habe ich zusammengebaut. Mehr brauche ich gar nicht.

 string Zeile1 = "Eins zwei drei vier fünf sechs sieben acht neun";
 
            b =25; //Fontsize, später mal variabel
            
           FontFamily fontFamily = new FontFamily("Tahoma");
            Font Schrift = new Font(
               fontFamily,
              b, 
               FontStyle.Bold,
               GraphicsUnit.Point);

            Bitmap bitmap = new Bitmap(this.Width, this.Height, 
            System.Drawing.Imaging.PixelFormat.Format32bppArgb);
            Graphics g = System.Drawing.Graphics.FromImage(bitmap);
              g.Clear(Color.Empty);
       

            Size textSize = g.MeasureString(Zeile1, Schrift).ToSize();
         //Rückgabewert ist dann textSize.Width

Nun möchte ich diese Funktion in ein kleines Programm packen aber es soll keine Windows-Oberfläche haben sondern ein ConsolenApp werden. Ich rufe dieses Consolentool einfach mit den Parametern "Fontname"; "FontSize"; "FontStyle"; Textstring auf und kriege einen einfachen Integerwert zurück. (nämlich die Breite in Pixel.)

Nur kriege ich die Consolenapp nicht zum laufen weil er die Fontklassen nicht kennt. Ich habe auch schon versucht "using System.Windows.Forms;" ganz oben einzufügen aber das will er auch nicht.
Wie kann ich eine ConsolenApp erstellen, die intern mit Fonts arbeiten kann ohne sie je darstellen zu müssen?

Fonts in einer Konsolenanwendung werden durch den Konsolenclient bestimmt; nicht durch die Anwendung - jedenfalls die Anzeige.

Zur Berechnung eines Fonts in einer Bitmap gibt es einige Themen hier im Forum; das funktioniert prinzipiell natürlich auch in einer Konsolenanwendung.
Verwende die Suche und Du wirst einiges finden.

Wenn das using nicht greift, dann fehlt Dir vermutlich die Referenz auf die Bibliothek.

Die Farbe kannst du aber einfach ändern durch z.B.

Console.ForegroundColor = ConsoleColor.Cyan;

OK, ich habe es jetzt hinbekommen. Es läuft soweit alles wie ich es mir vorgestellt habe.

Nun habe ich eine andere Frage. Ich habe zu Testzwecken mir den Textstring in der gewünschten Schrift als Jpg ausgeben lassen. Da sieht er genauso aus wie wenn ich ihn auf dem "Form" ausgeben lasse. Soll ja auch so sein.

Nur eine Sache ist mir aufgefallen. Er ist immer eine Font.Size größer als bei Word oder Libreoffice.
D.h. Ich schreibe eine Zeile bei Word oder Libreoffice und die, ist sagen wir, bei Schriftgröße 25
760 Pixel breit.
Bei C# ist sie 790 Pixel breit. Bei FontSize "24" ist sie dann auch ~760 Pixel breit.
Es scheint so, dass die Schriftgröße immer um eins erhöht ist bei C#. Ich müsste also immer Font.Size-1 rechnen um auf die selbe Breite zu kommen wie bei Word oder Libreoffice.
Woran könnte das liegen?

Bitte beachte [Hinweis] Wie poste ich richtig? und beschränke Dich auf eine Frage pro Thread in Zukunft.

Zeig mal Dein Code; bezweifle, dass es in C# eine Regel gibt, die besagt dass die Schriftgröße +1 sei.
Macht wenig Sinn.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Drawing;
using System.Drawing.Imaging;
using System.Windows.Forms;
using System.Runtime.InteropServices;


public static int Getwitdhindll(int Fsize, String Text, String Fname, String FStyle) 
        {
                   

            try
            {
                FontStyle myFStyle = FontStyle.Regular;

                if (FStyle == "Bold")
                {

                    myFStyle = FontStyle.Bold; 
                }



                FontFamily myfontFamily = new FontFamily(Fname);
                Font Schrift = new Font(
                   myfontFamily,
                   Fsize,
                   myFStyle,
                   GraphicsUnit.Point);



                Bitmap bitmap = new Bitmap(2000, 200, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
                Graphics g = System.Drawing.Graphics.FromImage(bitmap);
                g.Clear(Color.Empty);
                g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
                Size textSize = g.MeasureString(Text, Schrift).ToSize();

                Rectangle textRect = new Rectangle(new Point( 10,10), textSize);
                g.FillRectangle(Brushes.White, textRect);

                g.DrawString(Text, Schrift, Brushes.Blue, new Point(10, 10));

                bitmap.Save("KontrollBild.jpg", ImageFormat.Jpeg);

                bitmap.Dispose();
                g.Dispose();
                return textSize.Width;
            }
            catch { return -1; }

        }
    }

Wie gesagt, alles (jede Texzeile) ist hier eine Stufe grösser als wenn ich es in Word oder Libreoffice schreibe.

Vergleichst Du Bilder, oder vergleichst Du Bild mit Word-Editor?
Es ist immer noch ein Rätsel, was genau Du vergleichst.

Ich schreibe eine Zeile in Word (nicht Wordpad) (Maßstab 100%)und mache einen Screenshot und lege den in ein Bildbearbeitungsprogramm und schneide die Zeile aus
Ich schreibe eine Zeile in Libreoffice (100%) ->Screen... ->und lege die Zeile auch in das BB-Programm und sie sind gleich breit!

Dann mache ich bei gleichen Fontparametern ein Jpg mit meinem C#-Tool. Öffne das auch im BB-Programm und schneide es aus. Und siehe da, es ist breiter bzw. in allen Dimensionen größer als die obigen zwei.

Dann erstelle ich ein Jpg mit meinem C#Tool, mit einer kleineren Schriftgröße (genau 1 weniger) lege das dazu, schneide es aus und siehe da ->es passt besser. (Wenn auch nicht aufs Pixel genau.)

Dir ist bewusst, dass Du hier Äpfel mit Birnen vergleichst?

Das eine ist ein Screenshot, das Deine Display-Settings des Rechners mit involvieren lässt (zB. Skalierung, DPI und Co) - und das andere ist wirklich ein rohes Bild.
Wenn Du was valides vergleichen willst, dann verwende die Image Export Funktion von Word - wobei diese ebenfalls genug Einstellungen möglich lässt.

Ich habe den Maßstaab auf 100%.
Jetzt habe ich die KontrollBild.jpg-Zeile mal als Bild in Word eingefügt. Und genau das Selbe. Der WordText ist eine Stufe kleiner als der Text im JPG.
Ausserdem ist der Text wenn ich ihn auf dem Form (oder wie das heisst) anzeigen lasse, genau so groß wie im Kontrollbild.jpg.

Das wird auch nicht besser wenn Du weiterhin versuchst Äpfel mit Birnen zu vergleichen.
Maßstab von Word 100% ist nur die Darstellung des Windows - nicht die des Bildes am Rechner oder des Outputs.

Ich finde bei Word keine Image Export Funktion.
Wie wäre es, wenn du es selber mal nachstellst?

Naja, ich versuch es jetzt noch ein mal zu erklären, dann geb ich auf.

Die Darstellung in einem Text-Editor wie Word oder einem anderen Office Programm ist nicht treu zur tatsächlichen Skalierung des Bildes - egal ob das nun auf 100% ist oder nicht.
Wenn Du Word auf 100% setzt ist die Darstellung auf Deinem Bildschirm trotzdem nicht 1:1 wie ein reales Papier in A4.
Ich würde fast wetten, wenn Du Dein Word als PDF exportierst (Export -> PDF) und das neben Dein aktuellen Word Editor hängst, dann ist das ebenfalls nicht 1000% 1:1.

Darüber hinaus dürfte das Bild, das Du da erzeugst, deutlich pixeliger sein als die Text-Darstellung und dessen Screenshot in Word.
Ergo: Äpfel und Birne.

PS: .NET zeichnet nicht selbst, sondern ist bei Bitmap nur ein Wrapper zu GDI+
DPI and Device-Independent Pixels
Les Dich in die Grundlagen ein; vielleicht verstehst es ja irgendwann 😃
Viel Glück!

Ich habe das KontrollBild ohne neu zu scalieren ausgedruckt.
Und dann habe ich die selbe Zeile bei Word ausgedruckt und beides mit Lineal gemessen.

Es bleibt dabei. Die Zeile, die als Bild gespeichert wurde, ist eine Stufe grösser.