Ícone de mensagem
Ir para o conteúdo do rodapé
  1. Iron Software
  2. Blog IronXL
  3. Usando o IronXL
  4. Exportar para o Excel a partir do GridView
USANDO O IRONXL

Como exportar para o Excel a partir de um GridView em C# usando o IronXL

Jordi Bardia
Jordi Bardia
Atualizado:

Exportar dados de GridView para um arquivo Excel genuíno é um dos requisitos mais comuns em aplicações web ASP.NET. Abordagens tradicionais usando HtmlTextWriter e StringWriter criam arquivos Excel falsos que acionam alertas do navegador e erros de formatação quando os usuários tentam abri-los. Este guia mostra como exportar dados do GridView para arquivos .xlsx formatados corretamente usando IronXL, eliminando as dificuldades enfrentadas pelos desenvolvedores com métodos antigos.

Por que a abordagem tradicional de exportação do GridView causa problemas?

O método clássico para exportar para Excel a partir do GridView em ASP.NET C# envolve renderizar HTML e definir cabeçalhos Response com valores de nome de arquivo de anexo Content-Disposition. Esta abordagem requer sobrecarga public override void VerifyRenderingInServerForm para evitar erros de tempo de execução. O arquivo resultante não é um verdadeiro arquivo Excel - é HTML disfarçado com uma extensão .xls, fazendo com que o Excel exiba mensagens de alerta quando os usuários o abrem.

Especificamente, a técnica tradicional tem estas desvantagens:

  • O Excel mostra um aviso "O formato e a extensão do arquivo não correspondem" a cada abertura
  • A formatação e os tipos de dados são perdidos porque os dados são armazenados como HTML bruto
  • Você deve implementar VerifyRenderingInServerForm como uma solução alternativa, adicionando débito técnico ao seu projeto
  • O arquivo resultante não possui metadados de célula adequados, tornando-o inutilizável para ferramentas de automação ou relatórios subsequentes

IronXL resolve esses problemas criando arquivos Excel .xlsx genuínos sem exigir a instalação do Microsoft Office no servidor. Você obtém um arquivo que qualquer aplicativo de planilha pode abrir corretamente, com os tipos de dados apropriados, estilo e estrutura OOXML preservados.

Como Instalar o IronXL em Seu Projeto ASP.NET?

Antes de escrever qualquer lógica de exportação, adicione IronXL ao seu projeto usando o Gerenciador de Pacotes NuGet. Abra o Contrasole do Gerenciador de Pacotes no Visual Studio e execute:

Install-Package IronXl.Excel
Install-Package IronXl.Excel
SHELL

Alternativamente, procure por IronXl.Excel na interface do Gerenciador de Pacotes do NuGet e instale a partir de lá. Uma vez instalado, você pode referenciar o namespace IronXL em qualquer arquivo code-behind.

IronXL é compatível com .NET Standard 2.0 e acima, funcionando em projetos modernos do ASP.NET Core, bem como em aplicativos clássicos do ASP.NET Framework. Não é necessário interop COM, instalação do Office ou dependências nativas adicionais no seu servidor web.

Para mais detalhes, veja o guia de instalação do IronXL e a página do pacote NuGet do IronXL.

Como Configurar o ASP.NET GridView para Exportação?

Crie sua página Default.aspx com um controle GridView e um botão de exportação. A marcação é padrão do Web Forms:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="GridViewExportTest.Default" %>
<!DOCTYPE html>
<html>
<head runat="server">
    <title>Export GridView to Excel</title>
</head>
<body>
    <form id="form1" runat="server">
        <div>
            <h2>IronXL GridView Export Demo</h2>
            <asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true"
                HeaderStyle-BackColor="#3AC0F2" HeaderStyle-ForeColor="White" CellPadding="5">
            </asp:GridView>
            <br />
            <asp:Button ID="btnExport" runat="server" Text="Export to Excel (.xlsx)"
                OnClick="btnExport_Click" />
        </div>
    </form>
