C# Ref (Wie es für Entwickler funktioniert)

In C# wird die referenzschlüsselwort ist eine leistungsstarke Funktion, die es Methoden ermöglicht, den Parameterwert von übergebenen Variablen vom Referenztyp zu ändern. Wenn Sie wissen, wie ref zu verwenden ist, können Sie Ihre Fähigkeiten zur Verwaltung und Bearbeitung von Daten in Ihren Anwendungen verbessern.

Dieser Artikel führt Sie durch die Grundlagen des Schlüsselworts ref, seine Anwendung und die Feinheiten seiner Verwendung mit verschiedenen Datentypen. Wir lernen auch etwas über IronPDF-Bibliothek die eine PDF-Bibliothek ist.

Verstehen der Schiedsrichter-Parameter

Ein ref-Parameter ist ein Methodenparameter, der als Verweis auf die an die Methode übergebene Variable fungiert. Im Gegensatz zu Standardwertparametern, bei denen nur eine Kopie der Variablen übergeben wird, erlauben ref-Parameter der aufgerufenen Methode, den Wert der Originalvariablen zu ändern. Dieses Verhalten ist von entscheidender Bedeutung, wenn eine Methode den Zustand der ihr übergebenen Variablen aktualisieren soll.

Anhand des folgenden Beispiels soll die grundlegende Verwendung von ref demonstriert werden, wobei der Schwerpunkt darauf liegt, wie eine Variable vom Typ Referenz ihren Parameterwert bei Methodenaufrufen im selben Objekt beibehält:

class Program
{
    static void Main()
    {
        int number = 100;
        ModifyNumber(ref number);
        Console.WriteLine(number);
    }
    static void ModifyNumber(ref int number)
    {
        number = 200;
    }
}

class Program
{
    static void Main()
    {
        int number = 100;
        ModifyNumber(ref number);
        Console.WriteLine(number);
    }
    static void ModifyNumber(ref int number)
    {
        number = 200;
    }
}

Friend Class Program
	Shared Sub Main()
		Dim number As Integer = 100
		ModifyNumber(number)
		Console.WriteLine(number)
	End Sub
	Private Shared Sub ModifyNumber(ByRef number As Integer)
		number = 200
	End Sub
End Class

In diesem Beispiel deklariert die Methode Main eine Ganzzahl number und initialisiert sie auf 100. Dann ruft sie ModifyNumber auf und übergibt number als Parameter ref. In ModifyNumber wird der Wert von number auf 200 geändert. Da Zahl als Referenz übergeben wird, spiegelt sich die Änderung im ursprünglichen Wert in der Methode Haupt wider, und 200 wird auf der Konsole ausgegeben.

Funktionsweise der ref-Parameter

Wenn Sie einen Methodenparameter mit dem Schlüsselwort ref deklarieren, teilen Sie dem Compiler mit, dass der Parameter auf die ursprüngliche Variable verweist und nicht auf eine Kopie. Dies wird dadurch erreicht, dass nicht der tatsächliche Wert, sondern die Speicheradresse der Variablen übergeben wird. Sowohl die aufgerufene Methode als auch die aufrufende Methode greifen auf denselben Speicherplatz zu, was bedeutet, dass alle Änderungen am Parameter direkt an der ursprünglichen Variablen vorgenommen werden.

Der Schlüssel zum Verständnis von ref ist die Erkenntnis, dass es sowohl mit Werttypen als auch mit Referenztypen verwendet werden kann. Zu den Werttypen gehören einfache Datentypen wie Integer und Structs, während zu den Referenztypen Objekte und Arrays gehören. Obwohl Variablen vom Typ Referenz von Natur aus Speicheradressen enthalten, können Sie mit ref bei Referenztypen den eigentlichen Verweis und nicht nur den Inhalt des Objekts ändern.

Unterschiede zwischen ref und out

Sowohl das Schlüsselwort ref als auch das Schlüsselwort out ermöglichen zwar die Änderung der ursprünglichen Variablen, doch gibt es wichtige Unterschiede. Ein out-Parameter muss nicht initialisiert werden, bevor er an eine Methode übergeben wird. Umgekehrt erfordert ein ref-Parameter, dass die Variable initialisiert wird, bevor sie übergeben wird. Außerdem ist eine Methode, die einen out-Parameter verwendet, verpflichtet, einen Wert zuzuweisen, bevor die Methode zurückkehrt. Diese Anforderung gilt nicht für ref-Parameter.

So können Sie das Schlüsselwort out verwenden:

class Program
{
    static void Main()
    {
        int result;
        CalculateResult(out result);
        Console.WriteLine(result);
    }
    static void CalculateResult(out int calculation)
    {
        calculation = 20 * 5;
    }
}

