Lädt ein VB.NET 2003 Form deutlich schneller, wenn Controls im Designer auf Visible=false gesetzt und erst am Ende von Form_Load auf Visible=true gestellt werden?

Question

Lädt ein VB.NET 2003 Form deutlich schneller, wenn Controls im Designer auf Visible=false gesetzt und erst am Ende von Form_Load auf Visible=true gestellt werden?

Antwort

Verwandte Fragen

Wie prüfe ich in VB.NET 2003, ob ein TreeView gefüllt ist?

Wie addiert man in VB.NET 2003 die Werte "34 KB", "1.450 KB" und "100 KB"?

Gibt es eine Möglichkeit, in VB.NET 2003 die Farbe der SelectedItems eines ListViews zu beeinflussen?

Kann in VB.NET 2003 der AutoScroll eines Panels so manipuliert werden, dass nur ein Teil des Inhalts gescrollt wird und der Rest verborgen bleibt?

Wie ermittelt man in VB.NET 2003 die benötigte Höhe einer TreeView, damit kein Scrollbalken angezeigt wird?

Kann man in VB.NET 2003 das Aussehen des SelectedNode eines TreeView steuern?

Wie kann man in VB.NET 2003 bei MouseEnter einem Control ein MouseDown-Ereignis simulieren?

Wie selektiere ich in VB.NET 2003 einen TreeViewNode mit der rechten Maustaste?

Kann man mit VB.NET 2003 das Eigenschaften-Fenster von Dateien und Ordnern anzeigen?

Wie schneide ich einen Text in VB.NET 2003 nach einer maximalen Breite in Pixeln mithilfe von MeasureString ab?

Accepted Answer

Das Setzen von `Controls.Visible = False` für alle Steuerelemente auf der obersten Ebene im Entwurfsmodus und das anschließende Aktivieren (` = True`) am Ende von `_Load` kann in **VB.NET 2003** tatsächlich die Ladezeit des Formulars spürbar verkürzen – insbesondere bei komplexen Formularen mit vielen Controls. **Hintergrund:** Wenn ein Formular geladen wird, werden alle sichtbaren Controls erstellt, positioniert und gezeichnet. Ist `Visible = False`, werden die Controls zwar erstellt, aber nicht gezeichnet. Das Zeichnen (Rendern) der Controls ist oft der zeitaufwändigste Teil, besonders bei vielen oder komplexen Steuerelementen (z.B. mit vielen Unter-Controls, DataGrids, ListViews etc.). **Vorgehen:** 1. Im Designer alle Controls auf `Visible = False` setzen. 2. Am Ende von `Form_Load` (nach allen Initialisierungen) alle Controls auf `Visible = True` setzen. **Effekt:** Das Formular wird initial ohne die Zeichenoperationen geladen, was die Ladezeit deutlich reduzieren kann. Erst am Ende werden die Controls sichtbar gemacht und gezeichnet – dann aber in einem Rutsch, was meist schneller und für den Benutzer angenehmer ist. **Beachte:** - Das Formular „blitzt“ beim Anzeigen nicht auf, weil die Controls erst sichtbar werden, wenn alles fertig ist. - Eventuell müssen auch Unter-Controls (z.B. Controls in Panels oder GroupBoxes) berücksichtigt werden. - Manche Controls führen beim Sichtbarwerden zusätzliche Initialisierungen aus. **Fazit:** Ja, dieses Vorgehen kann die Ladezeit des Formulars in VB.NET 2003 deutlich verbessern, vor allem bei vielen oder komplexen Controls. Es ist ein bekannter Performance-Trick für ältere Windows-Forms-Anwendungen.

Accepted Answer

