Leitor de código de barras ASP.NET : Upload de arquivos e API REST com IronBarcode

Instalando através do Gerenciador de Pacotes NuGet

Abra o Console do Gerenciador de Pacotes no Visual Studio e execute:

Install-Package BarCode

Install-Package BarCode

Alternativamente, use o .NET CLI:

dotnet add package BarCode

dotnet add package BarCode

Ou procure por "BarCode" na interface do gerenciador de pacotes NuGet do Visual Studio e clique em Instalar. O pacote gerencia automaticamente todas as dependências.

Para implantações específicas de plataforma, considere usar pacotes NuGet específicos da plataforma que são otimizados para seu ambiente de destino. A biblioteca oferece pacotes padrão e pacotes BarCode.Slim para se adequar a diferentes cenários de implantação. Para o guia completo de instalação, veja o guia de instalação do IronBarcode.

Configurando Seu Projeto

Uma vez instalado, adicione a declaração 'using' necessária aos seus arquivos C#:

using IronBarCode;

using IronBarCode;

Esta importação dá-lhe acesso à completa leitura e geração de códigos de barras do IronBarcode. A biblioteca suporta mais de 30 formatos de código de barras, incluindo QR Code, Code 128, Code 39, Data Matrix e PDF417. Veja a lista completa de formatos de código de barras suportados para confirmar a compatibilidade com seu caso de uso.

Para solucionar problemas de instalação, consulte o guia de solução de problemas de pacotes NuGet ou envie uma solicitação de engenharia para suporte especializado.

Escolhendo o Padrão de Arquitetura Correto

Ao implementar a digitalização de código de barras em ASP.NET, você tem duas abordagens arquitetônicas principais. Compreender esses padrões ajuda você a escolher as configurações do leitor de código de barras corretas para cada caso de uso:

// Server-side processing -- recommended for most ASP.NET scenarios
var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    UseConfidenceThreshold = true,
    ConfidenceThreshold = 0.85
};

var results = BarcodeReader.Read(stream, options);

foreach (var barcode in results)
{
    Console.WriteLine($"Type: {barcode.BarcodeType}, Value: {barcode.Text}");
}

// Server-side processing -- recommended for most ASP.NET scenarios
var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    UseConfidenceThreshold = true,
    ConfidenceThreshold = 0.85
};

var results = BarcodeReader.Read(stream, options);

foreach (var barcode in results)
{
    Console.WriteLine($"Type: {barcode.BarcodeType}, Value: {barcode.Text}");
}

A abordagem do lado do servidor dá a você controle máximo sobre o processamento de imagens e funciona de forma consistente em todos os navegadores. Quando o servidor processa cada imagem, você também obtém um rastro de auditoria limpo: cada código de barras digitalizado passa por sua camada de aplicação onde você pode registrá-lo, validá-lo em relação a um banco de dados ou acionar fluxos de trabalho a jusante. Este padrão é particularmente adequado para indústrias regulamentadas, como saúde, logística e manufatura, onde cada digitalização deve ser registrada.

Para integração de captura de câmera no lado do cliente, navegadores modernos suportam a API MediaDevices para acesso à câmera, que pode ser combinada com o processamento no lado do servidor do IronBarcode através de uma API REST -- coberto em detalhes mais adiante neste guia. Escolher o processamento do lado do servidor também simplifica seu modelo de segurança: não há lógica de processamento sensível exposta ao navegador, e toda validação acontece por trás do limite de sua aplicação.

Construindo o Formulário de Upload

Crie um formulário HTML responsivo em sua view ASP.NET:

@* Razor view -- barcode upload form *@
<form method="post" enctype="multipart/form-data" id="barcodeForm">
    <div class="form-group">
        <label for="barcodeFile">Select Barcode Image:</label>
        <input type="file" name="barcodeFile" id="barcodeFile"
               accept="image/*,.pdf" class="form-control"
               capture="environment" />
    </div>
    <button type="submit" class="btn btn-primary" id="scanBtn">
        <span class="spinner-border spinner-border-sm d-none" role="status"></span>
        Scan Barcode
    </button>
</form>
<div id="results">
    @ViewBag.BarcodeResult
</div>

