Erstellen Sie einen angepassten PDF-Bericht mit IronPDF und optionalen Parametern. Sehen Sie die Ergebnisse in Aktion!
using IronPdf;
using System;
public class PdfReportGenerator
{
// Method to generate PDF with optional parameters
public static void CreatePdfReport(string htmlContent, string filePath = "Report.pdf", bool includeCharts = true, string reportTitle = "Monthly Report")
{
// Optional parameters allow customization of the report's title and content dynamically
var renderer = new ChromePdfRenderer();
// Customize the PDF document
renderer.RenderingOptions.TextHeader.CenterText = reportTitle;
renderer.RenderingOptions.TextFooter.CenterText = "Generated on " + DateTime.Now.ToString("dd-MM-yyyy");
renderer.RenderingOptions.MarginTop = 50; // Set the top margin
renderer.RenderingOptions.MarginBottom = 50; // Set the bottom margin
if (!includeCharts)
{
// Modify HTML content to remove chart sections if not included
htmlContent = htmlContent.Replace("<div class='charts'></div>", "");
}
// Render the HTML to PDF
PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Save the generated PDF to a file
pdf.SaveAs(filePath);
Console.WriteLine($"PDF report has been created at {filePath}");
}
static void Main()
{
License.LicenseKey = "License-Key";
string htmlTemplate = @"
<html>
<head>
<title>Monthly Report</title>
</head>
<body>
<h1>Monthly Performance Report</h1>
<p>This section contains text describing the overall performance for the month.</p>
<div class='charts'>
<h2>Sales Charts</h2>
<!-- Placeholder for charts -->
</div>
</body>
</html>";
// Call the CreatePdfReport method with different parameters
CreatePdfReport(htmlTemplate, "BasicReport.pdf", false, "Basic Monthly Report");
CreatePdfReport(htmlTemplate, "FullReport.pdf", true, "Detailed Monthly Report");
}
}
C# Optionale Parameter (So funktioniert es für Entwickler)
Regan Pun
29. April 2024
Teilen Sie:
Optionale Parameter oder optionale Argumente in C# bieten eine Möglichkeit, Funktionsaufrufe zu vereinfachen, indem einige Argumente weggelassen werden können. Diese Funktion verbessert die Lesbarkeit und Wartbarkeit des Codes, indem sie die Anzahl der erforderlichen überladenen Methoden reduziert. Wenn ein Parameter in einer Methodendefinition mit einem Standardwert deklariert wird, wird er optional, d.h. Sie können ihn beim Aufruf der Methode weglassen. Wir erforschen dieoptionale Parameter in C# und dieIronPDF-Bibliothek für .NET-PDF-Lösungen.
Definieren von optionalen Parametern in C#;
Grundlegende Syntax
Um einen optionalen Parameter zu definieren, weisen Sie ihm in der Deklaration der Methode einen Standardwert zu. Dieser Standardwert muss ein konstanter Ausdruck sein. So können Sie eine Methode mit einem oder mehreren optionalen Standardparametern in der Methodendefinition definieren:
public static void DisplayGreeting(string message, string end = "!")
{
Console.WriteLine(message + end);
}
public static void DisplayGreeting(string message, string end = "!")
{
Console.WriteLine(message + end);
}
Public Shared Sub DisplayGreeting(ByVal message As String, Optional ByVal [end] As String = "!")
Console.WriteLine(message & [end])
End Sub
$vbLabelText $csharpLabel
Im obigen Codeschnipsel ist 'end' ein optionaler Parameter mit dem Standardparameterwert '!'. Dadurch kann die Methode entweder mit oder ohne Angabe eines zweiten Arguments aufgerufen werden.
Methodenaufrufe mit optionalen Parametern
Es gibt zwei Möglichkeiten, die obige Methode aufzurufen:
Shared Sub Main()
DisplayGreeting("Hello") ' Outputs: Hello!
DisplayGreeting("Hello", "?") ' Outputs: Hello?
End Sub
$vbLabelText $csharpLabel
Beim ersten Aufruf wird das zweite Argument weggelassen und der Standardwert verwendet. Der zweite Aufruf liefert einen spezifischen Wert, der den Standardwert außer Kraft setzt.
Verwendung von benannten und optionalen Parametern
Benannte und optionale Parameter in C# verbessern die Übersichtlichkeit von Methodenaufrufen mit optionalen Parametern. Sie ermöglichen die Angabe der Parameter, denen Werte gegeben werden, indem sie direkt im Aufruf genannt werden.
Beispiel für die Verwendung benannter Parameter
// named parameters
public static void ConfigureDevice(string deviceName, bool enableLogging = false, int timeout = 30)
{
Console.WriteLine($"Configuring {deviceName}: Logging={(enableLogging ? "On" : "Off")}, Timeout={timeout}s");
}
// named parameters
public static void ConfigureDevice(string deviceName, bool enableLogging = false, int timeout = 30)
{
Console.WriteLine($"Configuring {deviceName}: Logging={(enableLogging ? "On" : "Off")}, Timeout={timeout}s");
}
' named parameters
Public Shared Sub ConfigureDevice(ByVal deviceName As String, Optional ByVal enableLogging As Boolean = False, Optional ByVal timeout As Integer = 30)
Console.WriteLine($"Configuring {deviceName}: Logging={(If(enableLogging, "On", "Off"))}, Timeout={timeout}s")
End Sub
$vbLabelText $csharpLabel
Sie können benannte Parameter verwenden, um Werte in anderer Reihenfolge anzugeben oder um optionale Parameter zu überspringen.
Shared Sub Main()
ConfigureDevice("Router", timeout:= 60)
End Sub
$vbLabelText $csharpLabel
Dieser Aufruf verwendet ein optionales Argument, um einen Wert für eine Zeitüberschreitung anzugeben, wobei der Standardwert für enableLogging verwendet wird.
Kombination von festen und optionalen Parametern
Methoden können beide erforderlichen Parameter haben(feste Argumente) und optionale Parameter. Erforderliche Parameter müssen in der Methodendeklaration immer vor den optionalen stehen, wie im folgenden Codeschnipsel zu sehen ist.
Code-Beispiel
public static void CreateProfile(string firstName, string lastName, int age = 25, string city = "Unknown")
{
Console.WriteLine($"Name: {firstName} {lastName}, Age: {age}, City: {city}");
}
public static void CreateProfile(string firstName, string lastName, int age = 25, string city = "Unknown")
{
Console.WriteLine($"Name: {firstName} {lastName}, Age: {age}, City: {city}");
}
Public Shared Sub CreateProfile(ByVal firstName As String, ByVal lastName As String, Optional ByVal age As Integer = 25, Optional ByVal city As String = "Unknown")
Console.WriteLine($"Name: {firstName} {lastName}, Age: {age}, City: {city}")
End Sub
$vbLabelText $csharpLabel
Aufrufen der Methode
static void Main()
{
CreateProfile("John", "Doe"); // Uses default age and city
CreateProfile("Jane", "Doe", 30, "New York"); // Specifies all parameters
}
static void Main()
{
CreateProfile("John", "Doe"); // Uses default age and city
CreateProfile("Jane", "Doe", 30, "New York"); // Specifies all parameters
}
Shared Sub Main()
CreateProfile("John", "Doe") ' Uses default age and city
CreateProfile("Jane", "Doe", 30, "New York") ' Specifies all parameters
End Sub
$vbLabelText $csharpLabel
Diese Flexibilität, Argumente wegzulassen, ermöglicht es, dieselbe Methode in verschiedenen Kontexten zu verwenden, ohne dass mehrere Überladungen erforderlich sind.
Standardwerte müssen konstante Ausdrücke sein
Die Standardparameter für optionale Argumente müssen konstante Ausdrücke sein, die zur Kompilierzeit ausgewertet werden. Dadurch wird sichergestellt, dass die Standardwerte immer stabil und vorhersehbar sind.
Korrekte Verwendung von Standardwerten
public static void SendEmail(string address, string subject = "No Subject", string body = "")
{
Console.WriteLine($"Sending email to {address}\nSubject: {subject}\nBody: {body}");
}
public static void SendEmail(string address, string subject = "No Subject", string body = "")
{
Console.WriteLine($"Sending email to {address}\nSubject: {subject}\nBody: {body}");
}
Imports Microsoft.VisualBasic
Public Shared Sub SendEmail(ByVal address As String, Optional ByVal subject As String = "No Subject", Optional ByVal body As String = "")
Console.WriteLine($"Sending email to {address}" & vbLf & "Subject: {subject}" & vbLf & "Body: {body}")
End Sub
$vbLabelText $csharpLabel
Überladen vs. optionale Parameter
Während bei der Methodenüberladung mehrere Methodensignaturen für verschiedene Anwendungsfälle erstellt werden müssen, können mit Hilfe optionaler Parameter mit einer einzigen Methode verschiedene Szenarien behandelt werden.
Vergleich durch Code
Überladene Methoden könnten wie folgt aussehen:
// method overloading
public static void Alert(string message)
{
Console.WriteLine(message);
}
public static void Alert(string message, bool urgent)
{
if (urgent)
Console.WriteLine("Urgent: " + message);
else
Console.WriteLine(message);
}
// method overloading
public static void Alert(string message)
{
Console.WriteLine(message);
}
public static void Alert(string message, bool urgent)
{
if (urgent)
Console.WriteLine("Urgent: " + message);
else
Console.WriteLine(message);
}
' method overloading
Public Shared Sub Alert(ByVal message As String)
Console.WriteLine(message)
End Sub
Public Shared Sub Alert(ByVal message As String, ByVal urgent As Boolean)
If urgent Then
Console.WriteLine("Urgent: " & message)
Else
Console.WriteLine(message)
End If
End Sub
$vbLabelText $csharpLabel
Eine gleichwertige Methode mit optionalen Parametern:
public static void Alert(string message, bool urgent = false)
{
if (urgent)
Console.WriteLine("Urgent: " + message);
else
Console.WriteLine(message);
}
public static void Alert(string message, bool urgent = false)
{
if (urgent)
Console.WriteLine("Urgent: " + message);
else
Console.WriteLine(message);
}
Public Shared Sub Alert(ByVal message As String, Optional ByVal urgent As Boolean = False)
If urgent Then
Console.WriteLine("Urgent: " & message)
Else
Console.WriteLine(message)
End If
End Sub
$vbLabelText $csharpLabel
Vorteile der Verwendung optionaler Parameter
Optionale Parameter vereinfachen die Methodenschnittstellen und verringern die Notwendigkeit zahlreicher Überladungen. Sie machen die Methoden flexibler und die Codebasis einfacher zu pflegen und zu verstehen.
Herausforderungen mit optionalen Parametern
Bei übermäßigem Gebrauch können optionale Parameter zu Verwirrung darüber führen, was jede Methode erwartet und für eine ordnungsgemäße Ausführung benötigt. Sie können die Absicht der Methode verschleiern, insbesondere wenn es viele Parameter gibt oder wenn die Standardwerte nicht selbsterklärend sind.
Bewährte Praktiken
Optionale Parameter begrenzen: Verwenden Sie optionale Parameter mit Bedacht, um übermäßig komplexe Methodensignaturen zu vermeiden.
Benannte Argumente verwenden: Verbessern Sie die Übersichtlichkeit von Methodenaufrufen, insbesondere beim Überspringen bestimmter optionaler Parameter.
Dokumentieren Sie die Standardwerte: Dokumentieren Sie, was jeder Parameter tut und was die Standardwerte bedeuten, um Missbrauch oder Verwirrung zu vermeiden.
Verwendung von IronPDF mit C# Optionale Parameter
IronPDF ist eine nützliche .NET-Bibliothek, die es Entwicklern ermöglicht, PDF-Dokumente direkt in ihren Anwendungen zu erstellen, zu bearbeiten und darzustellen. Eswandelt HTML effizient in PDF um für die PDF-Konvertierung. Dieses HTML kann in verschiedenen Formen vorliegen, z. B. als HTML-String, HTML-Datei oder URL. Sie ist ideal für Anwendungen, die eine dynamische Generierung von PDF-Dokumenten wie Rechnungen, Berichten oder benutzerdefinierten Inhalten erfordern. Mit IronPDF können Entwickler das .NET-Framework vollständig nutzen, um PDF-Dateien effizient zu verarbeiten.
Das herausragende Merkmal von IronPDF ist seine FähigkeithTML mühelos in PDF konvertieren, das Layouts und Stile beibehält. Es ist ideal zur Erstellung von PDFs aus webbasiertem Inhalt, wie Berichten, Rechnungen oder Dokumentationen. Sie können HTML-Dateien, URLs und HTML-Strings damit in PDF-Dateien konvertieren.
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// 1. Convert HTML String to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// 2. Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// 3. Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// 1. Convert HTML String to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// 2. Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// 3. Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}
Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim renderer = New ChromePdfRenderer()
' 1. Convert HTML String to PDF
Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
' 2. Convert HTML File to PDF
Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
' 3. Convert URL to PDF
Dim url = "http://ironpdf.com" ' Specify the URL
Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
pdfFromUrl.SaveAs("URLToPDF.pdf")
End Sub
End Class
$vbLabelText $csharpLabel
Durch die Kombination von IronPDF mit optionalen C#-Parametern lässt sich die Erstellung von PDF-Dokumenten vereinfachen. Durch die Verwendung optionaler Parameter können Entwickler flexible Methoden für die PDF-Erzeugung erstellen, die sich mit minimaler Methodenüberlastung an unterschiedliche Eingaben und Anforderungen anpassen können.
Code-Beispiel
Das folgende Beispiel zeigt, wie Sie IronPDF zusammen mit optionalen C#-Parametern verwenden können, um einen benutzerdefinierten PDF-Bericht aus einer einfachen HTML-Vorlage zu generieren, wobei Sie möglicherweise Details wie den Titel anpassen und festlegen können, ob bestimmte Berichtsabschnitte enthalten sein sollen:
using IronPdf;
using System;
public class PdfReportGenerator
{
// Method to generate PDF with optional parameters
public static void CreatePdfReport(string htmlContent, string filePath = "Report.pdf", bool includeCharts = true, string reportTitle = "Monthly Report")
{
// Optional parameters allow customization of the report's title and content dynamically
var renderer = new ChromePdfRenderer();
// Customize the PDF document
renderer.RenderingOptions.TextHeader.CenterText = reportTitle;
renderer.RenderingOptions.TextFooter.CenterText = "Generated on " + DateTime.Now.ToString("dd-MM-yyyy");
renderer.RenderingOptions.MarginTop = 50; // Set the top margin
renderer.RenderingOptions.MarginBottom = 50; // Set the bottom margin
if (!includeCharts)
{
// Modify HTML content to remove chart sections if not included
htmlContent = htmlContent.Replace("<div class='charts'></div>", "");
}
// Render the HTML to PDF
PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Save the generated PDF to a file
pdf.SaveAs(filePath);
Console.WriteLine($"PDF report has been created at {filePath}");
}
static void Main()
{
License.LicenseKey = "License-Key";
string htmlTemplate = @"
<html>
<head>
<title>Monthly Report</title>
</head>
<body>
<h1>Monthly Performance Report</h1>
<p>This section contains text describing the overall performance for the month.</p>
<div class='charts'>
<h2>Sales Charts</h2>
<!-- Placeholder for charts -->
</div>
</body>
</html>";
// Call the CreatePdfReport method with different parameters
CreatePdfReport(htmlTemplate, "BasicReport.pdf", false, "Basic Monthly Report");
CreatePdfReport(htmlTemplate, "FullReport.pdf", true, "Detailed Monthly Report");
}
}
using IronPdf;
using System;
public class PdfReportGenerator
{
// Method to generate PDF with optional parameters
public static void CreatePdfReport(string htmlContent, string filePath = "Report.pdf", bool includeCharts = true, string reportTitle = "Monthly Report")
{
// Optional parameters allow customization of the report's title and content dynamically
var renderer = new ChromePdfRenderer();
// Customize the PDF document
renderer.RenderingOptions.TextHeader.CenterText = reportTitle;
renderer.RenderingOptions.TextFooter.CenterText = "Generated on " + DateTime.Now.ToString("dd-MM-yyyy");
renderer.RenderingOptions.MarginTop = 50; // Set the top margin
renderer.RenderingOptions.MarginBottom = 50; // Set the bottom margin
if (!includeCharts)
{
// Modify HTML content to remove chart sections if not included
htmlContent = htmlContent.Replace("<div class='charts'></div>", "");
}
// Render the HTML to PDF
PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Save the generated PDF to a file
pdf.SaveAs(filePath);
Console.WriteLine($"PDF report has been created at {filePath}");
}
static void Main()
{
License.LicenseKey = "License-Key";
string htmlTemplate = @"
<html>
<head>
<title>Monthly Report</title>
</head>
<body>
<h1>Monthly Performance Report</h1>
<p>This section contains text describing the overall performance for the month.</p>
<div class='charts'>
<h2>Sales Charts</h2>
<!-- Placeholder for charts -->
</div>
</body>
</html>";
// Call the CreatePdfReport method with different parameters
CreatePdfReport(htmlTemplate, "BasicReport.pdf", false, "Basic Monthly Report");
CreatePdfReport(htmlTemplate, "FullReport.pdf", true, "Detailed Monthly Report");
}
}
Imports IronPdf
Imports System
Public Class PdfReportGenerator
' Method to generate PDF with optional parameters
Public Shared Sub CreatePdfReport(ByVal htmlContent As String, Optional ByVal filePath As String = "Report.pdf", Optional ByVal includeCharts As Boolean = True, Optional ByVal reportTitle As String = "Monthly Report")
' Optional parameters allow customization of the report's title and content dynamically
Dim renderer = New ChromePdfRenderer()
' Customize the PDF document
renderer.RenderingOptions.TextHeader.CenterText = reportTitle
renderer.RenderingOptions.TextFooter.CenterText = "Generated on " & DateTime.Now.ToString("dd-MM-yyyy")
renderer.RenderingOptions.MarginTop = 50 ' Set the top margin
renderer.RenderingOptions.MarginBottom = 50 ' Set the bottom margin
If Not includeCharts Then
' Modify HTML content to remove chart sections if not included
htmlContent = htmlContent.Replace("<div class='charts'></div>", "")
End If
' Render the HTML to PDF
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
' Save the generated PDF to a file
pdf.SaveAs(filePath)
Console.WriteLine($"PDF report has been created at {filePath}")
End Sub
Shared Sub Main()
License.LicenseKey = "License-Key"
Dim htmlTemplate As String = "
<html>
<head>
<title>Monthly Report</title>
</head>
<body>
<h1>Monthly Performance Report</h1>
<p>This section contains text describing the overall performance for the month.</p>
<div class='charts'>
<h2>Sales Charts</h2>
<!-- Placeholder for charts -->
</div>
</body>
</html>"
' Call the CreatePdfReport method with different parameters
CreatePdfReport(htmlTemplate, "BasicReport.pdf", False, "Basic Monthly Report")
CreatePdfReport(htmlTemplate, "FullReport.pdf", True, "Detailed Monthly Report")
End Sub
End Class
$vbLabelText $csharpLabel
Hier ist die Vorschau der FullReport PDF-Datei:
Die Methode CreatePdfReport im Codebeispiel ist so strukturiert, dass sie PDF-Dokumente aus HTML-Inhalten generiert und mit optionalen Parametern wie dem Dateipfad, der Einbeziehung von Diagrammen und dem Berichtstitel Flexibilität bietet. Dadurch kann die Methode mit geringfügigen Codeanpassungen an unterschiedliche Berichtsanforderungen angepasst werden. Innerhalb der Methode werden die IronPDF-Einstellungen so angepasst, dass benutzerdefinierte Kopf- und Fußzeilen in die PDF-Datei eingefügt werden, die den Berichtstitel und das Erstellungsdatum des Berichts anzeigen.
Die Ränder werden ebenfalls konfiguriert, um das visuelle Layout des Dokuments zu verbessern. Je nachdem, ob der Parameter includeCharts true oder false ist, wird der HTML-Inhalt dynamisch geändert, um Diagramme entweder einzuschließen oder auszuschließen. Schließlich wird das möglicherweise geänderte HTML in ein PDF-Dokument umgewandelt und an einem bestimmten Ort gespeichert. Dieses Beispiel zeigt, wie optionale Parameter den Prozess der Erstellung maßgeschneiderter PDF-Berichte erheblich vereinfachen können.
Schlussfolgerung
Zusammenfassend lässt sich sagen, dass optionale Parameter es Entwicklern ermöglichen, flexibleren und wartbaren Code zu erstellen, indem sie den Bedarf an mehreren überladenen Methoden verringern. Durch die Kombination von optionalen C#-Parametern mit der IronPDF-Bibliothek können Entwickler effizient angepasste PDF-Dokumente erzeugen. Diese Integration vereinfacht nicht nur die Codebasis, sondern verbessert auch die Funktionalität und erleichtert die Anpassung an unterschiedliche Berichtsanforderungen oder Benutzerpräferenzen.
IronPDF selbst ist ein leistungsfähiges Tool für jeden .NET-Entwickler, der PDF-Funktionen in seine Anwendungen integrieren möchte, und bietet einekostenlose IronPDF-Testversion für Entwickler für diejenigen, die seine Fähigkeiten testen möchten. Für die laufende Nutzung sind Lizenzen ab $749 erhältlich und bieten eine kostengünstige Lösung für die professionelle PDF-Bearbeitung.
Regan schloss sein Studium an der University of Reading mit einem BA in Elektrotechnik ab. Bevor er zu Iron Software kam, konzentrierte er sich in seinen früheren Jobs auf einzelne Aufgaben. Was ihm bei Iron Software am meisten Spaß macht, ist das Spektrum der Aufgaben, die er übernehmen kann, sei es im Vertrieb, im technischen Support, in der Produktentwicklung oder im Marketing. Es macht ihm Spaß, die Art und Weise zu verstehen, wie Entwickler die Bibliothek von Iron Software nutzen, und dieses Wissen zu nutzen, um die Dokumentation und die Produkte kontinuierlich zu verbessern.
< PREVIOUS C# Substring (Wie es funktioniert für Entwickler)
NÄCHSTES > Resharper C# (Wie es für Entwickler funktioniert)