Um in VB.NET 2003 festzustellen, ob ein `TreeView`-Steuerelement gefüllt ist, prüfst du, ob das `Nodes`-Eigenschaft des TreeViews mindestens einen Knoten enthält. Das machst du so: ```... [mehr]

Accepted Answer

Um in VB.NET 2003 festzustellen, ob ein `TreeView`-Steuerelement gefüllt ist, prüfst du, ob das `Nodes`-Eigenschaft des TreeViews mindestens einen Knoten enthält. Das machst du so: ```vb.net If TreeView1.Nodes.Count > 0 Then ' TreeView ist gefüllt Else ' TreeView ist leer End If ``` `TreeView1` ist dabei der Name deines TreeView-Steuerelements. Die Eigenschaft `Nodes.Count` gibt die Anzahl der obersten Knoten zurück. Wenn du auch prüfen möchtest, ob untergeordnete Knoten vorhanden sind, musst du ggf. rekursiv durch die Knoten gehen, aber in den meisten Fällen reicht die Prüfung auf `Nodes.Count`.

Accepted Answer

Um in VB.NET 2003 die Werte "34 KB", "1.450 KB" und "100 KB" zu addieren, musst du die Zahlen aus den Strings extrahieren, in einen numerischen Datentyp umwandeln (z.B. `... [mehr]

Accepted Answer

Um in VB.NET 2003 die Werte "34 KB", "1.450 KB" und "100 KB" zu addieren, musst du die Zahlen aus den Strings extrahieren, in einen numerischen Datentyp umwandeln (z.B. `Double`), und dann addieren. Hier ein Beispiel, wie das geht: ```vbnet Dim str1 As String = "34 KB" Dim str2 As String = "1.450 KB" Dim str3 As String = "100 KB" ' " KB" entfernen und in Double umwandeln Dim val1 As Double = Double.Parse(str1.Replace(" KB", "").Replace(".", ",")) Dim val2 As Double = Double.Parse(str2.Replace(" KB", "").Replace(".", ",")) Dim val3 As Double = Double.Parse(str3.Replace(" KB", "").Replace(".", ",")) Dim summe As Double = val1 + val2 + val3 ' Ergebnis ausgeben Console.WriteLine(summe.ToString() & " KB") ``` **Hinweise:** - In manchen Ländereinstellungen wird das Komma als Dezimaltrennzeichen verwendet, in anderen der Punkt. Falls dein System den Punkt als Dezimaltrennzeichen erwartet, entferne das `.Replace(".", ",")`. - Das Ergebnis ist: `1584,45 KB` (bei deutscher Ländereinstellung). **Zusammengefasst:** 1. Entferne " KB" aus jedem String. 2. Ersetze ggf. das Dezimaltrennzeichen. 3. Wandle die Strings in Zahlen um. 4. Addiere die Zahlen. 5. Gib das Ergebnis aus.

Accepted Answer

In VB.NET 2003 (also .NET Framework 1.1) gibt es leider keine direkte Möglichkeit, die Farbe der ausgewählten Elemente (`SelectedItems`) eines `ListView`-Steuerelements im Detail- oder Repor... [mehr]

Accepted Answer

