AJUDA DO .NET

.NET Core Polly (Como funciona para desenvolvedores)

Atualizado:julho 28, 2025

Polly é uma biblioteca .NET para estratégias de resiliência e tratamento de falhas transitórias, permitindo que desenvolvedores expressem políticas de resiliência como política de repetição, disjuntores, tempo limite, política de isolamento de anteparo e fallback. O Polly tem como alvo o ASP.NET Core, tornando-se uma ferramenta vital para a resiliência do .NET Core . Polly é thread-safe e suporta o processamento de múltiplas requisições simultâneas com respostas bem-sucedidas.

Este tutorial fornecerá mais detalhes sobre a biblioteca .NET para tratamento de falhas transitórias, Polly, e como usá-la com o IronPDF em uma aplicação ASP.NET Core . Analisaremos detalhadamente cada aspecto do Polly, explicaremos a mecânica do padrão Circuit Breaker, discutiremos o isolamento de bulkhead e os timeouts, e mostraremos como lidar com exceções específicas ou serviços com falha, com respostas de falha, de maneira controlada e segura para threads.

Políticas da Polly

Falhas transitórias geralmente ocorrem quando seu aplicativo tenta se conectar a um serviço web por meio de uma solicitação HTTP, banco de dados ou outros recursos externos. Essas falhas, como problemas de rede, instabilidade temporária ou timeouts, são breves e normalmente se corrigem sozinhas após um curto período.

Polly gerencia essas falhas transitórias aplicando diferentes estratégias e expressando políticas como Política de Repetição, Política Avançada de Disjuntor, Política de Tempo Limite, Política de Recuo e Política de Isolamento de Anteparo.

Política de Repetição

A política de repetição tenta novamente, automaticamente, solicitações simultâneas com falha, utilizando lógica de repetição. Ele pode ser configurado para tentar novamente indefinidamente ou realizar novas tentativas automaticamente um determinado número de vezes, podendo aguardar um intervalo de tempo definido entre as tentativas ou usar um recuo exponencial.

Disjuntor

A política Circuit Breaker permite que seu sistema suporte um token de cancelamento para tentativas de acesso a um serviço específico após um limite predefinido de solicitações com falha. A estratégia do disjuntor é análoga à engenharia do caos ou a um navio fechando portas estanques para localizar danos: uma falha não afundará o navio inteiro.

Política de tempo limite

A política de tempo limite define um tempo máximo que um determinado trecho de código de resiliência do .NET pode ser executado. Ele vem em duas versões: tempo limite otimista e tempo limite pessimista.

Política de Contingência

A política de fallback é usada para fornecer um valor ou comportamento alternativo em caso de falha. Essa política pode ser útil quando uma falha em um serviço não deve interromper todo o processo.

Isolamento de Anteparo

O isolamento de anteparo é usado para limitar o número de solicitações simultâneas que podem ser feitas a uma operação específica, limitando assim o potencial de esgotamento de sockets e mantendo um número controlado de slots de execução.

Política de cache

A política de cache armazena em cache a resposta bem-sucedida de uma execução, de forma que, se a mesma execução for invocada novamente, o Polly possa retornar o valor do cache distribuído.

Resumo da Política

Permite agrupar várias políticas para que funcionem como uma única unidade.

Criar e configurar políticas

Política de Repetição

A política de repetição é simples: quando ocorre uma exceção ou falha específica, o Polly tentará executar o delegado subjacente novamente. Você pode definir quantas tentativas devem ser feitas, o intervalo de tempo entre as tentativas ou usar uma estratégia de recuo exponencial; caso contrário, as tentativas serão indefinidas. Eis um exemplo:

// Retry policy for handling HttpRequestException with exponential back-off
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), 
    (exception, timeSpan, retryCount, context) =>
    {
        // This is the OnRetry delegate, where you can log or monitor failed requests
        Console.WriteLine($"Retry {retryCount} after {timeSpan}. Exception: {exception.Message}");
    });