@* Razor view -- barcode upload form *@
<form method="post" enctype="multipart/form-data" id="barcodeForm">
    <div class="form-group">
        <label for="barcodeFile">Select Barcode Image:</label>
        <input type="file" name="barcodeFile" id="barcodeFile"
               accept="image/*,.pdf" class="form-control"
               capture="environment" />
    </div>
    <button type="submit" class="btn btn-primary" id="scanBtn">
        <span class="spinner-border spinner-border-sm d-none" role="status"></span>
        Scan Barcode
    </button>
</form>
<div id="results">
    @ViewBag.BarcodeResult
</div>

O atributo capture="environment" ativa a câmera traseira em dispositivos móveis, proporcionando aos usuários uma experiência semelhante à de uma câmera nativa sem JavaScript.

Implementando o Processamento Seguro no Backend

A ação do controlador lida com a validação de arquivos, o processamento do fluxo de memória e a formatação de resultados:

[HttpPost]
[ValidateAntiForgeryToken]
[RequestSizeLimit(10_000_000)] // 10MB limit
public async Task<IActionResult> ScanBarcode(IFormFile barcodeFile)
{
    var allowedExtensions = new[] { ".jpg", ".jpeg", ".png", ".gif",
                                    ".tiff", ".bmp", ".pdf" };
    var extension = Path.GetExtension(barcodeFile.FileName).ToLowerInvariant();

    if (!allowedExtensions.Contains(extension))
    {
        ModelState.AddModelError("", "Invalid file type");
        return View();
    }

    if (barcodeFile != null && barcodeFile.Length > 0)
    {
        using var stream = new MemoryStream();
        await barcodeFile.CopyToAsync(stream);
        stream.Position = 0;

        var options = new BarcodeReaderOptions
        {
            Speed = ReadingSpeed.Balanced,
            ExpectMultipleBarcodes = true,
            ExpectBarcodeTypes = BarcodeEncoding.AllOneDimensional |
                                BarcodeEncoding.QRCode |
                                BarcodeEncoding.DataMatrix,
            ImageFilters = new ImageFilterCollection
            {
                new SharpenFilter(),
                new ContrastFilter()
            }
        };

        var results = BarcodeReader.Read(stream, options);

        ViewBag.BarcodeResult = results.Any()
            ? string.Join("<br/>", results.Select(r => $"<strong>{r.BarcodeType}:</strong> {r.Text}"))
            : "No barcodes found in the image.";
    }

    return View();
}

[HttpPost]
[ValidateAntiForgeryToken]
[RequestSizeLimit(10_000_000)] // 10MB limit
public async Task<IActionResult> ScanBarcode(IFormFile barcodeFile)
{
    var allowedExtensions = new[] { ".jpg", ".jpeg", ".png", ".gif",
                                    ".tiff", ".bmp", ".pdf" };
    var extension = Path.GetExtension(barcodeFile.FileName).ToLowerInvariant();

    if (!allowedExtensions.Contains(extension))
    {
        ModelState.AddModelError("", "Invalid file type");
        return View();
    }

    if (barcodeFile != null && barcodeFile.Length > 0)
    {
        using var stream = new MemoryStream();
        await barcodeFile.CopyToAsync(stream);
        stream.Position = 0;

        var options = new BarcodeReaderOptions
        {
            Speed = ReadingSpeed.Balanced,
            ExpectMultipleBarcodes = true,
            ExpectBarcodeTypes = BarcodeEncoding.AllOneDimensional |
                                BarcodeEncoding.QRCode |
                                BarcodeEncoding.DataMatrix,
            ImageFilters = new ImageFilterCollection
            {
                new SharpenFilter(),
                new ContrastFilter()
            }
        };

        var results = BarcodeReader.Read(stream, options);

        ViewBag.BarcodeResult = results.Any()
            ? string.Join("<br/>", results.Select(r => $"<strong>{r.BarcodeType}:</strong> {r.Text}"))
            : "No barcodes found in the image.";
    }

    return View();
}

Essa implementação valida o tipo de arquivo antes do processamento, lê códigos de barras de um fluxo de memória e retorna todos os resultados detectados. IronBarcode processa vários formatos de imagem, incluindo TIFF e GIF de múltiplas páginas e documentos PDF, eliminando código específico de manipulação de formato.

Como a Entrada e Saída Digitalizada se Parecem