class Program
{
    static void Main()
    {
        int result;
        CalculateResult(out result);
        Console.WriteLine(result);
    }
    static void CalculateResult(out int calculation)
    {
        calculation = 20 * 5;
    }
}

Friend Class Program
	Shared Sub Main()
		Dim result As Integer = Nothing
		CalculateResult(result)
		Console.WriteLine(result)
	End Sub
	Private Shared Sub CalculateResult(ByRef calculation As Integer)
		calculation = 20 * 5
	End Sub
End Class

In diesem Fall initialisiert CalculateResult die Berechnung innerhalb der Methode, und Main gibt das Ergebnis wieder.

Praktische Verwendung von ref bei der Methodenüberladung

ref kann auch bei der Methodenüberladung verwendet werden, wobei die Signatur der Methode durch das Schlüsselwort ref geändert wird. Methodensignaturen bestehen aus dem Methodennamen und den Parametertypen, einschließlich der Angabe, ob die Parameter als Referenz übergeben werden (ref)als Wert oder als Out-Parameter.

Erwägen Sie das Überladen von Methoden auf der Grundlage von ref und Wertparametern:

class Program
{
    static void Main()
    {
        int normalParameter = 10, refParameter = 10;
        IncrementValue(normalParameter);
        IncrementValue(ref refParameter);
        Console.WriteLine($"Normal: {normalParameter}, Ref: {refParameter}");
    }
    static void IncrementValue(int number)
    {
        number++;
    }
    static void IncrementValue(ref int number)
    {
        number++;
    }
}

class Program
{
    static void Main()
    {
        int normalParameter = 10, refParameter = 10;
        IncrementValue(normalParameter);
        IncrementValue(ref refParameter);
        Console.WriteLine($"Normal: {normalParameter}, Ref: {refParameter}");
    }
    static void IncrementValue(int number)
    {
        number++;
    }
    static void IncrementValue(ref int number)
    {
        number++;
    }
}

Friend Class Program
	Shared Sub Main()
		Dim normalParameter As Integer = 10, refParameter As Integer = 10
		IncrementValue(normalParameter)
		IncrementValue(refParameter)
		Console.WriteLine($"Normal: {normalParameter}, Ref: {refParameter}")
	End Sub
'INSTANT VB TODO TASK: VB does not allow method overloads which differ only in parameter ByVal/ByRef:
'ORIGINAL LINE: static void IncrementValue(int number)
	Private Shared Sub IncrementValue(ByVal number As Integer)
		number += 1
	End Sub
'INSTANT VB TODO TASK: VB does not allow method overloads which differ only in parameter ByVal/ByRef:
'ORIGINAL LINE: static void IncrementValue(ref int number)
	Private Shared Sub IncrementValue(ByRef number As Integer)
		number += 1
	End Sub
End Class

Hier wird IncrementValue überladen, wobei eine Version einen normalen Parameter und eine einen ref-Parameter annimmt. Die ref-Version erhöht die Originalvariable, während die normale Version nur eine Kopie ändert.

Einführung in IronPDF

IronPDF ist eine umfassende .NET-Bibliothek, die für die Arbeit mit PDF-Dokumenten entwickelt wurde. Es wurde hauptsächlich in C# entwickelt und konzentriert sich auf die Vereinfachung der Erstellung und Bearbeitung von PDFs aus HTML-Inhalten. Durch den Einsatz einer Chrome Rendering Engine liefert IronPDF qualitativ hochwertige, pixelgenaue PDF-Dokumente, die die Feinheiten von HTML, CSS, JavaScript und Bildinhalten berücksichtigen.

Diese Bibliothek ist vielseitig und unterstützt eine breite Palette von .NET-Umgebungen, einschließlich .NET-Framework, .NET Core und .NET-Standard, was sie für verschiedene Anwendungen von Desktop- bis zu webbasierten Systemen geeignet macht. IronPDF unterstützt nicht nur die Erstellung von PDFs, sondern bietet auch Funktionen zur Bearbeitung, Sicherung und Konvertierung von PDFs in andere Formate.

Diese Fähigkeit erstreckt sich auf das Extrahieren von Text und Bildern, das Ausfüllen von Formularen und sogar das Anbringen digitaler Signaturen, was eine umfassende Handhabung von PDF-Dokumenten innerhalb von .NET-Anwendungen gewährleistet.

Integration von IronPDF mit C# und ref Keyword

IronPDF kann in C# integriert werden, um die robusten Funktionen der Sprache zu nutzen, einschließlich der Verwendung des Schlüsselworts ref zur Übergabe von Parametern per Referenz. Diese Integration ermöglicht eine dynamische PDF-Erzeugung, bei der der Inhalt von Variablen abhängen kann, deren Werte zur Laufzeit bestimmt werden.