</body>
</html>
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="GridViewExportTest.Default" %>
<!DOCTYPE html>
<html>
<head runat="server">
    <title>Export GridView to Excel</title>
</head>
<body>
    <form id="form1" runat="server">
        <div>
            <h2>IronXL GridView Export Demo</h2>
            <asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true"
                HeaderStyle-BackColor="#3AC0F2" HeaderStyle-ForeColor="White" CellPadding="5">
            </asp:GridView>
            <br />
            <asp:Button ID="btnExport" runat="server" Text="Export to Excel (.xlsx)"
                OnClick="btnExport_Click" />
        </div>
    </form>
</body>
</html>
$vbLabelText   $csharpLabel

Esta marcação cria uma página simples com um GridView vinculado e um botão que aciona a exportação. O atributo AutoGenerateColumns="true" significa que a grade lê nomes de colunas diretamente do DataTable vinculado.

Vinculação de Dados de Amostra ao GridView

No seu code-behind, vincule um DataTable à grade e armazene-o em Session para uso posterior durante o postback de exportação:

using System;
using System.Data;
using System.Web.UI;
using IronXL;

namespace GridViewExport
{
    public partial class Default : Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                BindGridView();
            }
        }

        private void BindGridView()
        {
            DataTable dt = new DataTable("Employees");
            dt.Columns.Add("EmployeeID", typeof(int));
            dt.Columns.Add("Name", typeof(string));
            dt.Columns.Add("Department", typeof(string));
            dt.Columns.Add("Salary", typeof(decimal));

            dt.Rows.Add(1, "John Smith", "Engineering", 75000);
            dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
            dt.Rows.Add(3, "Mike Wilson", "Sales", 70000);
            dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

            GridView1.DataSource = dt;
            GridView1.DataBind();

            // Store DataTable in Session for export postback
            Session["GridData"] = dt;
        }
    }
}
using System;
using System.Data;
using System.Web.UI;
using IronXL;

namespace GridViewExport
{
    public partial class Default : Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                BindGridView();
            }
        }

        private void BindGridView()
        {
            DataTable dt = new DataTable("Employees");
            dt.Columns.Add("EmployeeID", typeof(int));
            dt.Columns.Add("Name", typeof(string));
            dt.Columns.Add("Department", typeof(string));
            dt.Columns.Add("Salary", typeof(decimal));

            dt.Rows.Add(1, "John Smith", "Engineering", 75000);
            dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
            dt.Rows.Add(3, "Mike Wilson", "Sales", 70000);
            dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

            GridView1.DataSource = dt;
            GridView1.DataBind();

            // Store DataTable in Session for export postback
            Session["GridData"] = dt;
        }
    }
}
$vbLabelText   $csharpLabel

Armazenar o DataTable em Session evita novas consultas ao banco de dados ou reconstrução de dados durante o postback acionado pelo botão de exportação. Para aplicativos reais, substitua as linhas codificadas por uma consulta de banco de dados usando Entity Framework ou ADO.NET.

Exportar para Excel a partir do GridView em ASP .NET C#: Uma Solução C# Limpa: Imagem 1 - UI mostrando os dados de exemplo do GridView

Como Exportar Dados do GridView para Excel Usando IronXL?

A abordagem limpa para exportação do GridView converte seu DataTable em um WorkBook IronXL e transmite o resultado diretamente para o navegador. Aqui está o método completo de exportação:

protected void btnExport_Click(object sender, EventArgs e)
{
    ExportGridViewToExcel();
}