// Retry policy for handling HttpRequestException with exponential back-off
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), 
    (exception, timeSpan, retryCount, context) =>
    {
        // This is the OnRetry delegate, where you can log or monitor failed requests
        Console.WriteLine($"Retry {retryCount} after {timeSpan}. Exception: {exception.Message}");
    });

' Retry policy for handling HttpRequestException with exponential back-off
Dim retryPolicy = Policy.Handle(Of HttpRequestException)().WaitAndRetryAsync(3, Function(retryAttempt) TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), Sub(exception, timeSpan, retryCount, context)
	Console.WriteLine($"Retry {retryCount} after {timeSpan}. Exception: {exception.Message}")
End Sub)

$vbLabelText $csharpLabel

Política de disjuntor

A política Circuit Breaker permite que a biblioteca Polly monitore falhas e, se o número de falhas exceder um limite configurado dentro de um período especificado, o circuito é "interrompido" e novas solicitações são bloqueadas por um tempo determinado. Isso é chamado de estado "aberto". Após esse período, o circuito entra em um estado "semiaberto", permitindo que algum tráfego verifique o funcionamento do serviço em questão. Se essas solicitações forem bem-sucedidas e nenhuma falha ocorrer, o circuito se fecha; Caso contrário, ele se abre novamente.

// Circuit breaker policy to handle failing requests with open and half-open states
var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreakerAsync(5, TimeSpan.FromMinutes(1));

// Circuit breaker policy to handle failing requests with open and half-open states
var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreakerAsync(5, TimeSpan.FromMinutes(1));

' Circuit breaker policy to handle failing requests with open and half-open states
Dim circuitBreakerPolicy = Policy.Handle(Of HttpRequestException)().CircuitBreakerAsync(5, TimeSpan.FromMinutes(1))

$vbLabelText $csharpLabel

Política de tempo limite

As políticas de tempo limite lidam com cenários em que um serviço não responde dentro de um prazo razoável. Polly oferece dois tipos de pausas: Otimista e Pessimista. Um timeout otimista funciona em uma thread separada e cancela a operação subjacente por meio de um CancellationToken. Um tempo limite pessimista bloqueia a thread principal até que a operação seja concluída ou o período de tempo limite expire.

// Timeout policy with a 30-second optimistic timeout
var timeoutPolicy = Policy.TimeoutAsync(30); // 30 seconds

// Timeout policy with a 30-second optimistic timeout
var timeoutPolicy = Policy.TimeoutAsync(30); // 30 seconds

' Timeout policy with a 30-second optimistic timeout
Dim timeoutPolicy = Policy.TimeoutAsync(30) ' 30 seconds

$vbLabelText $csharpLabel

Isolamento de Anteparo

O isolamento de anteparo é usado para limitar o número de ações simultâneas em um serviço específico. Ele fornece uma maneira de isolar falhas e impedir que elas se propaguem. Isso também limita a carga que impomos às nossas dependências.

// Bulkhead isolation policy to limit concurrency and queue length
var bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20); // 10 concurrent actions, 20 queue slots

// Bulkhead isolation policy to limit concurrency and queue length
var bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20); // 10 concurrent actions, 20 queue slots

' Bulkhead isolation policy to limit concurrency and queue length
Dim bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20) ' 10 concurrent actions, 20 queue slots

$vbLabelText $csharpLabel

Política de Contingência

As políticas de fallback são úteis quando você precisa fornecer um comportamento padrão ou um valor substituto quando todas as outras opções falharem.

// Fallback policy to provide a default result on failure
var fallbackPolicy = Policy
    .Handle<Exception>()
    .FallbackAsync<FallbackResult>(
        FallbackResult.SomethingWentWrong, 
        (exception, context) => 
        {
            Console.WriteLine($"Fallback triggered due to: {exception.Message}");
            return Task.CompletedTask;
        });

// Fallback policy to provide a default result on failure
var fallbackPolicy = Policy
    .Handle<Exception>()
    .FallbackAsync<FallbackResult>(
        FallbackResult.SomethingWentWrong, 
        (exception, context) => 
        {
            Console.WriteLine($"Fallback triggered due to: {exception.Message}");
            return Task.CompletedTask;
        });

