1
CHANCY
6 min de leitura ·

Criar, carregar e salvar arquivos Excel dinamicamente usando streams em C#

O uso de operações com streams em C# permite criar, carregar e salvar arquivos Excel dinamicamente. Como os dados podem ser processados diretamente na memória, não é necessário armazenar os arquivos fisicamente, proporcionando maior flexibilidade no gerenciamento de dados. Essa abordagem também é útil para o processamento de dados em tempo real e em ambientes com espaço de armazenamento limitado. Neste artigo, você aprenderá a criar, carregar, modificar e salvar arquivos Excel usando streams em C#.

Configurar o ambiente de desenvolvimento

Para executar os exemplos de código, crie um projeto .NET e adicione uma biblioteca compatível com a manipulação de arquivos Excel. Consulte a documentação oficial da biblioteca escolhida para configurar os pacotes e as dependências necessárias.

PM> Install-Package Spire.XLS

Criar um arquivo Excel dinamicamente e salvá-lo em um stream

Em C#, é possível criar arquivos Excel dinamicamente na memória inicializando um objeto Workbook, preenchendo-o com dados e aplicando formatações. Em seguida, o arquivo pode ser salvo em um stream usando o método Workbook.SaveToStream(). Essa abordagem dispensa o armazenamento de arquivos físicos, contribuindo para melhorar o desempenho e a capacidade de resposta da aplicação.

A seguir, estão as etapas para criar um arquivo Excel e salvá-lo em um stream usando C#:

  • Crie uma instância da classe Workbook para gerar uma nova pasta de trabalho do Excel, que inclui três planilhas por padrão.
  • Recupere uma planilha específica usando a propriedade Workbook.Worksheets[].
  • Defina os dados que serão inseridos na planilha, utilizando, por exemplo, um DataTable para organizá-los.
  • Insira os dados na planilha usando o método Worksheet.InsertDataTable() ou a propriedade Worksheet.Range[].Value para definir valores em células individuais.
  • Formate as células da planilha aplicando estilos como cores, fontes e bordas, ou ajustando a largura das colunas conforme necessário.
  • Salve a pasta de trabalho em um fluxo de memória usando o método Workbook.SaveToStream(). O stream pode ser utilizado em etapas posteriores, como salvar o conteúdo em um arquivo ou transmiti-lo pela rede.

O código de exemplo completo é apresentado a seguir.

using Spire.Xls;
using System.Data;
using System.Drawing;

namespace CreateExcelStream
{
    class Program
    {
        static void Main(string[] args)
        {
            // Criar uma nova instância de Workbook
            Workbook workbook = new Workbook();

            // Acessar a primeira planilha da pasta de trabalho
            Worksheet sheet = workbook.Worksheets[0];

            // Criar e preencher um DataTable com dados de exemplo
            DataTable dataTable = new DataTable("Data");
            dataTable.Columns.Add("ID", typeof(int));
            dataTable.Columns.Add("Name", typeof(string));
            dataTable.Columns.Add("Age", typeof(int));
            dataTable.Columns.Add("Country", typeof(string));
            dataTable.Columns.Add("Salary ($)", typeof(decimal));
            dataTable.Rows.Add(101, "John Smith", 28, "USA", 54000m);
            dataTable.Rows.Add(102, "Maria Garcia", 34, "Spain", 65500m);
            dataTable.Rows.Add(103, "Liam Johnson", 22, "Canada", 48000m);
            dataTable.Rows.Add(104, "Emma Brown", 30, "Australia", 72300m);
            dataTable.Rows.Add(105, "Wei Zhang", 40, "China", 58700m);
            dataTable.Rows.Add(106, "Sofia Lopez", 26, "Mexico", 45200m);

            // Inserir os dados do DataTable na planilha
            sheet.InsertDataTable(dataTable, true, 1, 1);

            // Formatar a planilha
            // Definir o estilo da linha de cabeçalho
            sheet.Rows[0].Style.Color = Color.LightGreen;
            sheet.Rows[0].Style.Font.FontName = "Arial";
            sheet.Rows[0].Style.Font.Size = 12f;
            sheet.Rows[0].BorderAround(); // Aplicar bordas ao redor da linha de cabeçalho
            sheet.Rows[0].Borders.Color = Color.Blue;

            // Definir o estilo das linhas de dados
            for (int i = 1; i < sheet.AllocatedRange.Rows.Count(); i++)
            {
                sheet.Rows[i].Style.Color = Color.LightGray;
                sheet.Rows[i].Style.Font.FontName = "Arial";
                sheet.Rows[i].Style.Font.Size = 11f;
            }

            // Ajustar automaticamente a largura das colunas de acordo com o conteúdo
            for (int j = 1; j <= sheet.AllocatedRange.Columns.Count(); j++)
            {
                sheet.AutoFitColumn(j);
            }

            // Salvar a pasta de trabalho em um fluxo de memória
            MemoryStream stream = new MemoryStream();
            workbook.SaveToStream(stream, FileFormat.Version2016);

            // Gravar o conteúdo do stream em um arquivo
            File.WriteAllBytes("output/CreateExcelByStream.xlsx", stream.ToArray());

            // Liberar os recursos
            workbook.Dispose();
        }
    }
}

Carregar e Ler Arquivos Excel de um Stream com C#

Em C#, é possível carregar arquivos Excel diretamente de um stream usando o método Workbook.LoadFromStream(). Após carregar o arquivo, os desenvolvedores podem acessar e ler facilmente os dados das células. Essa abordagem otimiza o uso da memória e permite um processamento de dados rápido e flexível, sem a necessidade de operações de entrada e saída de arquivos.