private void ExportGridViewToExcel()
{
    DataTable dt = (DataTable)Session["GridData"];

    // Create a workbook and load data from the DataTable
    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet worksheet = workbook.DefaultWorkSheet;

    // Apply header row formatting
    var headerRange = worksheet["A1:D1"];
    headerRange.Style.Font.Bold = true;
    headerRange.Style.Font.Size = 12;
    headerRange.Style.SetBackgroundColor("#3AC0F2");

    // Stream the file to the browser
    string filename = "GridViewExport_" + DateTime.Now.ToString("yyyyMMdd") + ".xlsx";
    Response.Clear();
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
    Response.AddHeader("content-disposition", "attachment;filename=" + filename);
    workbook.SaveAsStream(Response.OutputStream, IronXl.Enum.FileFormat.Xlsx);
    Response.Flush();
    Response.End();
}
protected void btnExport_Click(object sender, EventArgs e)
{
    ExportGridViewToExcel();
}

private void ExportGridViewToExcel()
{
    DataTable dt = (DataTable)Session["GridData"];

    // Create a workbook and load data from the DataTable
    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet worksheet = workbook.DefaultWorkSheet;

    // Apply header row formatting
    var headerRange = worksheet["A1:D1"];
    headerRange.Style.Font.Bold = true;
    headerRange.Style.Font.Size = 12;
    headerRange.Style.SetBackgroundColor("#3AC0F2");

    // Stream the file to the browser
    string filename = "GridViewExport_" + DateTime.Now.ToString("yyyyMMdd") + ".xlsx";
    Response.Clear();
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
    Response.AddHeader("content-disposition", "attachment;filename=" + filename);
    workbook.SaveAsStream(Response.OutputStream, IronXl.Enum.FileFormat.Xlsx);
    Response.Flush();
    Response.End();
}
$vbLabelText   $csharpLabel

Como a Exportação Funciona Passo a Passo

O processo é dividido em três etapas lógicas:

  1. Recuperar o DataTable -- Session["GridData"] retorna o mesmo DataTable que estava vinculado à grade. Isso evita chamadas duplicadas ao banco de dados.
  2. Contrastruir o WorkBook -- WorkBook.LoadWorkSheetsFromDataSet cria automaticamente uma planilha por DataTable no DataSet, copiando cabeçalhos de colunas e valores de linhas para as células apropriadas.
  3. Transmitir para o navegador -- Definir Content-Type para o tipo MIME OOXML e escrever para Response.OutputStream aciona um download no navegador com a extensão correta .xlsx. Nenhum arquivo temporário é escrito no disco.

Isto é fundamentalmente diferente da abordagem HtmlTextWriter legado. O arquivo exportado utiliza o formato Open XML -- o mesmo formato que o Microsoft Excel utiliza nativamente -- então ele abre sem avisos.

Para mais informações sobre como carregar dados programaticamente, veja a documentação do IronXL WorkBook e como exportar DataTable para Excel em C#.

Exportar para Excel a partir do GridView em ASP .NET C#: Uma Solução C# Limpa: Imagem 2 - Arquivo Excel Exportado

Como Salvar o Arquivo Excel no Disco em Vez de Transmiti-lo?

Se sua aplicação precisa arquivar exportações no servidor antes de entregar um link de download ao usuário, salve o workbook em um caminho de arquivo em vez de transmiti-lo para Response.OutputStream:

private void SaveExcelToDisk(WorkBook workbook, string exportFolder)
{
    // Ensure the exports directory exists
    if (!System.IO.Directory.Exists(exportFolder))
    {
        System.IO.Directory.CreateDirectory(exportFolder);
    }

    string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
    string filename = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx");

    workbook.SaveAs(filename);

    // Return the relative path for generating a download link
    string relativePath = "~/Exports/Report_" + timestamp + ".xlsx";
    Response.Write($"<script>alert('File saved to {relativePath}');</script>");
}
private void SaveExcelToDisk(WorkBook workbook, string exportFolder)
{
    // Ensure the exports directory exists
    if (!System.IO.Directory.Exists(exportFolder))
    {
        System.IO.Directory.CreateDirectory(exportFolder);
    }

    string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
    string filename = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx");

    workbook.SaveAs(filename);

    // Return the relative path for generating a download link
    string relativePath = "~/Exports/Report_" + timestamp + ".xlsx";
    Response.Write($"<script>alert('File saved to {relativePath}');</script>");
}
$vbLabelText   $csharpLabel