O exemplo acima mostra um padrão Code 128 -- um formato comum em aplicações de envio e inventário. Após a digitalização, a tela de resultado confirma o valor decodificado junto com metadados de confiança:

IronBarcode retorna o tipo de código de barras, valor decodificado, pontuação de confiança e dados de posição para cada código de barras detectado na imagem carregada.

Considerações de Segurança para APIs de Código de Barras

Antes de escrever o controlador, planeje a camada de segurança. Os dados do código de barras podem conter conteúdo arbitrário, então sempre valide as entradas. Siga as diretrizes de segurança do IronBarcode para proteção completa:

• Validação de entrada: Sanitizar o conteúdo do código de barras antes de armazenar ou agir sobre ele
• Limitação de taxa: Use o middleware de limitação de taxa integrado do ASP.NET Core para evitar abusos da API
• Autenticação: Proteja os endpoints com tokens JWT ou chaves de API
• Imposição de HTTPS: Todo o tráfego da API de código de barras deve trafegar sobre TLS
• Política de CORS: Restringir quais origens podem chamar seu endpoint de digitalização
• Gerenciamento de chave de licença: Aplique chaves de licença corretamente e configure-as no web.config para produção

Construindo o Controlador de API de Produção

[ApiController]
[Route("api/[controller]")]
public class BarcodeController : ControllerBase
{
    private readonly ILogger<BarcodeController> _logger;
    private readonly IMemoryCache _cache;

    public BarcodeController(ILogger<BarcodeController> logger, IMemoryCache cache)
    {
        _logger = logger;
        _cache = cache;
    }

    [HttpPost("scan")]
    [ProducesResponseType(typeof(BarcodeResponse), 200)]
    [ProducesResponseType(typeof(ErrorResponse), 400)]
    public async Task<IActionResult> ScanBarcode([FromBody] BarcodeRequest request)
    {
        try
        {
            if (string.IsNullOrEmpty(request.ImageBase64))
                return BadRequest(new ErrorResponse { Error = "Image data is required" });

            var cacheKey = $"barcode_{request.ImageBase64.GetHashCode()}";
            if (_cache.TryGetValue(cacheKey, out BarcodeResponse cachedResult))
                return Ok(cachedResult);

            byte[] imageBytes = Convert.FromBase64String(request.ImageBase64);

            if (imageBytes.Length > 10 * 1024 * 1024)
                return BadRequest(new ErrorResponse { Error = "Image size exceeds 10MB limit" });

            var options = new BarcodeReaderOptions
            {
                Speed = ReadingSpeed.Faster,
                ExpectMultipleBarcodes = request.ExpectMultiple ?? false,
                UseConfidenceThreshold = true,
                ConfidenceThreshold = 0.8
            };

            var results = await Task.Run(() => BarcodeReader.Read(imageBytes, options));

            var response = new BarcodeResponse
            {
                Success = true,
                Barcodes = results.Select(r => new BarcodeData
                {
                    Type = r.BarcodeType.ToString(),
                    Value = r.Text,
                    Confidence = r.Confidence,
                    Position = new BarcodePosition
                    {
                        X = r.Points.Select(p => p.X).Min(),
                        Y = r.Points.Select(p => p.Y).Min(),
                        Width = r.Width,
                        Height = r.Height
                    }
                }).ToList()
            };

            _cache.Set(cacheKey, response, TimeSpan.FromMinutes(5));
            return Ok(response);
        }
        catch (FormatException)
        {
            return BadRequest(new ErrorResponse { Error = "Invalid base64 image data" });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error processing barcode scan");
            return StatusCode(500, new ErrorResponse { Error = "Internal server error" });
        }
    }
}

public record BarcodeRequest(string ImageBase64, bool? ExpectMultiple);

public record BarcodeResponse
{
    public bool Success { get; init; }
    public List<BarcodeData> Barcodes { get; init; } = new();
}

public record BarcodeData
{
    public string Type { get; init; }
    public string Value { get; init; }
    public double Confidence { get; init; }
    public BarcodePosition Position { get; init; }
}

public record BarcodePosition(int X, int Y, int Width, int Height);

public record ErrorResponse
{
    public bool Success => false;
    public string Error { get; init; }
}