' Fallback policy to provide a default result on failure
Dim fallbackPolicy = Policy.Handle(Of Exception)().FallbackAsync(Of FallbackResult)(FallbackResult.SomethingWentWrong, Function(exception, context)
			Console.WriteLine($"Fallback triggered due to: {exception.Message}")
			Return Task.CompletedTask
End Function)

$vbLabelText $csharpLabel

Encapsulando as Políticas

É possível combinar várias políticas de forma flexível usando um PolicyWrap:

// Combining multiple policies using PolicyWrap
var policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy);

// Combining multiple policies using PolicyWrap
var policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy);

' Combining multiple policies using PolicyWrap
Dim policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy)

$vbLabelText $csharpLabel

Começando

Para começar a usar o Polly com o IronPDF, certifique-se de ter o Visual Studio instalado e crie um novo projeto de Aplicativo de Console no .NET Core. Abra o Console do Gerenciador de Pacotes NuGet no Visual Studio e instale os pacotes Polly e IronPDF:

Install-Package Polly

Install-Package IronPdf

Usando Polly com IronPDF: Convertendo uma URL em PDF

Uma característica importante do IronPDF é sua capacidade de converter HTML em PDF , garantindo que os layouts e estilos sejam mantidos intactos. Essa função transforma conteúdo da web em PDFs, o que é perfeito para relatórios, faturas e documentação. Ele permite a conversão de arquivos HTML, URLs e strings HTML em PDFs.

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

Vamos analisar um exemplo de como usar o Polly com o IronPDF para converter uma URL em PDF . Suponha que temos um serviço web que ocasionalmente falha devido a problemas transitórios, e queremos lidar com essas falhas de forma adequada usando o Polly.

Primeiro, vamos importar os namespaces necessários em nosso arquivo Program.cs:

using System;
using System.Threading.Tasks;
using Polly;
using Polly.Wrap;
using IronPdf;

using System;
using System.Threading.Tasks;
using Polly;
using Polly.Wrap;
using IronPdf;

Imports System
Imports System.Threading.Tasks
Imports Polly
Imports Polly.Wrap
Imports IronPdf

$vbLabelText $csharpLabel

Em seguida, definiremos nossas políticas. Neste exemplo, usaremos uma combinação de políticas de repetição e disjuntor para lidar com falhas:

// Retry policy with exponential backoff
var retryPolicy = Policy
    .Handle<Exception>()
    .WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(2 * i));

// Circuit breaker policy to block requests after consecutive failures
var circuitBreakerPolicy = Policy
    .Handle<Exception>()
    .CircuitBreakerAsync(2, TimeSpan.FromSeconds(30));

// Retry policy with exponential backoff
var retryPolicy = Policy
    .Handle<Exception>()
    .WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(2 * i));

// Circuit breaker policy to block requests after consecutive failures
var circuitBreakerPolicy = Policy
    .Handle<Exception>()
    .CircuitBreakerAsync(2, TimeSpan.FromSeconds(30));

' Retry policy with exponential backoff
Dim retryPolicy = Policy.Handle(Of Exception)().WaitAndRetryAsync(3, Function(i) TimeSpan.FromSeconds(2 * i))

' Circuit breaker policy to block requests after consecutive failures
Dim circuitBreakerPolicy = Policy.Handle(Of Exception)().CircuitBreakerAsync(2, TimeSpan.FromSeconds(30))

$vbLabelText $csharpLabel

O código retryPolicy tentará novamente a solicitação com falha até três vezes com uma estratégia de espera exponencial, aguardando 2 segundos, 4 segundos e 8 segundos entre as tentativas. O circuitBreakerPolicy abrirá o circuito se ocorrerem duas falhas consecutivas dentro de um intervalo de 30 segundos.

Agora, vamos definir nosso código IronPDF para converter uma URL em um PDF:

var htmlToPdf = new ChromePdfRenderer();
var pdfBytes = await retryPolicy
    .WrapAsync(circuitBreakerPolicy)
    .ExecuteAsync(async () =>
    {
        Console.WriteLine("Attempting to convert URL to PDF...");
        var result = await htmlToPdf.RenderUrlAsPdfAsync("https://example.com");
        Console.WriteLine("Conversion successful!");
        return result;
    });