Escolhendo Entre Transmissão e Salvamento no Disco

Comparação de estratégias de exportação de transmissão vs. salvamento no disco
Estratégia Prós Contras Ideal para
Transmissão para navegador Sem uso de disco, entrega imediata Não pode arquivar ou reenviar Exportações de usuário sob demanda
Salvar no disco Arquivo persiste para auditoria, re-download ou e-mail Requer trabalho de limpeza, gestão de espaço em disco Relatórios agendados, trilhas de auditoria

Para a maioria das aplicações web interativas, transmitir diretamente para o navegador é a escolha certa. Salve no disco quando precisar enviar o arquivo por e-mail, armazená-lo para conformidade ou permitir re-downloads de uma página de gestão de arquivos.

Como aplicar formatação avançada à planilha Excel exportada?

IronXL oferece controle detalhado sobre estilos de célula, larguras de coluna, formatos de número e mais. O exemplo a seguir mostra como construir uma exportação com estilo profissional:

private void ExportWithFormatting()
{
    DataTable dt = new DataTable("Products");
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Category", typeof(string));
    dt.Columns.Add("Price", typeof(decimal));
    dt.Columns.Add("InStock", typeof(bool));

    dt.Rows.Add("Widget A", "Hardware", 29.99m, true);
    dt.Rows.Add("Widget B", "Hardware", 49.99m, false);
    dt.Rows.Add("Service Plan", "Support", 199.00m, true);

    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet sheet = workbook.WorkSheets[0];

    // Style the header row
    sheet["A1:D1"].Style.Font.Bold = true;
    sheet["A1:D1"].Style.Font.Size = 13;
    sheet["A1:D1"].Style.SetBackgroundColor("#2196F3");
    sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

    // Apply currency format to the Price column (column C, rows 2 onwards)
    sheet["C2:C4"].Style.NumberFormat.Format = "$#,##0.00";

    // Auto-size all columns for readability
    for (int col = 0; col < 4; col++)
    {
        sheet.AutoSizeColumn(col);
    }

    // Freeze the header row so it stays visible when scrolling
    sheet.FreezePanes(0, 0, 1, 0);

    workbook.SaveAs("FormattedExport.xlsx");
}
private void ExportWithFormatting()
{
    DataTable dt = new DataTable("Products");
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Category", typeof(string));
    dt.Columns.Add("Price", typeof(decimal));
    dt.Columns.Add("InStock", typeof(bool));

    dt.Rows.Add("Widget A", "Hardware", 29.99m, true);
    dt.Rows.Add("Widget B", "Hardware", 49.99m, false);
    dt.Rows.Add("Service Plan", "Support", 199.00m, true);

    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet sheet = workbook.WorkSheets[0];

    // Style the header row
    sheet["A1:D1"].Style.Font.Bold = true;
    sheet["A1:D1"].Style.Font.Size = 13;
    sheet["A1:D1"].Style.SetBackgroundColor("#2196F3");
    sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

    // Apply currency format to the Price column (column C, rows 2 onwards)
    sheet["C2:C4"].Style.NumberFormat.Format = "$#,##0.00";

    // Auto-size all columns for readability
    for (int col = 0; col < 4; col++)
    {
        sheet.AutoSizeColumn(col);
    }

    // Freeze the header row so it stays visible when scrolling
    sheet.FreezePanes(0, 0, 1, 0);

    workbook.SaveAs("FormattedExport.xlsx");
}
$vbLabelText   $csharpLabel

Opções de formatação disponíveis no IronXL