As etapas para carregar e ler arquivos Excel de streams com C# são as seguintes:

  • Crie uma instância de Workbook.
  • Crie um objeto MemoryStream ou FileStream.
  • Use o método Workbook.LoadFromStream() para carregar o arquivo Excel do stream para a pasta de trabalho.
  • Recupere a primeira planilha usando a propriedade Workbook.Worksheets[].
  • Percorra as linhas e colunas da planilha para extrair os valores das células por meio da propriedade Worksheet.AllocatedRange[].Value.
  • Exiba os dados extraídos ou utilize-os em operações posteriores.

O código de exemplo completo é apresentado a seguir.

using Spire.Xls;

namespace LoadExcelStream
{
    class Program
    {
        static void Main(string[] args)
        {
            // Cria uma instância da classe Workbook
            Workbook workbook = new Workbook();

            // Cria um fluxo de memória
            MemoryStream stream = new MemoryStream();
            File.OpenRead("Sample.xlsx").CopyTo(stream);

            // Carrega o arquivo Excel a partir do fluxo
            workbook.LoadFromStream(stream);

            // Acessa a primeira planilha da pasta de trabalho
            Worksheet sheet = workbook.Worksheets[0];

            // Inicializa uma lista para armazenar os dados obtidos da planilha
            List<List<string>> data = new List<List<string>>();
            for (int i = 0; i < sheet.AllocatedRange.Rows.Count(); i++)
            {
                // Cria uma lista para armazenar os dados de cada linha
                List<string> lines = new List<string>();
                for (int j = 0; j < sheet.AllocatedRange.Columns.Count(); j++)
                {
                    // Obtém o texto da célula e o adiciona à linha
                    lines.Add(sheet.AllocatedRange[i + 1, j + 1].Text);
                }
                // Adiciona a linha à lista de dados
                data.Add(lines);
            }

            // Exibe os dados obtidos ou os utiliza em operações posteriores
            foreach (List<string> lines in data)
            {
                Console.WriteLine(string.Join(" | ", lines));
            }
        }
    }
}

Modificar um Arquivo Excel em um Stream com C#

Em C#, é possível modificar um arquivo Excel na memória carregando-o primeiro em um objeto Workbook por meio do método LoadFromStream(). Após realizar as alterações, como modificar valores de células ou formatação, o arquivo pode ser salvo novamente em um stream usando o método Workbook.SaveToStream(). Essa abordagem permite atualizar arquivos Excel diretamente na memória, sem depender de armazenamento físico.

Siga as etapas abaixo para modificar arquivos Excel em streams com C#:

  • Crie uma instância de Workbook para representar o arquivo Excel.
  • Crie uma instância de MemoryStream ou FileStream.
  • Use o método Workbook.LoadFromStream() para carregar o arquivo Excel do stream.
  • Acesse a primeira planilha por meio da propriedade Workbook.Worksheets[].
  • Modifique a formatação da linha de cabeçalho e das linhas de dados (fonte, tamanho, cor de fundo etc.) usando as propriedades de CellRange.Style.
  • Ajuste automaticamente a largura das colunas de acordo com o conteúdo usando o método Worksheet.AutoFitColumn().
  • Salve as alterações no stream usando o método Workbook.SaveToStream().

O código de exemplo completo é apresentado a seguir.

using Spire.Xls;
using System.Drawing;

namespace ModifyExcelStream
{
    class Program
    {
        static void Main(string[] args)
        {
            // Cria uma nova instância da classe Workbook
            Workbook workbook = new Workbook();

            // Cria um fluxo de memória
            MemoryStream stream = new MemoryStream();
            File.OpenRead("Sample.xlsx").CopyTo(stream);

            // Carrega o arquivo Excel a partir do fluxo
            workbook.LoadFromStream(stream);

            // Acessa a primeira planilha da pasta de trabalho
            Worksheet sheet = workbook.Worksheets[0];

            // Modifica a formatação da linha de cabeçalho
            CellRange headerRow = sheet.AllocatedRange.Rows[0];
            headerRow.Style.Font.FontName = "Times New Roman";
            headerRow.Style.Font.Size = 12f;
            headerRow.Style.Color = Color.LightBlue;

            // Modifica a formatação das linhas de dados
            for (int i = 1; i < sheet.AllocatedRange.Rows.Count(); i++)
            {
                CellRange dataRow = sheet.AllocatedRange.Rows[i];
                dataRow.Style.Font.FontName = "Arial";
                dataRow.Style.Font.Size = 10f;
                dataRow.Style.Color = Color.LightGray;
                // Alterna a cor de fundo das linhas pares
                if (i % 2 == 0)
                {
                    dataRow.Style.Color = Color.LightSlateGray;
                }
            }

            // Ajusta automaticamente a largura das colunas de acordo com o conteúdo
            for (int k = 1; k <= sheet.AllocatedRange.Columns.Count(); k++)
            {
                sheet.AutoFitColumn(k);
            }

            // Altera a cor das bordas
            sheet.AllocatedRange.Style.Borders.Color = Color.White;

            // Salva a pasta de trabalho modificada novamente no fluxo
            workbook.SaveToStream(stream);

            // Grava o conteúdo do fluxo em um novo arquivo
            File.WriteAllBytes("output/ModifyExcelByStream.xlsx", stream.ToArray());

            // Libera os recursos
            workbook.Dispose();
        }
    }
}

Conclusão

Com C#, é possível modificar arquivos Excel diretamente na memória usando streams. Você pode alterar a fonte, o tamanho, a cor de fundo e a cor das bordas das linhas de cabeçalho e de dados, além de ajustar automaticamente a largura das colunas de acordo com o conteúdo. Após as modificações, o arquivo pode ser salvo no stream e exportado como um novo arquivo Excel. Essa abordagem é útil para processar dados do Excel com eficiência, reduzindo a necessidade de acessar arquivos físicos.

Carregando publicação patrocinada...