# **Tworzenie aplikacji konsolowej: łączenie programowania obiektowego, wejścia/wyjścia plików i danych wprowadzanych przez użytkownika w praktycznym projekcie** --- ## **Wstęp** Aplikacja konsolowa często jest pierwszym praktycznym projektem, który programiści tworzą podczas nauki nowego języka. Choć prosta w wyglądzie, służy jako doskonała platforma do integracji wielu podstawowych koncepcji programowania - **programowania obiektowego (OOP)**, **wejścia/wyjścia plików (I/O)** oraz **obsługi danych wprowadzanych przez użytkownika** - w spójną, funkcjonalną aplikację. W tym rozdziale zaprojektujemy **Aplikację Zarządzania Zadaniami** , która pozwala użytkownikom: - Dodawać, przeglądać i usuwać zadania. - Zapisywać zadania do pliku w celu trwałości. - Ładować zadania z pliku podczas uruchamiania aplikacji. Ten projekt wzmocni: - **Zasady OOP** (enkapsulacja, abstrakcja i projektowanie klas). - **Operacje wejścia/wyjścia plików** (czytanie z plików i zapisywanie do nich). - **Interakcja z użytkownikiem** (obsługa danych wprowadzanych, walidacja i komunikaty zwrotne). - **Zarządzanie błędami** (łagodzenie wyjątków). Do końca tego rozdziału będziesz mieć w pełni funkcjonalną aplikację konsolową, która demonstruje, jak te koncepcje współpracują ze sobą w scenariuszu z życia codziennego. --- ## **Główne koncepcje** ### **1. Przegląd projektu: system zarządzania zadaniami** Aplikacja będzie symulować **Menadżera Listy Zadań** z następującymi funkcjami: - **Dodaj Zadanie**: Użytkownicy mogą wprowadzić opis zadania, a ono zostanie zapisane w pamięci (a później zapisane do pliku). - **Przegląd zadań**: Użytkownicy mogą zobaczyć wszystkie zadania na liście numerowanej. - **Usuń Zadanie**: Użytkownicy mogą usunąć zadanie według jego identyfikatora. - **Zapisz i Załaduj Zadania**: Zadania są utrwalane do pliku (`zadania.txt`) i ładowane podczas uruchamiania aplikacji. --- ### **2. Projekt obiektowy (OOP)** Dobrze zorganizowana aplikacja konsolowa powinna podążać za **zasadami OOP**, aby zapewnić modułowość, ponowną użyteczność i łatwość utrzymania. Poniżej przedstawiamy proponowaną strukturę klasy: #### **Diagram klasy** ``` +-------------------+ +-------------------+ +-------------------+ | Menadżer | | Zadanie | | Obsługa Pliku | +-------------------+ +-------------------+ +-------------------+ | - zadania: lista | | - Id: int | | - ścieżka do pliku: string | | - obsługa plików | | - Opis: string | | - ZapiszZadania() | | Obsługa Pliku | +-------------------+ | - ZaładujZadania() | +-------------------+ +-------------------+ +-------------------+ | + DodajZadanie() | | + ToString() | | + OdczytPliku() | | + PrzeglądZadań() | +-------------------+ | + ZapisPliku() | | + UsuńZadanie() | +-------------------+ +-------------------+ ``` #### **Kluczowe klasy i odpowiedzialność** | **Klasa** | **Odpowiedzialność** | |-----------------|-----------------------------------------------------------------------------------| | **`Zadanie`** | Reprezentuje pojedyncze zadanie z `Id` i `Opisem`. | | **`Menadżer`** | Zarządza kolekcją zadań, obsługuje interakcje z użytkownikiem i przekazuje operacje na plikach do `Obsługa Pliku`. | | **`Obsługa Pliku`** | Obsługuje czytanie z i zapisywanie do pliku (`zadania.txt`). | --- ### **3. Operacje wejścia/wyjścia plików** Wejście/Wyjście plików pozwala aplikacji **utrwalać dane** między sesjami. Będziemy korzystać z: - **`StrumieńCzytelnika`** i **`StrumieńZapisywarki`** do czytania i zapisywania plików tekstowych. - **Obsługa wyjątków** w celu zarządzania błędami związanymi z plikami (np. brak pliku, problemy z uprawnieniami). #### **Kluczowe metody** | **Metoda** | **Opis** | |---------------------|-----------------------------------------------------------------------------| | **`ZapiszZadania()`** | Zapisuje wszystkie zadania do `zadania.txt` w ustrukturyzowanym formacie (np. `Id,Opis`). | | **`ZaładujZadania()`** | Czyta `zadania.txt` i rekonstruuje obiekty `Zadanie`. | | **`OdczytPliku()`** | Metoda pomocnicza do czytania pliku wiersz po wierszu. | | **`ZapisPliku()`** | Metoda pomocnicza do zapisywania danych do pliku. | --- ### **4. Obsługa danych wprowadzanych przez użytkownika** Aplikacja musi: - **Wzywać użytkownika** do wprowadzenia danych (np. "Wprowadź opis zadania:"). - **Walidować dane** (np. upewnij się, że identyfikator zadania istnieje przed usunięciem). - **Wyświetlać komunikaty zwrotne** (np. "Zadanie dodane pomyślnie!" lub "Nieprawidłowy identyfikator zadania."). #### **Kluczowe techniki** - **`Console.ReadLine()`** – przechwytuje dane wprowadzane przez użytkownika jako łańcuch. - **`int.TryParse()`** – bezpiecznie konwertuje dane wprowadzane przez użytkownika do liczby całkowitej. - **`Console.WriteLine()`** – wyświetla komunikaty użytkownikowi. - **Pętle (`while`, `do-while`)** – utrzymuje aplikację w działaniu, dopóki użytkownik nie zakończy. --- ### **5. Zarządzanie błędami** Ponieważ operacje na plikach i dane wprowadzane przez użytkownika mogą nieudawać się, musimy zaimplementować **obsługę wyjątków**, aby: - Złapać **`FileNotFoundException`**, jeśli `zadania.txt` nie istnieje. - Obsłużyć **`FormatException`**, jeśli dane wprowadzane przez użytkownika są nieprawidłowe. - Łagodnie wyjść lub ponowić operację w przypadku błędów. #### **Scenariusze błędów** | **Scenariusz** | **Wyjątek** | **Strategia obsługi** | |---------------------------|-----------------------------|-----------------------------------------------| | Brak pliku | `FileNotFoundException` | Utwórz plik, jeśli go brak. | | Nieprawidłowy identyfikator zadania | `FormatException` | Wzywa użytkownika do ponownego wprowadzenia. | | Podział przez zero (hipotetyczny) | `DivideByZeroException` | Zaloguj błąd i kontynuuj. | --- ## **Krok po kroku wdrożenia** ### **Krok 1: zdefiniuj klasę `Zadanie`** Klasa `Zadanie` przechowuje **ID** i **opis** zadania. ```csharp public class Zadanie { public int Id { get; set; } public string Opis { get; set; } public Zadanie(int id, string opis) { Id = id; Opis = opis; } public override string ToString() { return $"{Id}. {Opis}"; } } ``` **Kluczowe punkty:** - **Właściwości (`Id`, `Opis`)** – enkapsulują dane zadania. - **Konstruktor** – inicjalizuje nowe `Zadanie` z identyfikatorem i opisem. - **Przejście `ToString()`** – zapewnia czytelny format wyświetlania zadań. --- ### **Krok 2: zaimplementuj klasę `Obsługa Pliku`** Ta klasa będzie obsługiwać **czytanie z i zapisywanie do `zadania.txt`**. ```csharp using System; using System.Collections.Generic; using System.IO; public class ObsługaPliku { private string ścieżkaDoPliku; public ObsługaPliku(string ścieżkaDoPliku) { this.ścieżkaDoPliku = ścieżkaDoPliku; } public void ZapiszZadania(List zadania) { try { using (StreamWriter zapisywarka = new StreamWriter(ścieżkaDoPliku)) { foreach (var zadanie in zadania) { zapisywarka.WriteLine($"{zadanie.Id},{zadanie.Opis}"); } } } catch (Exception ex) { Console.WriteLine($"Błąd podczas zapisywania zadań: {ex.Message}"); } } public List ZaładujZadania() { List zadania = new List(); if (!File.Exists(ścieżkaDoPliku)) { Console.WriteLine("Nie znaleziono istniejącego pliku zadań. Rozpoczęto z pustą listą."); return zadania; } try { string[] linie = File.ReadAllLines(ścieżkaDoPliku); foreach (string linia in linie) { string[] części = linia.Split(','); if (części.Length == 2) { int id = int.Parse(części[0]); string opis = części[1]; zadania.Add(new Zadanie(id, opis)); } } } catch (Exception ex) { Console.WriteLine($"Błąd podczas ładowania zadań: {ex.Message}"); } return zadania; } } ``` **Kluczowe punkty:** - **`ZapiszZadania()`** - Używa `StreamWriter` do zapisywania każdego zadania jako `Id,Opis` w `zadania.txt`. - Obejmuje blok `try-catch`, aby obsługiwać błędy plików. - **`ZaładujZadania()`** - Sprawdza, czy plik istnieje; jeśli nie, zwraca pustą listę. - Czyta każdą linię, dzieli według `,`, a następnie rekonstruuje obiekty `Zadanie`. - Obsługuje błędy parsowania łagodnie. --- ### **Krok 3: zbuduj klasę `Menadżer`** Ta klasa będzie **zarządzać zadaniami**, **interaktywna z użytkownikiem** i **delegować operacje na plikach** do `Obsługa Pliku`. ```csharp using System; using System.Collections.Generic; public class Menadżer { private List zadania; private ObsługaPliku obsługaPliku; private int następnyId = 1; public Menadżer(string ścieżkaDoPliku) { obsługaPliku = new ObsługaPliku(ścieżkaDoPliku); zadania = obsługaPliku.ZaładujZadania(); // Ustaw następnyId na najwyższy istniejący ID + 1 if (zadania.Count > 0) { następnyId = zadania.Count + 1; } } public void DodajZadanie(string opis) { Zadanie noweZadanie = new Zadanie(następnyId++, opis); zadania.Add(noweZadanie); Console.WriteLine("Zadanie dodane pomyślnie!"); } public void PrzeglądZadań() { if (zadania.Count == 0) { Console.WriteLine("Nie znaleziono zadań."); return; } Console.WriteLine("\n--- Twoje Zadania ---"); foreach (var zadanie in zadania) { Console.WriteLine(zadanie); } } public void UsuńZadanie(int id) { Zadanie zadanieDoUsunięcia = zadania.Find(t => t.Id == id); if (zadanieDoUsunięcia != null) { zadania.Remove(zadanieDoUsunięcia); Console.WriteLine("Zadanie usunięte pomyślnie!"); } else { Console.WriteLine("Zadanie nie znaleziono."); } } public void ZapiszIWyjdź() { obsługaPliku.ZapiszZadania(zadania); Console.WriteLine("Zadania zapisane. Dziękujemy!"); Environment.Exit(0); } } ``` **Kluczowe punkty:** - **Konstruktor** - Inicjalizuje `ObsługaPliku` i ładuje istniejące zadania. - Ustawia `następnyId` na najwyższy istniejący ID + 1 (lub 1, jeśli nie ma zadań). - **`DodajZadanie()`** - Tworzy nowe `Zadanie` z automatycznie przydzielonym ID. - **`PrzeglądZadań()`** - Wyświetla wszystkie zadania na liście numerowanej lub komunikat, jeśli nie ma zadań. - **`UsuńZadanie()`** - Znajduje i usuwa zadanie według ID (jeśli istnieje). - **`ZapiszIWyjdź()`** - Zapisuje zadania do `zadania.txt` i kończy działanie aplikacji. --- ### **Krok 4: Utwórz program główny (pętla interakcji z użytkownikiem)** Klasa `Program` będzie **koordynować interfejs użytkownika** i **wywoływać metody `Menadżera`**. ```csharp using System; class Program { static void Main(string[] args) { string ścieżkaDoPliku = "zadania.txt"; Menadżer menadżer = new Menadżer(ścieżkaDoPliku); bool działający = true; while (działający) { Console.WriteLine("\n--- Menadżer Zadań ---"); Console.WriteLine("1. Dodaj Zadanie"); Console.WriteLine("2. Przegląd Zadań"); Console.WriteLine("3. Usuń Zadanie"); Console.WriteLine("4. Wyjdź"); Console.Write("Wybierz opcję: "); string daneWprowadzane = Console.ReadLine(); switch (daneWprowadzane) { case "1": Console.Write("Wprowadź opis zadania: "); string opis = Console.ReadLine(); menadżer.DodajZadanie(opis); break; case "2": menadżer.PrzeglądZadań(); break; case "3": Console.Write("Wprowadź ID zadania do usunięcia: "); if (int.TryParse(Console.ReadLine(), out int id)) { menadżer.UsuńZadanie(id); } else { Console.WriteLine("Nieprawidłowy ID. Wprowadź liczbę."); } break; case "4": menadżer.ZapiszIWyjdź(); break; default: Console.WriteLine("Nieprawidłowa opcja. Spróbuj ponownie."); break; } } } } ``` **Kluczowe punkty:** - **Pętla menu** - Wyświetla opcje i odczytuje dane wprowadzane przez użytkownika w pętli `while`. - **Obługa przełączników** - Wywołuje odpowiednią metodę `Menadżera` w zależności od wyboru użytkownika. - **Walidacja danych wprowadzanych przez użytkownika** - Używa `int.TryParse()` do zapewnienia prawidłowego wprowadzania ID zadania. - **Łagodne wyjście** - Zapisuje zadania przed wyjściem. --- ## **Przykładowy przepływ** ### **Scenariusz: dodawanie i wyświetlanie zadań** 1. **Uruchom aplikację.** ``` --- Menadżer Zadań --- 1. Dodaj Zadanie 2. Przegląd Zadań 3. Usuń Zadanie 4. Wyjdź Wybierz opcję: 1 ``` 2. **Wprowadź opis zadania.** ``` Wprowadź opis zadania: Kupuj zakupy Zadanie dodane pomyślnie! ``` 3. **Wyświetl zadania.** ``` --- Twoje Zadania --- 1. Kupuj zakupy ``` 4. **Dodaj kolejne zadanie.** ``` Wprowadź opis zadania: Zakończ lekcję C# Zadanie dodane pomyślnie! ``` 5. **Wyświetl zadania ponownie.** ``` --- Twoje Zadania --- 1. Kupuj zakupy 2. Zakończ lekcję C# ``` ### **Scenariusz: usuwanie zadania i zapisywanie do pliku** 1. **Usuń zadanie według ID.** ``` Wprowadź ID zadania do usunięcia: 1 Zadanie usunięte pomyślnie! ``` 2. **Wyświetl pozostałe zadania.** ``` --- Twoje Zadania --- 2. Zakończ lekcję C# ``` 3. **Wyjdź z aplikacji (zadania są zapisywane do `zadania.txt`).** ``` Zadania zapisane. Dziękujemy! ``` ### Contenido del archivo (`zadania.txt`)** Po uruchomieniu przykładu`zadania.txt` będzie zawierać: ``` 2,Zakończ lekcję C# ``` --- ### **Ćwiczenia praktyczne** ### **Ćwiczenie 1: ulepsz funkcje zadania** Dodaj następujące funkcje do klasy `Zadanie`: - Własość **`Termin**`(np. `DateTime`). - Własość `jestKompletne` flagę bool. - Zmodyfikuj `Obsługa Pliku` aby zapisywać i ładować te nowe właściwości. Przykładowe dane wyjściowe: ``` 1. [ ] Kupuj zakupy (Do: 2023-12-31) 2. [X] Zakończ lekcję C# (Do: 2023-11-15) ``` --- ### **Ćwiczenie 2: Dodaj kategorie zadań** Rozbuduj aplikację do obsługi **kategorii zadań** (np. "Praca", "Osobista", "Zakupy"). - Zmodyfikuj klasę `Zadanie`, aby uwzględnić właściwość kategorii. - Aktualizuj format pliku do `ID, opis, kategoria`. - Dodaj opcję menu, aby **filtrować zadania według kategorii**. Przykładowe dane wyjśnięte: ``` --- Filtrowanie zadań --- 1. Praca 2. Osobista 3. Zakupy Wybierz kategorię: 1 ``` ### ### **Ćwiczenie 3: Implementowanie edycji zadań** Dodaj funkcjonalności w celu edycji istniejącego zadania: - Wprowadź ID zadania i nowego **opisu**. - Zaktualizuj zadanie w pamięci i zapisz do pliku. **Przykład 편): ``` Wprowadź ID zadania do edycji: 1 Wprowadź nowy opis: Kupuj mleko i jajka Zadanie zaktualizowane pomyślnie! ``` ### ### **Ćwiczenie 4: Dodaj dane wwalidacja** Popraw.validation volgende zasady: - **Opisy zadań** nie mogą być puste. - **ID zadań** muszą istnieć przed usunięciem/edycji. - **Datę zakończenia muszą być w przyszłym czasie** Przykładowe postępowanie: ``` Wprowadź opis zadania: (puste dane) Błąd: Opis zadania nie może być pusty. ``` ### ### ## **Wykluczający słowa kluczowe/termity**: ### --- ## **Wykluczane słowa kluczowe/termity:” { Markdown } # **Construcción de una aplicación de consola: combinación de OOP, entrada/salida de archivo y entrada de usuario para un proyecto práctico** --- ## **Introducción** Una aplicación de consola a menudo es el primer proyecto práctico que los desarrolladores construyen cuando aprenden un nuevo lenguaje. Aunque simple en apariencia, sirve como una plataforma excelente para integrar múltiples conceptos de programación fundamentales, como: **programación orientada a objetos (OOP)**, **entrada/salida de archivos (I/O)** y **manejo de entrada de usuario** en una aplicación funcional cohesiva. En este capítulo, diseñaremos una aplicación de **Gestión de Tareas** que permite a los usuarios: - Agregar, ver y eliminar tareas. - Guardar tareas en un archivo para su persistencia. - Cargar tareas desde un archivo cuando se inicia la aplicación. Este proyecto reforzará: - Principios de **OOP** (encapsulación, abstracción y diseño de clases). - Operaciones de **entrada/salida de archivos** (lectura y escritura de archivos). - Interacción con el usuario (manejo de entrada, validación y retroalimentación). - Manejo de errores (gestión suave de excepciones). Al final de este capítulo, tendrá una aplicación de consola completamente funcional que demuestra cómo trabajar juntos estos conceptos en un escenario del mundo real. --- ## **Conceptos clave** ### **1. Descripción general del proyecto: sistema de gestión de tareas** La aplicación simulará un **gestor de lista de tareas** con las siguientes características: - **Agregar tarea**: Los usuarios pueden ingresar una descripción de la tarea y se almacenará en memoria (y luego se guardará en un archivo). - **Ver tareas**: Los usuarios pueden ver todas las tareas en una lista numerada. - **Eliminar tarea**: Los usuarios pueden eliminar una tarea por su ID. - **Guardar y cargar tareas**: Las tareas se guardan en un archivo (`tasks.txt`) y se cargan cuando se inicia la aplicación. --- ### **2. Diseño orientado a objetos (OOP)** Una aplicación de consola bien estructurada debe seguir los principios de **OOP** para garantizar la modularidad, reutilización y facilidad de mantenimiento. A continuación, se propone una estructura de clases: #### **Diagrama de clases** ``` +-------------------+ +-------------------+ +-------------------+ | Gestor de | | Tarea | | Manejador de | +-------------------+ +-------------------+ +-------------------+ | - tareas: lista de | | - ID: int | | - ruta del archivo: string | | - Manejador de | | - Descripción: | | - GuardarTareas() | | archivo | +-------------------+ | - CargarTareas() | +-------------------+ | | +-------------------+ | + AgregarTarea() | | + ToString() | | + LeerArchivo() | | + VerTareas() | +-------------------+ | + EscribirArchivo()| | + EliminarTarea() | +-------------------+ +-------------------+ ``` #### **Clases y responsabilidades clave** | **Clase** | **Responsabilidad** | |-----------------|-----------------------------------------------------------------------------------| | **`Tarea`** | Representa una sola tarea con un `ID` y `Descripción`. | | **`Gestor`** | Administra la colección de tareas, maneja la interacción con el usuario y delega operaciones de archivo al `Manejador de archivo`. | | **`Manejador de archivo`** | Maneja la lectura y escritura del archivo (`tasks.txt`). | --- ### **3. Operaciones de entrada/salida de archivos** La entrada/salida de archivos permite que la aplicación **guarde datos** entre sesiones. Usaremos: - **`StreamReader`** y **`StreamWriter`** para lectura y escritura de archivos de texto. - **Manejo de excepciones** para gestionar errores relacionados con archivos (por ejemplo, archivo no encontrado, problemas de permisos). #### **Métodos clave** | **Método** | **Descripción** | |---------------------|-----------------------------------------------------------------------------| | **`GuardarTareas()`** | Escribe todas las tareas en `tasks.txt` en un formato estructurado (por ejemplo, `ID,descripción`). | | **`CargarTareas()`** | Lee `tasks.txt` y reconstruye los objetos de tarea. | | **`LeerArchivo()`** | Método auxiliar para leer un archivo línea por línea. | | **`EscribirArchivo()`** | Método auxiliar para escribir datos en un archivo. | --- ### **4. Manejo de entrada de usuario** La aplicación debe: - **Solicitar entrada del usuario** (por ejemplo, "Ingrese descripción de la tarea:"). - **Validar entrada** (por ejemplo, asegúrese de que el ID de la tarea exista antes de eliminarla). - **Mostrar retroalimentación** (por ejemplo, "Tarea agregada correctamente!" o "ID de tarea no válida."). #### **Técnicas clave** - **`Console.ReadLine()`** – captura la entrada del usuario como una cadena. - **`int.TryParse()`** – convierte con seguridad la entrada del usuario a un entero. - **`Console.WriteLine()`** – muestra mensajes al usuario. - **Bucles (`while`, `do-while`)** – mantiene la aplicación en ejecución hasta que el usuario salga. --- ### **5. Manejo de errores** Dado que las operaciones de archivo y la entrada de usuario pueden fallar, debemos implementar **manejo de excepciones** para: - Capturar **`FileNotFoundException`** si `tasks.txt` no existe. - Manejar **`FormatException`** si la entrada del usuario es no válida. - Salir con gracia o reintentar en caso de errores. #### **Escenarios de error** | **Escenario** | **Excepción** | **Estrategia de manejo** | |---------------------------|-----------------------------|-----------------------------------------------| | Archivo no existe | `FileNotFoundException` | Crear el archivo si falta. | | ID de tarea no válido | `FormatException` | Solicitar al usuario que ingrese nuevamente. | | División por cero (hipotético) | `DivideByZeroException` | Registrar el error y continuar. | --- ## **Implementación paso a paso** ### **Paso 1: definir la clase `Tarea`** La clase `Tarea` almacenará el **ID** y **descripcion** de una tarea. ```csharp public class Tarea { public int ID { get; set; } public string Descripcion { get; set; } public Tarea(int id, string descripcion) { ID = id; Descripcion = descripcion; } public override string ToString() { return $"{ID}. {Descripcion}"; } } ``` **Puntos clave:** - **Propiedades (`ID`, `Descripcion`)** – encapsulan los datos de la tarea. - **Constructor** – inicializa una nueva tarea con un ID y descripción. - **Anulaciones `ToString()`** – proporciona un formato legible para mostrar tareas. --- ### **Paso edycja Implementación de la clase `Manejador de archivos`** Esta clase manejará **lectura y escritura de tareas.txt**. ```csharp using System; using System.Collections.Generic; using System.IO; public class ManejadorDeArchivos { private string rutaArchivo; public ManejadorDeArchivos(string rutaArchivo) { this.rutaArchivo = rutaArchivo; } public void GuardarTareas(List tareas) { try { using (StreamWriter escritor = new StreamWriter(rutaArchivo)) { foreach (var tarea in tareas) { escritor.WriteLine($"{tarea.ID},{tarea.Descripcion}"); } } } catch (Exception ex) { Console.WriteLine($"Error al guardar tareas: {ex.Message}"); } } public List CargarTareas() { List tareas = new List(); if (!File.Exists(rutaArchivo)) { Console.WriteLine("No se encontró el archivo de tareas existente. Iniciando con una lista vacía."); return tareas; } try { string[] lineas = File.ReadAllLines(rutaArchivo); foreach (string linea in lineas) { string[] partes = linea.Split(','); if (partes.Length == 2) { int id = int.Parse(partes[0]); string descripcion = partes[1]; tareas.Add(new Tarea(id, descripcion)); } } } catch (Exception ex) { Console.WriteLine($"Error al cargar tareas: {ex.Message}"); } return tareas; } } ``` **Puntos clave:** - **`GuardarTareas()`** - Utiliza `StreamWriter` para escribir cada tarea como `ID,descripcion` en `tasks.txt`. - Envuelto en un `try-catch` para manejar errores de archivo. - **`CargarTareas()`** - Verifica si existe el archivo; si no, devuelve una lista vacía. - Lee cada línea, divide por `,`, y reconstruye objetos de tarea. - Maneja errores de parseo con gracia. --- ### **Paso 3: crear la clase `Gestor`** Esta clase manejará **tareas**, **interactuará con el usuario** y **delegará operaciones de archivo** al `Manejador de archivos`. ```csharp using System; using System.Collections.Generic; public class Gestor { private List tareas; private ManejadorDeArchivos manejadorDeArchivos; private int siguienteID = 1; public Gestor(string rutaArchivo) { manejadorDeArchivos = new ManejadorDeArchivos(rutaArchivo); tareas = manejadorDeArchivos.CargarTareas(); // Establecer siguienteID al ID existente más alto + 1 if (tareas.Count > znajdź { siguienteID = tareas.Count + 1; } } public void AgregarTarea(string descripcion) { Tarea nuevaTarea = new Tarea(siguienteID++, descripcion); tareas.Add(nuevaTarea); Console.WriteLine("Tarea agregada correctamente!"); } public void VerTareas() { if (tareas.Count == 0) { Console.WriteLine("No se encontraron tareas."); return; } Console.WriteLine("\n--- Tus Tareas ---"); foreach (var tarea in tareas) { Console.WriteLine(tarea); } } public void EliminarTarea(int id) { Tarea tareaEliminar = tareas.Find(t => t.ID == id); if (tareaEliminar != null) { tareas.Remove(tareaEliminar); Console.WriteLine("Tarea eliminada correctamente!"); } else { Console.WriteLine("Tarea no encontrada."); } } public void GuardarYsalir() { manejadorDeArchivos.GuardarTareas(tareas); Console.WriteLine("Tareas guardadas. Adiós!"); Environment.Exit(0); } } ``` **Puntos clave:** - **Constructor** - Inicializa `ManejadorDeArchivos` y carga tareas existentes. - Establece `siguienteID` al valor más alto existente `ID` + 1. - **`AgregarTarea()`** - Crea una nueva tarea con un ID auto-incrementado. - **`VerTareas()`** - Muestra todas las tareas en una lista numerada o un mensaje si no hay tareas. - **`EliminarTarea()`** - Encuentra y elimina una tarea por ID (si existe). - **`GuardarYsalir()`** - Guards tareas en `tasks.txt` y cierra la aplicación. --- ### **Paso 4: crear el programa principal (bucle de interacción del usuario)** La clase `Programa` coordinará **interfaz del usuario** y llamará métodos de `Gestor`. ```csharp using System; class Programa { static void Main(string[] args) { string rutaArchivo = "tasks.txt"; Gestor gestor = new Gestor(rutaArchivo); bool enEjecucion = true; while (enEjecucion) { Console.WriteLine("\n--- Gestor de Tareas ---"); Console.WriteLine("1. Agregar Tarea"); Console.WriteLine("2. Ver Tareas"); Console.WriteLine("3. Eliminar Tarea"); Console.WriteLine("4. Salir"); Console.Write("Elija una opción: "); string entrada = Console.ReadLine(); switch (entrada) { case "1": Console.Write("Ingresar descripción de la tarea: "); string descripcion = Console.ReadLine(); gestor.AgregarTarea(descripcion); break; case "2": gestor.VerTareas(); break; case "3": Console.Write("Ingresar ID de tarea para eliminar: "); if (int.TryParse(Console.ReadLine(), out int id)) { gestor.EliminarTarea(id); } else { Console.WriteLine("ID no válido. Por favor, ingrese un número."); } break; case "4": gestor.GuardarYsalir(); break; default: Console.WriteLine("Opción no válida. Por favor, intente nuevamente."); break; } } } } ``` **Puntos clave:** - **Bucle del menú** - Muestra opciones y lee entrada del usuario en un bucle `while`. - **Manejo de casos** - Llama al método apropiado del gestor según la elección del usuario. - **Validación de entrada** - Usa `int.TryParse()` para asegurar entrada válida de ID de tarea. - **Salida elegante** - Guarda tareas antes de salir. --- ## **Ejemplo de flujo de trabajo** ### **Escenario: agregar y visualizar tareas** 1. **Ejecutar la aplicación.** ``` --- Gestor de Tareas --- 1. Agregar Tarea 2. Ver Tareas 3. Eliminar Tarea 4. Salir Elija una opción: 1 ``` 2. **Ingresar descripción de la tarea.** ``` Ingresar descripción de la tarea: Comprar provisiones Tarea agregada correctamente! ``` 3. **Ver tareas.** ``` --- Tus Tareas --- 1. Comprar provisiones ``` 4. **Agregar otra tarea.** ``` Ingresar descripción de la tarea: Finalizar lección C# Tarea agregada correctamente! ``` 5. **Ver tareas nuevamente.** ``` --- Tus Tareas --- 1. Comprar provisiones 2. Finalizar lección C# ``` --- ### **Escenario: eliminar una tarea y guardar en archivo** 1. **Eliminar una tarea por ID.** ``` Ingresar ID de tarea para eliminar: 1 Tarea eliminada correctamente! ``` 2. **Ver tareas restantes.** ``` --- Tus Tareas --- 2. Finalizar lección C# ``` 3. **Salir de la aplicación (tareas guardadas en `tasks.txt`).** ``` Tareas guardadas. Adiós! ``` --- ### **Contenido del archivo (`tasks.txt`)** Después de ejecutar el ejemplo, `tasks.txt` contendrá: ``` 2,Finalizar lección C# ``` --- ## **Conclusiones clave** 1. **OOP en acción** - Las clases `Tarea`, `Gestor` y `ManejadorDeArchivos` demuestran **encapsulación** (ocultamiento de detalles internos) y **separación de preocupaciones** (cada clase tiene una responsabilidad única). - **Abstracción** se logra al exponer solo los métodos necesarios (por ejemplo, `AgregarTarea()`, `VerTareas()`). 2. **Mejores prácticas de E/S de archivos** - Siempre usa bloques `try-catch` al trabajar con archivos para manejar excepciones con gracia. - **`StreamWriter`** y **`StreamReader`** son eficientes para operaciones de archivos basadas en texto. - Almacena datos en un **formato estructurado** (por ejemplo, `ID,descripción`) para facilitar el parseo. 3. **Manejo de entrada de usuario** - **Validar toda la entrada del usuario** (por ejemplo, verificar si existe un ID de tarea antes de eliminar). - Usar **`Console.ReadLine()`** para entrada de texto y **`int.TryParse()`** para entrada numérica. - Proporcionar **retroalimentación clara** (por ejemplo, "Tarea agregada correctamente!" o "Opción no válida."). 4. **Manejo de errores** - Anticipar **errores relacionados con archivos** (por ejemplo, archivo no encontrado, problemas de permisos). - Usar **mensajes de error personalizados** para guiar al usuario sin provocar fallos en la aplicación. 5. **Diseño modular** - Desglosar la aplicación en **clases pequeñas y reutilizables** para una mejor capacidad de mantenimiento. - **Delegar operaciones de archivo** a una clase separada (`ManejadorDeArchivos`) para mantener limpio al `Gestor`. 6. **Persistencia con almacenamiento de archivos** - Guardar datos en un archivo garantiza que las tareas **no sean perdidas** cuando se cierra la aplicación. - Cargar tareas al inicio proporciona una experiencia suave para el usuario. --- ## **Ejercicios para practicar** Para reforzar su comprensión, pruebe estos ejercicios: ### **Ejercicio 1: mejorar las características de las tareas** Agregar las siguientes características a la clase `Tarea`: - Una propiedad **`FechaDeVencimiento`** (por ejemplo, `DateTime`). - Una bandera booleana **`EstaCompletada`**. - Modificar `ManejadorDeArchivos` para guardar y cargar estas propiedades nuevas. **Salida de ejemplo:** ``` 1. [ ] Comprar provisiones (Vencimiento: 2023-12-31) 2. [X] Finalizar lección C# (Vencimiento: 2023-11-15) ``` --- ### **Ejercicio 2: agregar categorías de tareas** Extender la aplicación para admitir **categorías de tareas** (por ejemplo, "Trabajo", "Personal", "Compras"). - Modificar la clase `Tarea` para incluir una propiedad `Categoria`. - Actualizar el formato de archivo a `ID, Descripcion, Categoria`. - Agregar una opción de menú para **filtrar tareas por categoría**. **Ejemplo:** ``` --- Filtrar tareas --- 1. Trabajo 2. Personal 3. Compras Elija una categoría: 1 ``` --- ### **Ejercicio 3: implementar edición de tareas** Agregar una función para **editar una tarea existente**: - Pedirle al usuario un **ID de tarea** y una nueva **descripcion**. - Actualizar la tarea en memoria y guardarla en el archivo. **Ejemplo:** ``` Introduzca el ID de tarea a editar: 1 Introduzca la nueva descripción: Comprar leche y huevos Tarea actualizada correctamente! ``` --- ### **Ejercicio 4: agregar validación de datos** Mejorar la validación de entrada con las siguientes reglas: - **Descripciones de tareas** no pueden estar vacías. - **ID de tareas** debe existir antes de eliminar/editar. - **Fechas de vencimiento** deben ser en el futuro. **Ejemplo de manejo de errores:** ``` Ingresar descripción de la tarea: (entrada vacía) Error: La descripción de la tarea no puede estar vacía. ``` --- ## **Pensamientos finales** Esta aplicación de consola demuestra cómo la **OOP, E/S de archivos y manejo de entrada del usuario** pueden combinarse para producir un programa **funcional y práctico**. Si bien es simple, sirve como una base para aplicaciones más complejas, como: - **Aplicaciones de escritorio** (WPF, WinForms). - **API web** (ASP.NET Core) con lógica similar de gestión de tareas. - **Sistemas respaldados por bases de datos** (Entity Framework Core). Al dominar estos conceptos, está bien encaminado para convertirse en un desarrollador **competente de C#**, capaz de crear aplicaciones **escalables y mantenibles**.

Building a Console Application: Combining OOP, File I/O, and User Input for a Practical Project