In VB.NET 2003 (also .NET Framework 1.1) gibt es leider keine direkte Möglichkeit, die Farbe der ausgewählten Elemente (`SelectedItems`) eines `ListView`-Steuerelements im Detail- oder Report-View zu ändern. Die Farbe für die Markierung wird vom Betriebssystem (Windows) vorgegeben und kann nicht einfach über Eigenschaften des Controls angepasst werden. **Mögliche Ansätze:** 1. **OwnerDraw verwenden:** Das `ListView`-Control in .NET 1.1 unterstützt das OwnerDraw-Feature **nur im View "List" und "SmallIcon"**, nicht aber im "Details"-Modus. Im "Details"-Modus ist OwnerDraw erst ab .NET 2.0 verfügbar. 2. **SubClassing und API-Hacks:** Mit erheblichem Aufwand und unter Verwendung von Windows-API-Funktionen (z.B. durch Subclassing und das Abfangen von WM_DRAWITEM-Nachrichten) kann man das Zeichnen beeinflussen. Das ist jedoch sehr komplex, fehleranfällig und wird nicht empfohlen, insbesondere in .NET 1.1. 3. **Alternative Controls:** Es gibt Drittanbieter-Controls, die mehr Flexibilität bieten, z.B. von [ComponentOne](https://www.grapecity.com/componentone), [DevExpress](https://www.devexpress.com/) oder [Infragistics](https://www.infragistics.com/). **Fazit:** Im Standard-`ListView` von VB.NET 2003 kannst du die Farbe der ausgewählten Items nicht direkt ändern. Ein Umstieg auf eine neuere .NET-Version (ab 2.0) oder die Verwendung eines Drittanbieter-Controls wäre notwendig, wenn du diese Funktionalität benötigst. **Weitere Infos:** - [Microsoft-Dokumentation zu ListView.OwnerDraw](https://learn.microsoft.com/de-de/dotnet/api/system.windows.forms.listview.ownerdraw) - [StackOverflow: Change ListView selected item color](https://stackoverflow.com/questions/1105046/change-listview-selected-item-color) Falls du eine bestimmte Ansicht oder einen bestimmten Anwendungsfall hast, kann eventuell ein Workaround gefunden werden, aber eine direkte Lösung gibt es in .NET 1.1 nicht.

Accepted Answer

In VB.NET 2003 (also .NET Framework 1.1) ist das Verhalten des `Panel`-Steuerelements mit aktiviertem `AutoScroll` so ausgelegt, dass beim Scrollen immer der gesamte Inhalt des Panels sichtbar gemacht... [mehr]

Accepted Answer

In VB.NET 2003 (also .NET Framework 1.1) ist das Verhalten des `Panel`-Steuerelements mit aktiviertem `AutoScroll` so ausgelegt, dass beim Scrollen immer der gesamte Inhalt des Panels sichtbar gemacht werden kann – also alles, was sich innerhalb der `Controls`-Sammlung und außerhalb des sichtbaren Bereichs befindet. Eine direkte Möglichkeit, das Standard-Scrolling so zu manipulieren, dass **nur ein Teil** des Inhalts gescrollt werden kann und der Rest dauerhaft verborgen bleibt, gibt es nicht. Das Panel-Scrolling bezieht sich immer auf den gesamten Inhalt. **Mögliche Workarounds:** 1. **Zwei Panels verwenden:** Teile den Inhalt auf zwei Panels auf – einen sichtbaren, scrollbaren Bereich und einen verborgenen Bereich (z.B. ein Panel außerhalb des sichtbaren Bereichs oder mit `Visible = False`). Nur der sichtbare Teil wird gescrollt. 2. **Custom Panel ableiten:** Erstelle eine eigene Panel-Klasse, die das Scrollverhalten überschreibt. In .NET 1.1 ist das allerdings recht aufwändig, da viele Scroll-Mechanismen intern ablaufen. Du könntest aber z.B. im `OnPaint`-Event oder durch gezieltes Verschieben von Controls das gewünschte Verhalten nachbilden. 3. **Controls dynamisch ein-/ausblenden:** Blende Controls, die nicht gescrollt werden sollen, einfach aus (`Visible = False`), solange sie nicht sichtbar sein sollen. So werden sie vom AutoScroll-Mechanismus ignoriert. **Beispiel für Variante 3:** ```vb ' Angenommen, Panel1 enthält mehrere Controls For Each ctrl As Control In Panel1.Controls If ctrl.Top > 200 Then ' z.B. alles unterhalb von 200px soll verborgen bleiben ctrl.Visible = False Else ctrl.Visible = True End If Next ``` **Fazit:** Das Standard-Panel in VB.NET 2003 bietet keine eingebaute Möglichkeit, das Scrollen auf einen Teilbereich zu beschränken. Du musst mit Workarounds wie Aufteilen, Ein-/Ausblenden oder einer eigenen Panel-Implementierung arbeiten. Weitere Infos zum Panel-Control: [Microsoft Docs: Panel.AutoScroll Property](https://learn.microsoft.com/en-us/dotnet/api/system.windows.forms.panel.autoscroll?view=netframework-1.1)

Accepted Answer

Um in VB.NET 2003 zu bestimmen, wie viel Höhe eine `TreeView` benötigt, damit kein vertikaler Scrollbalken angezeigt wird, musst du die Höhe aller sichtbaren Knoten (Nodes) berechnen. D... [mehr]

Accepted Answer

Um in VB.NET 2003 zu bestimmen, wie viel Höhe eine `TreeView` benötigt, damit kein vertikaler Scrollbalken angezeigt wird, musst du die Höhe aller sichtbaren Knoten (Nodes) berechnen. Die TreeView zeigt einen vertikalen Scrollbalken an, wenn die Summe der Knoten-Höhen größer als die aktuelle Höhe des Steuerelements ist. **Vorgehen:** 1. **Ermittle die Anzahl der sichtbaren Knoten** Das sind alle Knoten, die nicht durch einen zugeklappten Elternknoten verborgen sind. 2. **Ermittle die Höhe eines Knotens** Die Eigenschaft `ItemHeight` gibt die Höhe eines Knotens in Pixel an. 3. **Berechne die benötigte Höhe** Multipliziere die Anzahl der sichtbaren Knoten mit der Knoten-Höhe. **Beispielcode:** ```vb ' Funktion, um die Anzahl der sichtbaren Knoten zu zählen Private Function CountVisibleNodes(node As TreeNode) As Integer Dim count As Integer = 1 ' Der aktuelle Knoten ist sichtbar If node.IsExpanded Then For Each child As TreeNode In node.Nodes count += CountVisibleNodes(child) Next End If Return count End Function ' Gesamte sichtbare Knoten im TreeView zählen Private Function GetVisibleNodeCount(tree As TreeView) As Integer Dim count As Integer = 0 For Each node As TreeNode In tree.Nodes count += CountVisibleNodes(node) Next Return count End Function ' Benötigte Höhe berechnen Dim visibleNodes As Integer = GetVisibleNodeCount(Me.TreeView1) Dim neededHeight As Integer = visibleNodes * Me.TreeView1.ItemHeight ' Optional: Padding für Rahmen oder Header hinzufügen neededHeight += 4 ' je nach Design ggf. anpassen ' TreeView auf die berechnete Höhe setzen Me.TreeView1.Height = neededHeight ``` **Hinweise:** - Die Methode berücksichtigt nur die sichtbaren Knoten (also auch, ob Elternknoten eingeklappt sind). - Je nach Windows-Theme und Rahmen kann ein kleiner zusätzlicher Wert (z.B. 2–4 Pixel) nötig sein, damit wirklich kein Scrollbalken erscheint. - Die Eigenschaft `ItemHeight` ist in .NET 1.1 (und damit in VB.NET 2003) verfügbar. **Weitere Infos zur TreeView-Klasse:** [Microsoft Docs: TreeView.ItemHeight Property](https://learn.microsoft.com/en-us/dotnet/api/system.windows.forms.treeview.itemheight)

Accepted Answer

In VB.NET 2003 (also .NET Framework 1.1) ist die Möglichkeit, das Aussehen des `SelectedNode` eines `TreeView`-Steuerelements direkt zu beeinflussen, sehr eingeschränkt. Die TreeView-Kontrol... [mehr]

Accepted Answer

In VB.NET 2003 (also .NET Framework 1.1) ist die Möglichkeit, das Aussehen des `SelectedNode` eines `TreeView`-Steuerelements direkt zu beeinflussen, sehr eingeschränkt. Die TreeView-Kontrolle unterstützt in dieser Version keine OwnerDraw- oder erweiterte Styling-Optionen, wie sie in späteren .NET-Versionen eingeführt wurden. **Standardmöglichkeiten:** - Du kannst die Farben für alle Nodes über die Eigenschaften `BackColor`, `ForeColor`, `LineColor` und `HideSelection` des TreeView steuern. - Für die ausgewählte Node gibt es die Eigenschaften `SelectedImageIndex` und `SelectedImageKey`, um ein anderes Icon anzuzeigen. **Beispiel:** ```vb.net TreeView1.SelectedImageIndex = 1 ``` Das ändert das Bild der ausgewählten Node, aber nicht die Hintergrund- oder Textfarbe nur für die ausgewählte Node. **Individuelle Gestaltung (Workarounds):** - **Keine direkte Unterstützung:** Es gibt keine eingebaute Möglichkeit, nur das Aussehen der ausgewählten Node (z.B. Hintergrundfarbe, Schriftart) zu ändern. - **Möglicher Workaround:** Du könntest versuchen, die TreeView-API mit Subclassing und OwnerDraw über Windows-API zu erweitern, aber das ist sehr aufwändig und fehleranfällig, besonders in .NET 1.1. **Ab .NET 2.0:** Ab .NET 2.0 gibt es die Eigenschaft `DrawMode` und das Ereignis `DrawNode`, mit denen du das Aussehen jeder Node individuell gestalten kannst. In .NET 1.1 (VB.NET 2003) steht das aber **nicht** zur Verfügung. **Fazit:** In VB.NET 2003 kannst du das Aussehen der `SelectedNode` im TreeView nur sehr eingeschränkt beeinflussen (hauptsächlich das Icon). Für weitergehende Anpassungen wäre ein Upgrade auf eine neuere .NET-Version notwendig. **Weitere Infos:** - [TreeView-Klasse (Microsoft Docs)](https://learn.microsoft.com/de-de/dotnet/api/system.windows.forms.treeview?view=netframework-1.1) - [TreeView.DrawNode-Ereignis (ab .NET 2.0)](https://learn.microsoft.com/de-de/dotnet/api/system.windows.forms.treeview.drawnode?view=netframework-4.8.1)

Accepted Answer

In VB.NET 2003 gibt es keine eingebaute Möglichkeit, einem Control direkt ein „MouseDown“-Ereignis vorzutäuschen, da Ereignisse wie `MouseDown` normalerweise nur durch echte Benu... [mehr]

Accepted Answer

In VB.NET 2003 gibt es keine eingebaute Möglichkeit, einem Control direkt ein „MouseDown“-Ereignis vorzutäuschen, da Ereignisse wie `MouseDown` normalerweise nur durch echte Benutzereingaben ausgelöst werden. Allerdings kannst du das gewünschte Verhalten auf zwei Arten erreichen: **1. Die Ereignisbehandlung direkt aufrufen** Du kannst die Ereignisbehandlungsroutine für `MouseDown` direkt aus dem `MouseEnter`-Ereignis aufrufen. Beispiel: ```vb.net Private Sub MyControl_MouseEnter(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyControl.MouseEnter ' MouseEventArgs mit gewünschten Werten erzeugen Dim mouseArgs As New MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0) MyControl_MouseDown(sender, mouseArgs) End Sub Private Sub MyControl_MouseDown(ByVal sender As Object, ByVal e As MouseEventArgs) Handles MyControl.MouseDown ' Dein Code für MouseDown End Sub ``` **2. Windows-API verwenden, um ein echtes Ereignis zu simulieren** Du kannst mit der Windows-API ein echtes Mausklick-Ereignis simulieren. Das ist allerdings aufwändiger und kann Nebenwirkungen haben, da es wirklich einen Mausklick an der aktuellen Cursorposition auslöst: ```vb.net Declare Sub mouse_event Lib "user32" (ByVal dwFlags As Integer, ByVal dx As Integer, ByVal dy As Integer, ByVal cButtons As Integer, ByVal dwExtraInfo As Integer) Const MOUSEEVENTF_LEFTDOWN As Integer = &H2 Private Sub MyControl_MouseEnter(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyControl.MouseEnter mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0) End Sub ``` **Achtung:** Diese Methode klickt wirklich an der aktuellen Mausposition und ist daher meist nicht zu empfehlen. **Fazit:** Am einfachsten und sichersten ist es, die gewünschte Logik aus dem `MouseDown`-Handler in eine eigene Methode auszulagern und diese sowohl bei `MouseDown` als auch bei `MouseEnter` aufzurufen. Das „Vortäuschen“ eines MouseDown-Ereignisses ist in .NET nicht direkt vorgesehen, aber durch das manuelle Aufrufen der Handler kannst du das Verhalten nachbilden.

Accepted Answer

Um in VB.NET 2003 einen TreeNode im TreeView mit der rechten Maustaste auszuwählen, musst du das MouseDown-Event des TreeView-Steuerelements verwenden. Dort prüfst du, ob die rechte Maustast... [mehr]

Accepted Answer

Um in VB.NET 2003 einen TreeNode im TreeView mit der rechten Maustaste auszuwählen, musst du das MouseDown-Event des TreeView-Steuerelements verwenden. Dort prüfst du, ob die rechte Maustaste gedrückt wurde, und selektierst dann den Knoten unter dem Mauszeiger. Hier ein Beispiel: ```vb.net Private Sub TreeView1_MouseDown(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) Handles TreeView1.MouseDown If e.Button = MouseButtons.Right Then Dim node As TreeNode = TreeView1.GetNodeAt(e.X, e.Y) If Not node Is Nothing Then TreeView1.SelectedNode = node End If End If End Sub ``` **Erklärung:** - `TreeView1.GetNodeAt(e.X, e.Y)` gibt den Knoten an der Position des Mausklicks zurück. - Wenn ein Knoten gefunden wurde, wird er mit `TreeView1.SelectedNode = node` ausgewählt. So wird beim Rechtsklick der entsprechende Knoten selektiert.

Accepted Answer

Mit VB.NET 2003 gibt es keine direkte, eingebaute Methode, um das Eigenschaften-Fenster (also das Windows-Dialogfeld „Eigenschaften“ einer Datei oder eines Ordners) anzuzeigen. Allerdings... [mehr]

Accepted Answer

Mit VB.NET 2003 gibt es keine direkte, eingebaute Methode, um das Eigenschaften-Fenster (also das Windows-Dialogfeld „Eigenschaften“ einer Datei oder eines Ordners) anzuzeigen. Allerdings kannst du dies über die Windows-API erreichen, indem du die Funktion `ShellExecute` mit dem „properties“-Verb verwendest. Hier ein Beispiel, wie das in VB.NET 2003 funktionieren kann: ```vbnet Imports System.Runtime.InteropServices Public Class Form1 <DllImport("shell32.dll", CharSet:=CharSet.Auto)> Public Shared Function ShellExecute( _ ByVal hwnd As IntPtr, _ ByVal lpOperation As String, _ ByVal lpFile As String, _ ByVal lpParameters As String, _ ByVal lpDirectory As String, _ ByVal nShowCmd As Integer) As IntPtr End Function Private Sub ShowProperties(ByVal filePath As String) ShellExecute(Me.Handle, "properties", filePath, Nothing, Nothing, 1) End Sub ' Beispielaufruf, z.B. durch einen Button: Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click ShowProperties("C:\Pfad\zur\Datei.txt") End Sub End Class ``` **Hinweise:** - Ersetze `"C:\Pfad\zur\Datei.txt"` durch den Pfad zu deiner Datei oder deinem Ordner. - Das funktioniert sowohl für Dateien als auch für Ordner. - Die Methode öffnet das Standard-Eigenschaftenfenster von Windows für die angegebene Datei oder den Ordner. Weitere Informationen zu `ShellExecute` findest du z.B. in der [Microsoft-Dokumentation](https://learn.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-shellexecutea). **Achtung:** VB.NET 2003 ist sehr veraltet und wird nicht mehr unterstützt. Für neue Projekte empfiehlt sich eine aktuelle .NET-Version.

Accepted Answer

Um in VB.NET 2003 einen Text so abzuschneiden, dass er eine bestimmte Pixelbreite (z. B. 200 Pixel) nicht überschreitet, kannst du eine Schleife verwenden, die den Text Zeichen für Zeichen k... [mehr]

Accepted Answer

Um in VB.NET 2003 einen Text so abzuschneiden, dass er eine bestimmte Pixelbreite (z. B. 200 Pixel) nicht überschreitet, kannst du eine Schleife verwenden, die den Text Zeichen für Zeichen kürzt und mit `Graphics.MeasureString` prüft, ob die gewünschte Breite erreicht ist. Hier ein Beispiel: ```vb.net Function TruncateTextToWidth(g As Graphics, text As String, font As Font, maxWidth As Single) As String If g.MeasureString(text, font).Width <= maxWidth Then Return text End If Dim result As String = text While result.Length > 0 AndAlso g.MeasureString(result & "...", font).Width > maxWidth result = result.Substring(0, result.Length - 1) End While If result.Length < text.Length Then result &= "..." End If Return result End Function ``` **Verwendung:** ```vb.net Dim g As Graphics = Me.CreateGraphics() Dim font As New Font("Arial", 10) Dim maxWidth As Single = 200 Dim originalText As String = "Dies ist ein sehr langer Text, der abgeschnitten werden muss." Dim truncatedText As String = TruncateTextToWidth(g, originalText, font, maxWidth) g.Dispose() ``` **Hinweise:** - Die Funktion hängt von einem gültigen `Graphics`-Objekt ab. - Das Abschneiden erfolgt von rechts, und es wird "..." angehängt, wenn der Text gekürzt wurde. - Für bessere Performance kann ein binäres Suchverfahren verwendet werden, aber die Schleife ist für kurze Texte meist ausreichend. Weitere Infos zu [`Graphics.MeasureString`](https://learn.microsoft.com/de-de/dotnet/api/system.drawing.graphics.measurestring) findest du in der Microsoft-Dokumentation.