pdfBytes.SaveAs("output.pdf");

var htmlToPdf = new ChromePdfRenderer();
var pdfBytes = await retryPolicy
    .WrapAsync(circuitBreakerPolicy)
    .ExecuteAsync(async () =>
    {
        Console.WriteLine("Attempting to convert URL to PDF...");
        var result = await htmlToPdf.RenderUrlAsPdfAsync("https://example.com");
        Console.WriteLine("Conversion successful!");
        return result;
    });

pdfBytes.SaveAs("output.pdf");

Dim htmlToPdf = New ChromePdfRenderer()
Dim pdfBytes = Await retryPolicy.WrapAsync(circuitBreakerPolicy).ExecuteAsync(Async Function()
		Console.WriteLine("Attempting to convert URL to PDF...")
		Dim result = Await htmlToPdf.RenderUrlAsPdfAsync("https://example.com")
		Console.WriteLine("Conversion successful!")
		Return result
End Function)

pdfBytes.SaveAs("output.pdf")

$vbLabelText $csharpLabel

No exemplo de código acima, envolvemos nossos retryPolicy e circuitBreakerPolicy usando o método WrapAsync. Isso nos permite aplicar várias políticas a novas solicitações sequencialmente. O método ExecuteAsync executa o delegado fornecido, que neste código é o método RenderUrlAsPdfAsync do IronPDF.

Ao aplicar as políticas do Polly, garantimos que nosso código seja resiliente a falhas transitórias. Se uma solicitação falhar, o Polly tentará novamente automaticamente, de acordo com a política de repetição. Se o número de falhas consecutivas ultrapassar o limite pré-configurado, a política de disjuntor abrirá o circuito, impedindo novas solicitações por um período especificado.

Casos de teste para políticas da Polly

Para testar a eficácia de nossas políticas Polly, vamos simular algumas requisições com falha. Modifique a URL para um endpoint inexistente e adicione alguns casos de teste:

var testUrls = new[]
{
    "https://ironpdf.com",
    "https://notexistingdomain.com/",
    "http://httpbin.org/delay/120"
};

foreach (var url in testUrls)
{
    try
    {
        var pdfBytes = await retryPolicy
            .WrapAsync(circuitBreakerPolicy)
            .ExecuteAsync(() => htmlToPdf.RenderUrlAsPdfAsync(url));

        pdfBytes.SaveAs($"{Guid.NewGuid()}.pdf");
        Console.WriteLine($"Successfully converted {url} to PDF.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to convert {url} to PDF: {ex.Message}");
    }
}

var testUrls = new[]
{
    "https://ironpdf.com",
    "https://notexistingdomain.com/",
    "http://httpbin.org/delay/120"
};

foreach (var url in testUrls)
{
    try
    {
        var pdfBytes = await retryPolicy
            .WrapAsync(circuitBreakerPolicy)
            .ExecuteAsync(() => htmlToPdf.RenderUrlAsPdfAsync(url));

        pdfBytes.SaveAs($"{Guid.NewGuid()}.pdf");
        Console.WriteLine($"Successfully converted {url} to PDF.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to convert {url} to PDF: {ex.Message}");
    }
}

Imports System

Dim testUrls = {
    "https://ironpdf.com",
    "https://notexistingdomain.com/",
    "http://httpbin.org/delay/120"
}

For Each url In testUrls
    Try
        Dim pdfBytes = Await retryPolicy _
            .WrapAsync(circuitBreakerPolicy) _
            .ExecuteAsync(Function() htmlToPdf.RenderUrlAsPdfAsync(url))

        pdfBytes.SaveAs($"{Guid.NewGuid()}.pdf")
        Console.WriteLine($"Successfully converted {url} to PDF.")
    Catch ex As Exception
        Console.WriteLine($"Failed to convert {url} to PDF: {ex.Message}")
    End Try
Next

$vbLabelText $csharpLabel