IronXL expõe um rico conjunto de propriedades de formatação através do namespace IronXl.Styles:

  • Estilização de fonte -- negrito, itálico, sublinhado, família de fontes e tamanho
  • Cores de fundo da célula -- strings de cor hexadecimal aceitas diretamente
  • Formatos de número e data -- qualquer string de formato Excel, incluindo moeda, porcentagem e padrões de data
  • Largura da coluna -- largura manual em pixels ou AutoSizeColumn para ajuste automático
  • Congelar painéis -- trancar linhas ou colunas de cabeçalho durante a rolagem
  • Bordas de célula -- todas as quatro bordas com estilo e cor configuráveis
  • Mesclar células -- combinar células através de linhas ou colunas para cabeçalhos de relatório

Para a referência completa da API, veja a documentação de estilização de célula IronXL e formatação de números no IronXL.

Exportar para Excel a partir do GridView em ASP .NET C#: Uma Solução C# Limpa: Imagem 3 - Documento Excel formatado exportado

Como lidar com grandes conjuntos de dados em exportações de GridView?

Quando o GridView está vinculado a milhares de linhas, algumas técnicas mantêm a exportação rápida e eficiente em termos de memória:

Paginação e DataTable do lado do servidor

Não exporte apenas a página visível do GridView. Recupere o conjunto de dados completo de sua fonte de dados em um DataTable antes de chamar WorkBook.LoadWorkSheetsFromDataSet. IronXL escreve linhas em uma única passada sem carregar o workbook inteiro na memória várias vezes, tornando-o adequado para dezenas de milhares de linhas.

Adicionando Múltiplas Planilhas

Você pode incluir múltiplos objetos DataTable no DataSet para produzir um workbook com abas separadas:

DataSet exportSet = new DataSet();
exportSet.Tables.Add(GetEmployeeData());    // Sheet 1
exportSet.Tables.Add(GetDepartmentData());  // Sheet 2
exportSet.Tables.Add(GetSalaryReport());    // Sheet 3

WorkBook workbook = WorkBook.Create();
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook);

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx");
workbook.SaveAsStream(Response.OutputStream, IronXl.Enum.FileFormat.Xlsx);
Response.Flush();
Response.End();
DataSet exportSet = new DataSet();
exportSet.Tables.Add(GetEmployeeData());    // Sheet 1
exportSet.Tables.Add(GetDepartmentData());  // Sheet 2
exportSet.Tables.Add(GetSalaryReport());    // Sheet 3

WorkBook workbook = WorkBook.Create();
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook);

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx");
workbook.SaveAsStream(Response.OutputStream, IronXl.Enum.FileFormat.Xlsx);
Response.Flush();
Response.End();
$vbLabelText   $csharpLabel

Cada DataTable.TableName torna-se o nome da aba da planilha no Excel. Este padrão funciona bem para relatórios de gestão que combinam dados relacionados em várias visualizações.

Guias relacionadas:

Quais são os principais benefícios de usar o IronXL para exportação de GridView?

Usar IronXL para exportar dados de GridView oferece claras vantagens sobre a abordagem tradicional de encapsulamento HTML:

  • Arquivos Excel genuínos -- cria um formato .xlsx válido que abre sem alertas ou mensagens de erro do navegador
  • Sem instalação do Office necessária -- funciona em qualquer servidor web sem o Microsoft Excel ou interop do Office
  • Sem sobrecarga VerifyRenderingInServerForm -- elimina a solução alternativa genérica que sobrecarrega o código tradicional
  • Controle total de formatação -- estilize células, aplique formatos de número, congele painéis e crie planilhas profissionais programaticamente
  • Suporte a múltiplas planilhas -- exporte conjuntos de dados relacionados como abas separadas em um único workbook
  • Compatibilidade multiplataforma -- funciona corretamente em servidores Windows e Linux, incluindo contêineres Docker e Azure App Service

