Tabla + Matriz + Archivos - Ejercicio De Programacion C# Sharp

En este ejercicio, se te pide que amplíes el ejercicio anterior (tablas + array) añadiendo dos nuevos métodos. El primero de estos métodos debe encargarse de volcar los datos de un array en un archivo binario. El segundo método debe ser capaz de restaurar esos datos del archivo binario al array original. Este proceso implica escribir los datos del array de manera eficiente en un archivo binario y luego leer ese archivo para recuperar la información, lo que permite la persistencia de datos. A través de este ejercicio, aprenderás a trabajar con operaciones de entrada y salida de archivos binarios, lo que es útil cuando necesitas almacenar datos de forma compacta y rápida. El enfoque de trabajar con archivos binarios te ayudará a comprender cómo gestionar datos de manera eficiente en aplicaciones que requieren manejar grandes volúmenes de información.

 Categoría

Persistencia de Objetos

 Ejercicio

Tabla + Matriz + Archivos

 Objectivo

Expanda el ejercicio del 9 de enero (tablas + matriz), de modo que contenga dos nuevos métodos, volcar los datos de la matriz en un archivo binario y restaurar los datos del archivo.

 Ejemplo Ejercicio C#

 Copiar Código C#
// Importing necessary namespaces
using System; // To use general .NET functionalities
using System.IO; // To perform file I/O operations

// Define a class to represent the structure of the table
class Table
{
    public string Name { get; set; } // Name of the table
    public string Description { get; set; } // Description of the table
    public int[] Data { get; set; } // Array to store table data

    // Constructor to initialize a new Table with a name, description, and data
    public Table(string name, string description, int[] data)
    {
        Name = name; // Assign name to the table
        Description = description; // Assign description to the table
        Data = data; // Assign the array of data to the table
    }

    // Method to dump the table's data into a binary file
    public void DumpToBinaryFile(string fileName)
    {
        try
        {
            // Open a new binary file for writing
            using (BinaryWriter writer = new BinaryWriter(File.Open(fileName, FileMode.Create)))
            {
                // Write the table name to the file
                writer.Write(Name);
                // Write the table description to the file
                writer.Write(Description);
                // Write the size of the data array
                writer.Write(Data.Length);

                // Write each element of the data array to the file
                foreach (var item in Data)
                {
                    writer.Write(item); // Write individual elements of the data array
                }
            }

            // Notify that the data has been written successfully
            Console.WriteLine("Data dumped successfully to the binary file.");
        }
        catch (Exception ex)
        {
            // Display error message if any exception occurs
            Console.WriteLine($"Error writing to binary file: {ex.Message}");
        }
    }

    // Method to restore the table's data from a binary file
    public static Table RestoreFromBinaryFile(string fileName)
    {
        try
        {
            // Open the binary file for reading
            using (BinaryReader reader = new BinaryReader(File.Open(fileName, FileMode.Open)))
            {
                // Read the table name
                string name = reader.ReadString();
                // Read the table description
                string description = reader.ReadString();
                // Read the size of the data array
                int length = reader.ReadInt32();

                // Initialize an array to hold the data
                int[] data = new int[length];

                // Read the data array from the file
                for (int i = 0; i < length; i++)
                {
                    data[i] = reader.ReadInt32(); // Read each integer from the file
                }

                // Return a new Table object with the restored data
                return new Table(name, description, data);
            }
        }
        catch (Exception ex)
        {
            // Display error message if any exception occurs
            Console.WriteLine($"Error reading from binary file: {ex.Message}");
            return null;
        }
    }
}

// Main class to demonstrate the Table and array functionality
class Program
{
    static void Main(string[] args)
    {
        // Example data to be used in the table
        int[] tableData = new int[] { 1, 2, 3, 4, 5 };

        // Create a new table instance
        Table table = new Table("Table1", "Example Table Description", tableData);

        // Dump the table data to a binary file
        table.DumpToBinaryFile("tableData.bin");

        // Restore the table data from the binary file
        Table restoredTable = Table.RestoreFromBinaryFile("tableData.bin");

        // Check if the table has been restored successfully
        if (restoredTable != null)
        {
            // Display the restored table data
            Console.WriteLine($"Restored Table Name: {restoredTable.Name}");
            Console.WriteLine($"Restored Table Description: {restoredTable.Description}");
            Console.WriteLine("Restored Data:");
            foreach (var item in restoredTable.Data)
            {
                Console.Write(item + " "); // Display each item from the restored data array
            }
        }
    }
}

 Salida

Data dumped successfully to the binary file.
Restored Table Name: Table1
Restored Table Description: Example Table Description
Restored Data:
1 2 3 4 5 

 Comparte este Ejercicio C# Sharp

 Más Ejercicios de Programacion C# Sharp de Persistencia de Objetos

¡Explora nuestro conjunto de ejercicios de programación C# Sharp! Estos ejercicios, diseñados específicamente para principiantes, te ayudarán a desarrollar una sólida comprensión de los conceptos básicos de C#. Desde variables y tipos de datos hasta estructuras de control y funciones simples, cada ejercicio está diseñado para desafiarte de manera gradual a medida que adquieres confianza en la codificación en C#.

  •  Tabla + SetOfTables + archivos

    En este ejercicio, deberás expandir el ejercicio anterior (tablas + array + archivos) creando tres nuevas clases: Table, SetOfTables...

  •  Insectos + persistencia

    En este ejercicio, debes crear una nueva versión del ejercicio de los insectos, donde se persistan los datos utilizando algún tipo de almacenamiento, como una ...

  •  Ciudades - persistencia

    En este ejercicio, deberás crear una nueva versión de la base de datos de ciudades, utilizando persistencia para almacenar sus datos en lugar de archivos de texto. El...