[ApiController]
[Route("api/[controller]")]
public class BarcodeController : ControllerBase
{
    private readonly ILogger<BarcodeController> _logger;
    private readonly IMemoryCache _cache;

    public BarcodeController(ILogger<BarcodeController> logger, IMemoryCache cache)
    {
        _logger = logger;
        _cache = cache;
    }

    [HttpPost("scan")]
    [ProducesResponseType(typeof(BarcodeResponse), 200)]
    [ProducesResponseType(typeof(ErrorResponse), 400)]
    public async Task<IActionResult> ScanBarcode([FromBody] BarcodeRequest request)
    {
        try
        {
            if (string.IsNullOrEmpty(request.ImageBase64))
                return BadRequest(new ErrorResponse { Error = "Image data is required" });

            var cacheKey = $"barcode_{request.ImageBase64.GetHashCode()}";
            if (_cache.TryGetValue(cacheKey, out BarcodeResponse cachedResult))
                return Ok(cachedResult);

            byte[] imageBytes = Convert.FromBase64String(request.ImageBase64);

            if (imageBytes.Length > 10 * 1024 * 1024)
                return BadRequest(new ErrorResponse { Error = "Image size exceeds 10MB limit" });

            var options = new BarcodeReaderOptions
            {
                Speed = ReadingSpeed.Faster,
                ExpectMultipleBarcodes = request.ExpectMultiple ?? false,
                UseConfidenceThreshold = true,
                ConfidenceThreshold = 0.8
            };

            var results = await Task.Run(() => BarcodeReader.Read(imageBytes, options));

            var response = new BarcodeResponse
            {
                Success = true,
                Barcodes = results.Select(r => new BarcodeData
                {
                    Type = r.BarcodeType.ToString(),
                    Value = r.Text,
                    Confidence = r.Confidence,
                    Position = new BarcodePosition
                    {
                        X = r.Points.Select(p => p.X).Min(),
                        Y = r.Points.Select(p => p.Y).Min(),
                        Width = r.Width,
                        Height = r.Height
                    }
                }).ToList()
            };

            _cache.Set(cacheKey, response, TimeSpan.FromMinutes(5));
            return Ok(response);
        }
        catch (FormatException)
        {
            return BadRequest(new ErrorResponse { Error = "Invalid base64 image data" });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error processing barcode scan");
            return StatusCode(500, new ErrorResponse { Error = "Internal server error" });
        }
    }
}

public record BarcodeRequest(string ImageBase64, bool? ExpectMultiple);

public record BarcodeResponse
{
    public bool Success { get; init; }
    public List<BarcodeData> Barcodes { get; init; } = new();
}

public record BarcodeData
{
    public string Type { get; init; }
    public string Value { get; init; }
    public double Confidence { get; init; }
    public BarcodePosition Position { get; init; }
}

public record BarcodePosition(int X, int Y, int Width, int Height);

public record ErrorResponse
{
    public bool Success => false;
    public string Error { get; init; }
}

Esse endpoint aceita imagens codificadas em base64 -- o formato padrão para transmissão de imagens sobre HTTP. A resposta inclui tipo de código de barras, valor decodificado, pontuação de confiança e posição. Para cenários de alto volume, revise as opções de processamento de códigos de barras em lote e otimização de velocidade de leitura.

Como a API Lida com Múltiplos Códigos de Barras?

IronBarcode processa múltiplos códigos de barras em uma única imagem em uma chamada, retornando um array de resultados. Cada entrada na resposta inclui dados de posição para que a aplicação cliente possa destacar os códigos de barras detectados na tela.

A resposta JSON estruturada fornece às aplicações clientes tudo o que é necessário para processar e exibir os resultados dos códigos de barras sem consultas adicionais.

Diagnosticando Problemaas Comuns de Digitalização

Antes de aplicar correções, identifique em qual categoria seu problema se enquadra. A maior parte das falhas de digitalização em produção se enquadra em um dos cinco grupos: problemas de qualidade de imagem (desfoque, ruído, baixa resolução), problemas geométricos (rotação, inclinação, distorção de perspectiva), problemas de dano (rótulos rasgados, tinta borrada), problemas de ambiente (reflexo, sombras, iluminação inconsistente), e detecção de falso positivo onde o leitor encontra um código de barras que não existe.

