A palavra-chave params em C# é um recurso poderoso no .NET que permite que um método aceite um número variável de argumentos. Isso pode simplificar significativamente a sintaxe ao chamar métodos que exigem um número variável de parâmetros. Neste guia abrangente, exploraremos a palavra-chave params em C#, sua sintaxe, casos de uso e melhores práticas. Mais adiante neste artigo, apresentaremos a biblioteca IronPDF da Iron Software e explicaremos como usar a palavra-chave params e o IronPDF para gerar PDFs.
No contexto da linguagem C#, os métodos normalmente seguem um conjunto predeterminado de parâmetros. No entanto, existem situações em que alguém pode se encontrar incerto quanto ao número exato de argumentos destinados a um método. Introduza a palavra-chave "params", uma solução que permite especificar um parâmetro de método capaz de acomodar uma matriz de argumentos. Essa funcionalidade se mostra extremamente útil quando o desenvolvedor não tem certeza sobre o número exato de argumentos, facilitando a passagem de um número indeterminado ou opcional de parâmetros, todos do mesmo tipo, dentro de uma declaração de método.
public class ParamsExample
{
// Method accepting a variable number of string arguments using the params keyword
public void PrintMessages(params string[] messages)
{
foreach (var message in messages)
{
Console.WriteLine(message);
}
}
}
// Usage
class Program
{
public static void Main()
{
var example = new ParamsExample();
example.PrintMessages("Hello", "World", "!");
}
// More examples
public static void AddItemsToShoppingBasket(params string[] items)
{
// Implementation to add items to a shopping basket
}
public static void AddItemsSumToShoppingBasket(params int[] sum) // Using params with int
{
// Implementation to add sum of items to the shopping basket
}
}Public Class ParamsExample
' Method accepting a variable number of string arguments using the params keyword
Public Sub PrintMessages(ParamArray ByVal messages() As String)
For Each message In messages
Console.WriteLine(message)
Next message
End Sub
End Class
' Usage
Friend Class Program
Public Shared Sub Main()
Dim example = New ParamsExample()
example.PrintMessages("Hello", "World", "!")
End Sub
' More examples
Public Shared Sub AddItemsToShoppingBasket(ParamArray ByVal items() As String)
' Implementation to add items to a shopping basket
End Sub
Public Shared Sub AddItemsSumToShoppingBasket(ParamArray ByVal sum() As Integer) ' Using params with int
' Implementation to add sum of items to the shopping basket
End Sub
End ClassO método AddItemsToShoppingBasket pode ser invocado com um número variável de argumentos de parâmetros de string. A palavra-chave params simplifica a sintaxe para a chamada do método permitindo que os desenvolvedores passem os parâmetros opcionais diretamente, sem a necessidade de criar explicitamente uma entrada de array.
class Program
{
public static void Main()
{
AddItemsToShoppingBasket("cake", "pizza", "cold drink");
AddItemsToShoppingBasket("snacks", "burger");
AddItemsToShoppingBasket(); // Valid even with zero parameters, using default value
}
}Friend Class Program
Public Shared Sub Main()
AddItemsToShoppingBasket("cake", "pizza", "cold drink")
AddItemsToShoppingBasket("snacks", "burger")
AddItemsToShoppingBasket() ' Valid even with zero parameters, using default value
End Sub
End ClassPosicione o parâmetro params no final da lista de parâmetros: Uma prática recomendada é posicionar o parâmetro params ao final da lista de parâmetros do método. Essa prática promove clareza, minimizando confusões durante as chamadas do método. Para uma organização eficaz, os parâmetros que exigem valores explícitos devem preceder os demais parâmetros.
Especificar Explicitamente Parâmetros Não-params: Ao invocar um método com params, assegure-se de fornecer explicitamente valores para os parâmetros não-params. Essa prática evita ambiguidades e garante a invocação correta do método com o número necessário de argumentos.
Seja Cauteloso para Evitar Ambiguidade: A vigilância é fundamental ao utilizar params em métodos com múltiplas sobrecargas ou parâmetros do mesmo tipo. O compilador pode ter dificuldades em determinar o método apropriado a ser invocado, o que pode resultar em erros de ambiguidade.
Explore Abordagens Alternativas: Embora params ofereça conveniência, considere métodos alternativos em determinados cenários. Utilizar coleções como List<t> pode ser preferível para funcionalidade aprimorada ou quando passar parâmetros nomeados alinha-se com seus objetivos.
Aplique com Discernimento a Cenários Relevantes: Use params com discernimento em cenários onde a contagem de parâmetros é variável e pode flutuar em chamadas de métodos distintas. Reserve seu uso para situações em que o número de parâmetros seja imprevisível, evitando sua aplicação quando a quantidade de parâmetros for fixa e conhecida.
AddItemsToShoppingBasket também pode ser utilizado chamando-o com um array unidimensional.
class Program
{
public static void Main()
{
var items = new string[] { "cold drink", "snack", "roll" }; // 1D string array
AddItemsToShoppingBasket(items); // Works as expected
AddItemsToShoppingBasket("cold drink", "coke", "roll"); // Similar result to the above line
}
}Friend Class Program
Public Shared Sub Main()
Dim items = New String() { "cold drink", "snack", "roll" } ' 1D string array
AddItemsToShoppingBasket(items) ' Works as expected
AddItemsToShoppingBasket("cold drink", "coke", "roll") ' Similar result to the above line
End Sub
End ClassAddItemsToShoppingBasket pode ser chamada passando uma lista/array de variáveis na chamada do método, como mostrado abaixo.
class Program
{
public static void Main()
{
// Example method signature
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink"); // Comma separated values
AddItemsToShoppingBasket("snacks");
}
}Friend Class Program
Public Shared Sub Main()
' Example method signature
AddItemsToShoppingBasket("snacks", "burger", "snacks", "burger", "cold drink") ' Comma separated values
AddItemsToShoppingBasket("snacks")
End Sub
End ClassO array deve conter o mesmo tipo definido no método params; Caso contrário, será lançado um erro.
// Example that results in an error
AddItemsToShoppingBasket("snacks", 2, "burger"); // Error due to type mismatch
AddItemsToShoppingBasket(2, 3, 4); // Error since params type is string' Example that results in an error
AddItemsToShoppingBasket("snacks", 2, "burger") ' Error due to type mismatch
AddItemsToShoppingBasket(2, 3, 4) ' Error since params type is stringOcorre um erro de sintaxe se houver uma incompatibilidade de tipo do params definido no método.
Nenhum parâmetro adicional é permitido após o parâmetro params em uma assinatura de método. Apenas um argumento params é permitido em uma declaração de parâmetros de método. Uma definição incorreta leva a erros de compilação.
class Program
{
static void Main(string[] args)
{
// Example 1
public static void AddItemsToShoppingBasket(double total, params string[] items)
{
// Works fine as `params` is the last parameter
}
// Example 2, error scenario
public static void AddItemsToShoppingBasket(params string[] items, decimal total, int total)
{
// Error: `params` keyword must be the last parameter
}
}
}Module Program
Sub Main(args As String())
' Example 1
Public Sub AddItemsToShoppingBasket(total As Double, ParamArray items As String())
' Works fine as `ParamArray` is the last parameter
End Sub
' Example 2, error scenario
' Public Sub AddItemsToShoppingBasket(ParamArray items As String(), total As Decimal, total As Integer)
' Error: `ParamArray` keyword must be the last parameter
' End Sub
End Sub
End ModuleparamsApenas um parâmetro params em uma assinatura de método é permitido. O compilador lança um erro se mais de uma palavra-chave params for encontrada na assinatura do método.
class Program
{
static void Main(string[] args)
{
public static void AddItemsToShoppingBasket(params string[] items, params string[] quantity)
{
// Compiler Error: Only one params keyword is allowed in the method signature
}
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
' public static void AddItemsToShoppingBasket(params string[] items, params string[] quantity)
' {
' ' Compiler Error: Only one params keyword is allowed in the method signature
' }
End Sub
End ClassSe um método tem um parâmetro com a palavra-chave params, ele pode ser chamado sem quaisquer argumentos, e o compilador não lançará um erro.
AddItemsToShoppingBasket(); // Works as expectedAddItemsToShoppingBasket() ' Works as expectedPara qualquer parâmetro com um argumento params, ele é considerado um parâmetro opcional e pode ser invocado sem passar parâmetros.
Crie um novo aplicativo de console. Abra o Visual Studio, crie um novo projeto e selecione o tipo de aplicativo de console.
Agora adicione o código abaixo.
using System;
using System.Collections.Generic;
class Program
{
static void Main(string[] args)
{
List<string> cart = new List<string>();
void AddItemsToShoppingBasket(params string[] samples)
{
for (int i = 0; i < samples.Length; i++)
{
cart.Add(samples[i]);
}
}
// Caller code
Console.WriteLine("Enter the cart items as comma separated values");
var itemsString = Console.ReadLine();
if (itemsString != null)
{
var items = itemsString.Split(",").ToArray();
AddItemsToShoppingBasket(items);
}
AddItemsToShoppingBasket("Sample1", "Sample2");
Console.WriteLine("-------------------------------------------------------");
Console.WriteLine("Display Cart");
foreach (var item in cart)
{
Console.WriteLine(item);
}
}
}Imports System
Imports System.Collections.Generic
Module Program
Sub Main(args As String())
Dim cart As New List(Of String)()
Sub AddItemsToShoppingBasket(ParamArray samples As String())
For i As Integer = 0 To samples.Length - 1
cart.Add(samples(i))
Next
End Sub
' Caller code
Console.WriteLine("Enter the cart items as comma separated values")
Dim itemsString = Console.ReadLine()
If itemsString IsNot Nothing Then
Dim items = itemsString.Split(","c)
AddItemsToShoppingBasket(items)
End If
AddItemsToShoppingBasket("Sample1", "Sample2")
Console.WriteLine("-------------------------------------------------------")
Console.WriteLine("Display Cart")
For Each item In cart
Console.WriteLine(item)
Next
End Sub
End Module
IronPDF, uma biblioteca PDF em C# da Iron Software , é uma biblioteca versátil que permite ler, escrever e gerenciar documentos PDF em C#. Ele oferece suporte a todos os tipos de desenvolvimento de aplicativos modernos, como aplicativos móveis, sites, aplicativos para desktop, Docker, etc. Além disso, é compatível com diferentes sistemas operacionais, como Windows, Linux, Unix, etc., e não depende de métodos nativos do sistema operacional.
O IronPDF se destaca na conversão de HTML para PDF , garantindo a preservação precisa dos layouts e estilos originais. É perfeito para criar PDFs a partir de conteúdo da web, como relatórios, faturas e documentação. Com suporte para arquivos HTML, URLs e strings HTML brutas, o IronPDF produz facilmente documentos PDF de alta qualidade.
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 ClassA biblioteca IronPDF pode ser instalada usando o console do gerenciador de pacotes NuGet com o comando abaixo ou usando o gerenciador de pacotes do Visual Studio.
Agora, usaremos o IronPDF para gerar o documento PDF a partir do exemplo acima.
using System;
using System.Collections.Generic;
using System.Linq;
using IronPdf;
class Program
{
public static void Main()
{
List<string> cart = new List<string>();
void AddItemsToShoppingBasket(params string[] items)
{
for (int i = 0; i < items.Length; i++)
{
cart.Add(items[i]);
}
}
// Take input from console
Console.WriteLine("Enter the cart items as comma separated values");
var itemsString = Console.ReadLine();
// Read the items
if (itemsString != null)
{
var items = itemsString.Split(",").ToArray();
AddItemsToShoppingBasket(items);
}
// Add to cart
AddItemsToShoppingBasket("Sample1", "Sample2");
Console.WriteLine("------------------------------------------------");
Console.WriteLine("Display Cart");
Console.WriteLine("------------------------------------------------");
string name = "Sam";
var count = cart.Count;
string content = $@"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} items in the cart.</p>
" +
string.Join("\n", cart.Select(x => $"<p>{x}</p>"))
+ @"
</body>
</html>";
// Create a new PDF document
var pdfDoc = new ChromePdfRenderer();
pdfDoc.RenderHtmlAsPdf(content).SaveAs("cart.pdf");
}
}Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports IronPdf
Friend Class Program
Public Shared Sub Main()
Dim cart As New List(Of String)()
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
' void AddItemsToShoppingBasket(params string[] items)
' {
' for (int i = 0; i < items.Length; i++)
' {
' cart.Add(items[i]);
' }
' }
' Take input from console
Console.WriteLine("Enter the cart items as comma separated values")
Dim itemsString = Console.ReadLine()
' Read the items
If itemsString IsNot Nothing Then
Dim items = itemsString.Split(",").ToArray()
AddItemsToShoppingBasket(items)
End If
' Add to cart
AddItemsToShoppingBasket("Sample1", "Sample2")
Console.WriteLine("------------------------------------------------")
Console.WriteLine("Display Cart")
Console.WriteLine("------------------------------------------------")
Dim name As String = "Sam"
Dim count = cart.Count
Dim content As String = $"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} items in the cart.</p>
" & String.Join(vbLf, cart.Select(Function(x) $"<p>{x}</p>")) & "
</body>
</html>"
' Create a new PDF document
Dim pdfDoc = New ChromePdfRenderer()
pdfDoc.RenderHtmlAsPdf(content).SaveAs("cart.pdf")
End Sub
End ClassNo código acima, estamos gerando um documento HTML para os itens do carrinho e, em seguida, salvando-o como um documento PDF usando o IronPDF .
O IronPDF requer uma chave de licença para funcionar em produção. Uma chave de avaliação pode ser obtida na página de licenças aqui . Insira a chave no arquivo appsettings.json.
"IronPdf.LicenseKey": "your license key"Forneça seu endereço de e-mail para receber uma licença de avaliação em seu e-mail.
A palavra-chave params em C# oferece uma maneira flexível de lidar com métodos que exigem um número variável de parâmetros. Isso simplifica as chamadas de método e torna o código mais legível e fácil de manter. Em conjunto com o IronPDF , forma uma excelente combinação de ferramentas para qualquer programador escrever código limpo.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