Um die Integration von IronPDF mit C# unter Verwendung des Schlüsselworts ref zu veranschaulichen, betrachten wir ein Szenario, in dem wir einen PDF-Bericht erstellen möchten, der einen dynamisch berechneten Wert enthält. Dieser Wert wird in einer Methode berechnet, die einen ref-Parameter akzeptiert, so dass die Methode diesen Wert ändern kann, was sich dann in der generierten PDF-Datei widerspiegelt.

Code-Beispiel: Generierung einer PDF-Datei mit dynamischem Inhalt mit ref

Der folgende C#-Code veranschaulicht die Verwendung von IronPDF in Verbindung mit dem Schlüsselwort ref, um ein PDF-Dokument zu erzeugen. Der Code berechnet einen Wert, ändert ihn über eine Methode, die einen ref-Parameter akzeptiert, und verwendet dann IronPDF, um eine PDF-Datei zu erzeugen, die diesen dynamischen Inhalt enthält.

using IronPdf;
using System;
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        // Initialize the value
        int totalSales = 150;
        // Modify the value within the method using 'ref'
        AddMonthlyBonus(ref totalSales);
        // Use IronPDF to generate a PDF report
        var Renderer = new ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf($"<h1>Monthly Sales Report</h1><p>Total Sales, including bonus: {totalSales}</p>");
        // Save the PDF to a file
        PDF.SaveAs("MonthlySalesReport.pdf");
        // Confirm the PDF has been generated
        Console.WriteLine("PDF generated successfully. Check your project directory.");
    }
    static void AddMonthlyBonus(ref int sales)
    {
        // Assume a bonus of 10% of the sales
        sales += (int)(sales * 0.1);
    }
}

using IronPdf;
using System;
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        // Initialize the value
        int totalSales = 150;
        // Modify the value within the method using 'ref'
        AddMonthlyBonus(ref totalSales);
        // Use IronPDF to generate a PDF report
        var Renderer = new ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf($"<h1>Monthly Sales Report</h1><p>Total Sales, including bonus: {totalSales}</p>");
        // Save the PDF to a file
        PDF.SaveAs("MonthlySalesReport.pdf");
        // Confirm the PDF has been generated
        Console.WriteLine("PDF generated successfully. Check your project directory.");
    }
    static void AddMonthlyBonus(ref int sales)
    {
        // Assume a bonus of 10% of the sales
        sales += (int)(sales * 0.1);
    }
}

Imports IronPdf
Imports System
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		' Initialize the value
		Dim totalSales As Integer = 150
		' Modify the value within the method using 'ref'
		AddMonthlyBonus(totalSales)
		' Use IronPDF to generate a PDF report
		Dim Renderer = New ChromePdfRenderer()
		Dim PDF = Renderer.RenderHtmlAsPdf($"<h1>Monthly Sales Report</h1><p>Total Sales, including bonus: {totalSales}</p>")
		' Save the PDF to a file
		PDF.SaveAs("MonthlySalesReport.pdf")
		' Confirm the PDF has been generated
		Console.WriteLine("PDF generated successfully. Check your project directory.")
	End Sub
	Private Shared Sub AddMonthlyBonus(ByRef sales As Integer)
		' Assume a bonus of 10% of the sales
		sales += CInt(Math.Truncate(sales * 0.1))
	End Sub
End Class

In diesem Beispiel beginnt totalSales bei 150. Die Methode AddMonthlyBonus bezieht sich mit dem Schlüsselwort ref auf diesen Wert, berechnet einen Bonus von 10 % und addiert ihn zum ursprünglichen Umsatzwert. IronPDF generiert dann ein PDF-Dokument, das ein HTML-Snippet enthält, das den Gesamtumsatz einschließlich des Bonus ausweist. Das endgültige Dokument wird lokal als "MonthlySalesReport.pdf" gespeichert.

Schlussfolgerung

Das Verständnis des ref-Schlüsselworts in C# bietet ein wertvolles Werkzeug für die Verwaltung der Datenübergabe zwischen Methoden. Indem ref den Methoden erlaubt, die ursprünglichen Werte der an sie übergebenen Parameter direkt zu ändern, können Sie Ihre Methoden flexibler und leistungsfähiger machen.

Je mehr Erfahrung Sie mit ref sammeln, desto besser werden Sie verstehen, wann und wie Sie es effektiv einsetzen können, um Ihre Programmieranforderungen zu erfüllen. IronPDF bietet eine kostenloser Test beginnt bei $749.