No código acima, iteramos sobre um conjunto de URLs de teste e tentamos converter cada uma delas em PDF. Se uma solicitação falhar, a exceção será capturada e uma mensagem apropriada será exibida no console.

.NET Core Polly (Como funciona para desenvolvedores): Figura 1 - Saída de URL para PDF

Conclusão

Polly é uma biblioteca poderosa e flexível para implementar resiliência e tratamento de falhas transitórias em aplicações .NET Core . Ao combinar políticas como repetição e disjuntor, os desenvolvedores podem construir sistemas robustos e tolerantes a falhas que lidam com falhas de forma adequada.

Neste tutorial, exploramos como usar o Polly com o IronPDF para converter uma URL em PDF. Aprendemos como definir e aplicar políticas do Polly, incluindo repetição e disjuntor. Também testamos nossas políticas com URLs diferentes. Também podemos fazer isso para converter HTML em PDF .

O IronPDF oferece um período de teste gratuito e as licenças têm preços iniciais competitivos, permitindo que você aproveite seus recursos em seus projetos.

Perguntas frequentes

O que é Polly e como ele aprimora a resiliência do .NET Core?

Polly é uma biblioteca .NET projetada para resiliência e tratamento de falhas transitórias, especialmente para aplicações ASP.NET Core. Ela aprimora a resiliência fornecendo estratégias como Retry, Circuit Breakers, Timeout, Bulkhead Isolation e Fallback, garantindo sistemas robustos e tolerantes a falhas.

Como posso usar o Polly para implementar uma política de repetição no .NET Core?

No .NET Core, você pode usar o Polly para implementar uma política de repetição, configurando-o para repetir automaticamente as solicitações com falha. Isso pode ser feito definindo o número de tentativas e o intervalo de tempo entre elas, permitindo um gerenciamento eficaz de falhas transitórias.

Como a política Circuit Breaker impede falhas em cascata em aplicações .NET?

A política Circuit Breaker do Polly impede falhas em cascata monitorando falhas e abrindo o circuito para bloquear solicitações quando um limite de falha é atingido. Isso interrompe novas solicitações até que o circuito seja reiniciado, permitindo que o sistema se recupere antes de aceitar novas solicitações.

Qual o papel do isolamento de antepara na gestão do esgotamento de recursos?

O Isolamento de Bulkhead no Polly limita o número de solicitações simultâneas a um serviço, evitando o esgotamento de recursos ao controlar os slots de execução. Essa política ajuda a conter falhas e garante o gerenciamento eficiente de recursos em uma aplicação .NET Core.

Como a política de tempo limite da Polly pode melhorar a capacidade de resposta da minha aplicação?

A política de tempo limite do Polly impõe um tempo máximo de execução para as operações, o que ajuda a gerenciar cenários em que os serviços não respondem prontamente. Ao definir tempos limite otimistas ou pessimistas, os desenvolvedores podem garantir que seus aplicativos permaneçam responsivos.

O Polly pode ser usado para melhorar a confiabilidade da conversão de URL para PDF?

Sim, o Polly pode aumentar a confiabilidade da conversão de URL para PDF integrando suas políticas de Repetição e Disjuntor com as ferramentas de geração de PDF. Isso garante que os processos de conversão sejam resilientes a falhas transitórias, mantendo a confiabilidade.

Como uma política de fallback no Polly garante uma degradação de serviço controlada?

Uma política de fallback no Polly fornece respostas ou comportamentos alternativos quando um serviço falha. Isso ajuda a garantir que uma falha não interrompa toda a aplicação, permitindo uma degradação gradual e a continuidade da operação.

Como combinar várias políticas Polly em uma aplicação .NET?

Em uma aplicação .NET, várias políticas do Polly podem ser combinadas usando Policy Wraps. Isso permite que os desenvolvedores executem diferentes estratégias de resiliência simultaneamente, possibilitando uma abordagem de tratamento de falhas mais abrangente e flexível.

Como a integração do Polly com o IronPDF lida com falhas transitórias na geração de PDFs?