A biblioteca está disponível no NuGet e suporta todos os targets modernos do .NET, incluindo .NET 10. Também suporta leitura e escrita de outros formatos, como CSV e ODS, o que a torna uma única dependência para todas as necessidades de planilhas em sua aplicação.

Para uma comparação lado a lado com outras bibliotecas Excel, veja IronXL vs ClosedXML e a visão geral de recursos do IronXL.

Quais são os seus próximos passos?

Agora você tem tudo o que precisa para substituir a exportação de GridView legado HtmlTextWriter com uma implementação IronXL limpa e sem alertas. Aqui está como avançar:

  • Experimente o teste gratuito -- comece um teste gratuito de 30 dias do IronXL sem necessidade de cartão de crédito e teste o código de exportação em seu próprio projeto
  • Explore mais tutoriais IronXL -- o blog IronXL cobre importação de dados, fórmulas de células, geração de gráficos e fluxos de trabalho de modelos Excel
  • Leia a referência da API -- a documentação da API IronXL cobre todos os métodos em WorkBook, WorkSheet, e a API de estilo
  • Compare opções de licenciamento -- veja preços do IronXL para encontrar a licença certa para o tamanho da sua equipe e cenário de implantação
  • Faça uma pergunta -- a equipe de suporte do Iron Software e os fóruns da comunidade estão disponíveis se você encontrar algo inesperado

Perguntas frequentes

Por que devo usar o IronXL para exportar dados do GridView para o Excel?

O IronXL permite criar arquivos XLSX genuínos a partir do GridView no ASP.NET C# sem os problemas comuns associados ao HtmlTextWriter e ao StringWriter, como avisos do navegador e erros de formatação.

Quais são as limitações do uso do HtmlTextWriter para exportar para o Excel?

O HtmlTextWriter frequentemente cria arquivos Excel falsos que podem causar avisos no navegador e problemas de formatação. O IronXL resolve esses problemas gerando arquivos Excel verdadeiros.

Como o IronXL melhora o processo de exportação de dados do GridView?

O IronXL simplifica a exportação de dados do GridView, permitindo que os desenvolvedores gerem arquivos Excel formatados corretamente diretamente de seus aplicativos ASP.NET, eliminando a necessidade de soluções alternativas baseadas em HTML.

Qual formato de arquivo o IronXL utiliza para arquivos Excel exportados?

O IronXL exporta dados para arquivos XLSX genuínos, garantindo compatibilidade e formatação adequada quando abertos no Excel.

O IronXL pode ajudar com problemas de formatação ao exportar para o Excel?

Sim, o IronXL elimina problemas de formatação criando arquivos Excel verdadeiros, o que garante que os dados sejam exibidos corretamente sem acionar avisos do navegador.

Existe algum exemplo de código para exportar dados do GridView com o IronXL?

Sim, o tutorial inclui exemplos de código que demonstram como usar o IronXL para exportar dados do GridView para o Excel de forma eficiente e eficaz.

O IronXL suporta a exportação de grandes conjuntos de dados do GridView?

O IronXL foi projetado para lidar com grandes conjuntos de dados de forma eficiente, tornando-o adequado para exportar grandes quantidades de dados do GridView para o Excel.

Quais são as vantagens de usar o IronXL em comparação com os métodos tradicionais de exportação para Excel?

IronXL oferece uma solução mais confiável e eficiente, eliminando avisos do navegador, garantindo a formatação correta dos arquivos e fornecendo uma implementação de código direta para exportar dados do GridView.

Jordi Bardia
Jordi Bardia
  Converse agora mesmo com a equipe de engenharia.
Engenheiro de Software
Jordi é extremamente proficiente em Python, C# e C++, e quando não está utilizando suas habilidades na Iron Software, dedica-se à programação de jogos. Compartilhando as responsabilidades por testes, desenvolvimento e pesquisa de produtos, Jordi agrega imenso valor à melhoria contínua dos produtos. Essa experiência diversificada o mantém ...
Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Comece seu teste gratuito

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me