Referência de C# (Como funciona para desenvolvedores)

Entendendo os parâmetros de referência

Um parâmetro ref é um parâmetro de método que atua como uma referência à variável passada para o método. Ao contrário dos parâmetros de valor padrão, onde apenas uma cópia da variável é passada, os parâmetros ref permitem que o método chamado modifique o valor da variável original. Esse comportamento é crucial quando você precisa de um método para atualizar o estado das variáveis ​​que lhe são passadas.

Considere o seguinte exemplo para demonstrar o uso básico de ref, com foco em como uma variável de tipo referência retém o valor de seu parâmetro no mesmo objeto durante as chamadas de método:

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

Neste exemplo, o método Main declara um inteiro number e o inicializa com 100. Em seguida, chama ModifyNumber, passando number como parâmetro ref. Dentro de ModifyNumber, o valor de number é alterado para 200. Como number é passado por referência, a alteração é refletida no valor original no método Main, e 200 é impresso no console.

Como funcionam os parâmetros de referência

Ao declarar um parâmetro de método com a palavra-chave ref, você está dizendo ao compilador que o parâmetro fará referência à variável original em vez de uma cópia. Isso é conseguido passando o endereço de memória da variável, em vez do valor real. Tanto o método chamado quanto o método que o chama acessam o mesmo local de memória, o que significa que quaisquer alterações feitas no parâmetro são feitas diretamente na variável original.

A chave para entender ref é reconhecer que ele pode ser usado tanto com tipos de valor quanto com tipos de referência. Tipos de valor incluem tipos de dados simples como inteiros e structs, enquanto tipos de referência incluem objetos e arrays. No entanto, embora as variáveis ​​de tipo de referência contenham inerentemente endereços de memória, usar ref com tipos de referência permite modificar a referência real, e não apenas o conteúdo do objeto.

Diferenças entre ref e out

Embora as palavras-chave ref e out permitam modificar as variáveis ​​originais, existem distinções importantes. Um parâmetro out não requer inicialização antes de ser passado para um método. Por outro lado, um parâmetro ref exige que a variável seja inicializada antes de ser passada. Além disso, um método que usa um parâmetro out é obrigado a atribuir um valor antes que o método retorne. Este requisito não se aplica aos parâmetros ref.

Eis como você pode usar a palavra-chave out:

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

Neste caso, CalculateResult inicializa o calculation dentro do método, e Main reflete o resultado.

Uso prático de ref em sobrecarga de métodos

ref também pode ser usado na sobrecarga de métodos, onde a assinatura do método é alterada pela palavra-chave ref. As assinaturas de métodos são compostas pelo nome do método e seus tipos de parâmetros, incluindo se os parâmetros são passados ​​por referência (ref), por valor ou como um parâmetro out.

Considere sobrecarregar métodos com base em parâmetros ref e valores:

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

Aqui, IncrementValue está sobrecarregado com uma versão que aceita um parâmetro normal e outra que aceita um parâmetro ref. A versão ref incrementa a variável original, enquanto a versão normal apenas altera uma cópia.

Introdução ao IronPDF

IronPDF for .NET PDF Solutions é uma biblioteca .NET abrangente projetada para trabalhar com documentos PDF. É desenvolvido principalmente em C# e tem como foco simplificar a criação e manipulação de PDFs a partir de conteúdo HTML . Ao utilizar um mecanismo de renderização do Chrome, o IronPDF oferece documentos PDF de alta qualidade e com precisão de pixels, que capturam as nuances do conteúdo de HTML, CSS, JavaScript e imagens.

Esta biblioteca é versátil, suportando uma ampla gama de ambientes .NET , incluindo .NET Framework, .NET Core e .NET Standard, o que a torna adequada para diversas aplicações, desde sistemas desktop até sistemas baseados na web. O IronPDF não só permite a criação de PDFs, como também oferece funcionalidades para editar, proteger e converter PDFs para outros formatos.

Essa funcionalidade abrange a extração de texto e imagens, o preenchimento de formulários e até mesmo a aplicação de assinaturas digitais, garantindo o manuseio completo de documentos PDF em aplicativos .NET .

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

Conclusão

Compreender a palavra-chave ref em C# fornece uma ferramenta valiosa para gerenciar como os dados são passados ​​entre os métodos. Ao permitir que os métodos modifiquem diretamente os valores originais dos parâmetros que lhes são passados, ref pode tornar seus métodos mais flexíveis e poderosos.

À medida que você ganha experiência com ref, você entenderá melhor quando e como usá-lo de forma eficaz para atender às suas necessidades de programação. O IronPDF oferece um teste gratuito para você começar a usar os recursos de PDF e os preços começam em $799.