Ao integrar o Polly com o IronPDF, os desenvolvedores podem lidar com falhas transitórias durante a geração de PDFs por meio de políticas como repetição e disjuntor. Essa integração garante a geração estável e confiável de PDFs, mesmo diante de interrupções ocasionais do serviço.

Quais são algumas estratégias comuns de resolução de problemas ao usar o Polly com o .NET Core?

As estratégias comuns de resolução de problemas incluem a verificação das configurações de políticas, como intervalos de repetição e limites de disjuntores, e o teste de políticas com diferentes cenários para garantir o tratamento adequado de falhas e a resiliência do sistema.

Curtis Chau

Converse agora mesmo com a equipe de engenharia.

Redator Técnico

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 ...

Destaque do cliente:

Destaque do desenvolvedor:

Webinários:

Experimente gratuitamente por 30 dias.

.NET Core Polly (Como funciona para desenvolvedores)

Políticas da Polly

Política de Repetição

Disjuntor

Política de tempo limite

Política de Contingência

Isolamento de Anteparo

Política de cache

Resumo da Política

Criar e configurar políticas

Política de Repetição

Política de disjuntor

Política de tempo limite

Isolamento de Anteparo

Política de Contingência

Encapsulando as Políticas

Começando

Usando Polly com IronPDF: Convertendo uma URL em PDF

Casos de teste para políticas da Polly

Conclusão

Perguntas frequentes

O que é Polly e como ele aprimora a resiliência do .NET Core?

Como posso usar o Polly para implementar uma política de repetição no .NET Core?

Como a política Circuit Breaker impede falhas em cascata em aplicações .NET?

Qual o papel do isolamento de antepara na gestão do esgotamento de recursos?

Como a política de tempo limite da Polly pode melhorar a capacidade de resposta da minha aplicação?

O Polly pode ser usado para melhorar a confiabilidade da conversão de URL para PDF?

Como uma política de fallback no Polly garante uma degradação de serviço controlada?

Como combinar várias políticas Polly em uma aplicação .NET?

Como a integração do Polly com o IronPDF lida com falhas transitórias na geração de PDFs?

Quais são algumas estratégias comuns de resolução de problemas ao usar o Polly com o .NET Core?

Equipe de suporte de ferro

Experimente gratuitamente por 30 dias.

.NET Core Polly (Como funciona para desenvolvedores)

Políticas da Polly

Política de Repetição

Disjuntor

Política de tempo limite

Política de Contingência

Isolamento de Anteparo

Política de cache

Resumo da Política

Criar e configurar políticas

Política de Repetição

Política de disjuntor

Política de tempo limite

Isolamento de Anteparo

Política de Contingência

Encapsulando as Políticas

Começando

Usando Polly com IronPDF: Convertendo uma URL em PDF

Casos de teste para políticas da Polly

Conclusão

Perguntas frequentes

O que é Polly e como ele aprimora a resiliência do .NET Core?

Como posso usar o Polly para implementar uma política de repetição no .NET Core?

Como a política Circuit Breaker impede falhas em cascata em aplicações .NET?

Qual o papel do isolamento de antepara na gestão do esgotamento de recursos?

Como a política de tempo limite da Polly pode melhorar a capacidade de resposta da minha aplicação?

O Polly pode ser usado para melhorar a confiabilidade da conversão de URL para PDF?

Como uma política de fallback no Polly garante uma degradação de serviço controlada?

Como combinar várias políticas Polly em uma aplicação .NET?

Como a integração do Polly com o IronPDF lida com falhas transitórias na geração de PDFs?

Quais são algumas estratégias comuns de resolução de problemas ao usar o Polly com o .NET Core?

Artigos relacionados

Unindo a simplicidade da linha de comando e o .NET: usando Curl DotNet com IronPDF

Gerador de Números Aleatórios em C#

O operador Equals em C# (Como funciona para desenvolvedores)

Want to deploy IronSuite to a live project for FREE?

What’s included?

Thank You

Want to deploy IronSuite to a live project for FREE?

What’s included?

Aprovado por milhões de engenheiros em todo o mundo.

Equipe de suporte de ferro