Saber a categoria ajuda a selecionar a combinação correta de filtro e velocidade de leitura sem executar processamento desnecessário em todas as imagens. Para a maioria dos cenários de aplicativos web, começar com ReadingSpeed.Balanced e AutoRotate = true cobre a maioria dos casos. Escale apenas para ExtremeDetail quando a primeira tentativa não retornar resultados.

A abordagem de múltiplas passagens no código abaixo implementa essa estratégia em camadas. A rápida primeira passagem lida com imagens típicas rapidamente, mantendo a latência mediana baixa para casos comuns. A detalhada segunda passagem é acionada apenas quando a primeira tentativa falha, garantindo que você só pague o custo adicional de processamento quando realmente necessário. Esse padrão mantém seu endpoint ASP.NET responsivo sob carga normal, enquanto ainda lida com casos limítrofes difíceis de forma confiável.

Implementando Processamento de Imagem de Múltiplas Passagens

Para imagens desafiadoras, uma abordagem de processamento em camadas oferece os melhores resultados sem sacrificar o desempenho em imagens fáceis:

public class AdvancedBarcodeProcessor
{
    private readonly ILogger<AdvancedBarcodeProcessor> _logger;

    public async Task<List<ScannedBarcode>> ProcessChallengingImage(Stream imageStream)
    {
        // First pass -- fast, minimal processing
        var fastOptions = new BarcodeReaderOptions
        {
            Speed = ReadingSpeed.Balanced,
            ExpectMultipleBarcodes = true,
            AutoRotate = false,
            UseConfidenceThreshold = true,
            ConfidenceThreshold = 0.85
        };

        var results = BarcodeReader.Read(imageStream, fastOptions);

        if (!results.Any())
        {
            // Second pass -- aggressive image correction
            imageStream.Position = 0;

            var detailedOptions = new BarcodeReaderOptions
            {
                Speed = ReadingSpeed.ExtremeDetail,
                ExpectMultipleBarcodes = true,
                AutoRotate = true,
                RemoveFalsePositive = true,
                UseConfidenceThreshold = true,
                ConfidenceThreshold = 0.6,
                Multithreaded = true,
                ExpectBarcodeTypes = BarcodeEncoding.All,
                ImageFilters = new ImageFilterCollection
                {
                    new SharpenFilter(2.5f),
                    new ContrastFilter(2.0f),
                    new BrightnessFilter(1.2f),
                    new InvertFilter()
                }
            };

            results = BarcodeReader.Read(imageStream, detailedOptions);
            _logger.LogInformation("Second pass detected {Count} barcodes", results.Count());
        }

        return results.Select(r => new ScannedBarcode
        {
            Value = r.Text,
            BarcodeType = r.BarcodeType.ToString(),
            Confidence = r.Confidence,
            RotationAngle = r.RotationAngle,
            PageNumber = r.PageNumber
        }).ToList();
    }
}

public record ScannedBarcode
{
    public string Value { get; init; }
    public string BarcodeType { get; init; }
    public double Confidence { get; init; }
    public float RotationAngle { get; init; }
    public int PageNumber { get; init; }
}

public class AdvancedBarcodeProcessor
{
    private readonly ILogger<AdvancedBarcodeProcessor> _logger;

    public async Task<List<ScannedBarcode>> ProcessChallengingImage(Stream imageStream)
    {
        // First pass -- fast, minimal processing
        var fastOptions = new BarcodeReaderOptions
        {
            Speed = ReadingSpeed.Balanced,
            ExpectMultipleBarcodes = true,
            AutoRotate = false,
            UseConfidenceThreshold = true,
            ConfidenceThreshold = 0.85
        };

        var results = BarcodeReader.Read(imageStream, fastOptions);

        if (!results.Any())
        {
            // Second pass -- aggressive image correction
            imageStream.Position = 0;

            var detailedOptions = new BarcodeReaderOptions
            {
                Speed = ReadingSpeed.ExtremeDetail,
                ExpectMultipleBarcodes = true,
                AutoRotate = true,
                RemoveFalsePositive = true,
                UseConfidenceThreshold = true,
                ConfidenceThreshold = 0.6,
                Multithreaded = true,
                ExpectBarcodeTypes = BarcodeEncoding.All,
                ImageFilters = new ImageFilterCollection
                {
                    new SharpenFilter(2.5f),
                    new ContrastFilter(2.0f),
                    new BrightnessFilter(1.2f),
                    new InvertFilter()
                }
            };

            results = BarcodeReader.Read(imageStream, detailedOptions);
            _logger.LogInformation("Second pass detected {Count} barcodes", results.Count());
        }

        return results.Select(r => new ScannedBarcode
        {
            Value = r.Text,
            BarcodeType = r.BarcodeType.ToString(),
            Confidence = r.Confidence,
            RotationAngle = r.RotationAngle,
            PageNumber = r.PageNumber
        }).ToList();
    }
}

