C# Ref (Funktionsweise für Entwickler)

Verstehen von ref-Parametern

Ein ref Parameter ist ein Methodenparameter, der als Referenz auf die an die Methode übergebene Variable fungiert. Im Gegensatz zu Standardwertparametern, bei denen nur eine Kopie der Variablen übergeben wird, ermöglichen ref Parameter der aufgerufenen Methode, den Wert der ursprünglichen Variablen zu ändern. Dieses Verhalten ist entscheidend, wenn Sie möchten, dass eine Methode den Status der an sie übergebenen Variablen aktualisiert.

Betrachten Sie das folgende Beispiel, um die grundlegende Verwendung von ref zu veranschaulichen, wobei der Schwerpunkt darauf liegt, wie eine Referenztypvariable ihren Parameterwert im selben Objekt über Methodenaufrufe hinweg beibehält:

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

    // Method that modifies the original number through 'ref'
    static void ModifyNumber(ref int number)
    {
        number = 200; // Modifies the original value
    }
}

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

    // Method that modifies the original number through 'ref'
    static void ModifyNumber(ref int number)
    {
        number = 200; // Modifies the original value
    }
}

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

	' Method that modifies the original number through 'ref'
	Private Shared Sub ModifyNumber(ByRef number As Integer)
		number = 200 ' Modifies the original value
	End Sub
End Class

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

Wie funktionieren 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 und nicht auf eine Kopie verweisen soll. Dies wird erreicht, indem die Speicheradresse der Variable und nicht der tatsächliche Wert übergeben wird. Sowohl die aufgerufene Methode als auch die aufrufende Methode greifen auf denselben Speicherort zu, was bedeutet, dass alle Änderungen, die am Parameter vorgenommen werden, direkt mit der ursprünglichen Variable vorgenommen werden.

Der Schlüssel zum Verständnis von ref liegt in der Erkenntnis, dass es sowohl mit Werttypen als auch mit Referenztypen verwendet werden kann. Zu den Werttypen gehören einfache Datentypen wie Ganzzahlen und Strukturen, während Referenztypen Objekte und Arrays umfassen. Obwohl Referenztypvariablen von Natur aus Speicheradressen enthalten, ermöglicht die Verwendung von ref mit Referenztypen die Änderung der eigentlichen Referenz und nicht nur des Inhalts des Objekts.

Unterschiede zwischen ref und out

Obwohl sowohl ref als auch out Schlüsselwörter die Modifizierung der ursprünglichen Variablen ermöglichen, 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. Darüber hinaus 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.

Hier ist ein Beispiel, wie Sie das Schlüsselwort out verwenden könnten:

class Program
{
    static void Main()
    {
        int result;
        CalculateResult(out result);
        Console.WriteLine(result); // Output: 100
    }

    // Method that calculates a result and assigns it via 'out'
    static void CalculateResult(out int calculation)
    {
        calculation = 20 * 5; // Must initialize the out parameter
    }
}

class Program
{
    static void Main()
    {
        int result;
        CalculateResult(out result);
        Console.WriteLine(result); // Output: 100
    }

    // Method that calculates a result and assigns it via 'out'
    static void CalculateResult(out int calculation)
    {
        calculation = 20 * 5; // Must initialize the out parameter
    }
}

Friend Class Program
	Shared Sub Main()
		Dim result As Integer = Nothing
		CalculateResult(result)
		Console.WriteLine(result) ' Output: 100
	End Sub

	' Method that calculates a result and assigns it via 'out'
	Private Shared Sub CalculateResult(ByRef calculation As Integer)
		calculation = 20 * 5 ' Must initialize the out parameter
	End Sub
End Class

In diesem Fall initialisiert CalculateResult den calculation innerhalb der Methode, und Main spiegelt das Ergebnis wider.

Praktische Verwendung von ref bei der Methodenüberladung

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

Erwägen Sie die Überladung von Methoden basierend auf ref und Wertparametern:

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

    // Method that increments a copy of the integer
    static void IncrementValue(int number)
    {
        number++;
    }

    // Method that increments the original integer using 'ref'
    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}"); // Output: Normal: 10, Ref: 11
    }

    // Method that increments a copy of the integer
    static void IncrementValue(int number)
    {
        number++;
    }

    // Method that increments the original integer using 'ref'
    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}") ' Output: Normal: 10, Ref: 11
	End Sub

	' Method that increments a copy of the integer
'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

	' Method that increments the original integer using 'ref'
'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 ist IncrementValue überladen, und zwar mit einer Version, die einen normalen Parameter entgegennimmt, und einer Version, die einen ref Parameter entgegennimmt. Die Version ref erhöht die ursprüngliche Variable, während die normale Version nur eine Kopie ändert.

Einführung in IronPDF

IronPDF für .NET PDF Solutions 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 Manipulation von PDFs aus HTML-Inhalten. Indem ein Chrome Rendering Engine verwendet wird, liefert IronPDF hochwertige, pixelgenaue PDF-Dokumente, die die Nuancen von HTML, CSS, JavaScript und Bildinhalten erfassen.

Diese Bibliothek ist vielseitig und unterstützt eine breite Palette von .NET-Umgebungen, darunter .NET Framework, .NET Core und .NET Standard, was sie für verschiedene Anwendungen von Desktop- bis hin zu webbasierten Systemen geeignet macht. IronPDF unterstützt nicht nur die PDF-Erstellung, sondern bietet auch Funktionen zum Bearbeiten, Sichern und Konvertieren von PDFs in andere Formate.

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

using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Set your IronPDF license key
        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.");
    }

    // Method that adds a monthly bonus to sales using 'ref'
    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)
    {
        // Set your IronPDF license key
        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.");
    }

    // Method that adds a monthly bonus to sales using 'ref'
    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)
		' Set your IronPDF license key
		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

	' Method that adds a monthly bonus to sales using 'ref'
	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

Abschluss

Das Verständnis des Schlüsselworts ref in C# bietet ein wertvolles Werkzeug zur Steuerung der Datenübergabe zwischen Methoden. Indem ref Methoden die Möglichkeit gibt, die ursprünglichen Werte der ihnen übergebenen Parameter direkt zu verändern, können Ihre Methoden flexibler und leistungsfähiger werden.

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 kostenlose Testversion an, um die PDF-Funktionen kennenzulernen. Die Preise beginnen bei $999.