public record ScannedBarcode
{
    public string Value { get; init; }
    public string BarcodeType { get; init; }
    public double Confidence { get; init; }
    public float RotationAngle { get; init; }
    public int PageNumber { get; init; }
}

A classe BarcodeReaderOptions fornece controle detalhado sobre todos os aspectos da digitalização. Configurar AutoRotate lida com imagens capturadas em qualquer ângulo, enquanto filtros de imagem melhoram a clareza de códigos de barras borrados ou de baixo contraste. Para configuração detalhada, consulte o exemplo de configurações do leitor de código de barras e configurações específicas para PDF.

Ao trabalhar com PDFs, considere carimbar códigos de barras em PDFs ou criar códigos de barras como documentos PDF. Para processamento em alto volume, habilitar multithreading através das capacidades assíncronas e multithread melhora significativamente a taxa de transferência.

Adicionando Compatibilidade com Navegadores e Estratégias de Recuperação

Suportar navegadores diversos requer aprimoramento progressivo. Os navegadores modernos no Android e nos desktops Chrome, Edge e Firefox suportam a API MediaDevices.getUserMedia() para acesso à câmera. Safari no iOS o suporta a partir da versão 11. Navegadores empresariais antigos, modos de compatibilidade do IE11 e certos ambientes corporativos protegidos podem não suportar acesso à câmera de forma alguma, então seu caminho de recuperação de upload de arquivos deve sempre permanecer funcional.

A abordagem recomendada é usar detecção de recursos em tempo de execução em vez de análise de user-agent, e então mostrar ou esconder a interface da câmera conforme apropriado. Comece com uma interface compatível com câmera e recorra graciosamente ao upload de arquivos:

@* Razor view with progressive enhancement *@
<div class="barcode-scanner-container">
    @* Camera capture -- hidden until JavaScript confirms support *@
    <div id="cameraSection" class="d-none">
        <video id="videoPreview" class="w-100" autoplay></video>
        <button id="captureBtn" class="btn btn-primary mt-2">Capture and Scan</button>
    </div>

    @* File upload -- always available as fallback *@
    <div id="uploadSection">
        <form method="post" enctype="multipart/form-data"
              asp-action="ScanBarcode" asp-controller="Barcode">
            <div class="form-group">
                <label>Upload Barcode Image:</label>
                <input type="file" name="file" accept="image/*,.pdf"
                       class="form-control" required />
            </div>
            <button type="submit" class="btn btn-primary">Upload and Scan</button>
        </form>
    </div>
</div>

@* Razor view with progressive enhancement *@
<div class="barcode-scanner-container">
    @* Camera capture -- hidden until JavaScript confirms support *@
    <div id="cameraSection" class="d-none">
        <video id="videoPreview" class="w-100" autoplay></video>
        <button id="captureBtn" class="btn btn-primary mt-2">Capture and Scan</button>
    </div>

    @* File upload -- always available as fallback *@
    <div id="uploadSection">
        <form method="post" enctype="multipart/form-data"
              asp-action="ScanBarcode" asp-controller="Barcode">
            <div class="form-group">
                <label>Upload Barcode Image:</label>
                <input type="file" name="file" accept="image/*,.pdf"
                       class="form-control" required />
            </div>
            <button type="submit" class="btn btn-primary">Upload and Scan</button>
        </form>
    </div>
</div>

A integração Blazor fornece suporte para aplicativos web modernos com configuração mínima se você preferir uma abordagem baseada em componentes. Para resolução de problemas de implantação, consulte o guia de exceção de cópia de runtimes.