Odczyt i zapis plików w C#

Tim Corey

24m 34s

Operacje wejścia/wyjścia (I/O) plików w C# są nieodłączną częścią wielu aplikacji programowych, pozwalając deweloperom na efektywny odczyt i zapis plików. Bez wzgledu na to, czy przechowujesz dane, rejestrujesz zdarzenia aplikacji, czy przetwarzasz duza ilosc tekstu lub danych binarnych, C# oferuje solidne narzędzia do pracy z plikami. W filmie Tima Coreya, "C# Data Access: Text Files", oferuje szczegółowy przewodnik po tych operacjach na plikach, skupiajac sie na użyciu plików tekstowych do przechowywania i pobierania danych. Niniejszy artykuł ma na celu podsumowanie kluczowych pojec i technik, ktore Tim omawia w filmie, dostarczając praktycznych wskazowek dotyczących operacji I/O plików w C#.

Wprowadzenie

W C#, operacje wejscia i wyjscia na plikach sa niezbędne do odczytu i zapisu plików tekstowych. Klasa File zapewnia statyczne metody do interakcji z istniejącymi plikami lub tworzenia nowych. StreamReader i StreamWriter są często używane do odczytu i zapisu plików. StreamReader odczytuje pliki linia po linii, umożliwiając dostęp do każdej linii tekstu lub tablicy napisów. Można również użyć pętli while, aby efektywnie odczytać większe pliki. Klasa StreamWriter jest używana do zapisu danych do pliku, wspierając zapis łańcuchów i tablic. Można jej użyć do dodawania tekstu do istniejącego pliku lub nadpisania całego pliku. Metody takie jak WriteLine i WriteText umożliwiają łatwą manipulację danymi w plikach tekstowych.

Te operacje zazwyczaj są wykonywane w metodzie static void Main, gdzie definiuje się ścieżkę pliku. Na przykład, można określić nazwę pliku i użyć StreamWriter do zapisu pojedynczego łańcucha lub całej tablicy łańcuchów. Instrukcja using zapewnia, że plik jest prawidłowo zamykany po operacjach, zapobiegając wyciekom zasobów. StreamReader może być również używane do odczytu plików linia po linii, a wyjątki mogą być obsługiwane, aby zarządzać potencjalnymi błędami, gdy plik nie istnieje lub nie można go uzyskać dostępu. Te możliwosci I/O plików czynia C# doskonalym wyborem do pracy z plikami wydajnie i efektywnie.

Tim wprowadza temat, podkreślajac prostote odczytu i zapisu plików tekstowych w C#. Demonstruje, jak kilka linijek kodu może wykonac te zadania, czyniac pliki tekstowe realna opcja do przechowywania danych.

Tworzenie aplikacji konsolowej demonstracyjnej

Tim rozpoczyna od stworzenia nowej aplikacji konsolowej nazwanej "TextFileDataAccessDemo" używajac Visual Studio.

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace TextFileDataAccessDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine(); // Keeps the console window open to view the output
        }
    }
}

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace TextFileDataAccessDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine(); // Keeps the console window open to view the output
        }
    }
}

Imports System
Imports System.IO
Imports System.Collections.Generic
Imports System.Linq

Namespace TextFileDataAccessDemo
    Class Program
        Shared Sub Main(ByVal args As String())
            Console.ReadLine() ' Keeps the console window open to view the output
        End Sub
    End Class
End Namespace

Imports System
Imports System.IO
Imports System.Collections.Generic
Imports System.Linq

Namespace TextFileDataAccessDemo
    Class Program
        Shared Sub Main(ByVal args As String())
            Console.ReadLine() ' Keeps the console window open to view the output
        End Sub
    End Class
End Namespace

Wyjaśnia on użycie Console.ReadLine, aby utrzymać okno konsoli otwarte, umożliwiając użytkownikom zobaczenie wyniku.

Odczyt z pliku tekstowego

Tim pokazuje, jak odczytać plik tekstowy za pomocą metody File.ReadAllLines. Pokazuje, jak sobie radzic ze ścieżkami plików i używac literałow ciagow, aby uniknąć znakow ucieczki.

string filePath = @"C:\demos\test.txt";
List<string> lines = File.ReadAllLines(filePath).ToList();

string filePath = @"C:\demos\test.txt";
List<string> lines = File.ReadAllLines(filePath).ToList();

Dim filePath As String = "C:\demos\test.txt"
Dim lines As List(Of String) = File.ReadAllLines(filePath).ToList()

Dim filePath As String = "C:\demos\test.txt"
Dim lines As List(Of String) = File.ReadAllLines(filePath).ToList()

Metoda File.ReadAllLines odczytuje wszystkie linie z określonego pliku i zwraca je jako tablicę łańcuchów. Tim konwertuje te tablice na liste dla łatwiejszej manipulacji.

Zapisywanie do pliku tekstowego

Tim wyjaśnia, jak zapisać dane do pliku tekstowego przy użyciu metody File.WriteAllLines. Demonstruje, jak dodawac nowe linie do listy i zapisywac zaktualizowana liste z powrotem do pliku.

lines.Add("Sue,Storm,WWIStorm.com");
File.WriteAllLines(filePath, lines);

lines.Add("Sue,Storm,WWIStorm.com");
File.WriteAllLines(filePath, lines);

lines.Add("Sue,Storm,WWIStorm.com")
File.WriteAllLines(filePath, lines)

lines.Add("Sue,Storm,WWIStorm.com")
File.WriteAllLines(filePath, lines)

Ten kod dodaje nowy wpis do listy i zapisuje cała liste z powrotem do pliku.

Tworzenie modelu danych i jego wypelnianie z pliku

Tim tworzy klasę Person, aby reprezentować strukturę danych dla każdego wpisu w pliku tekstowym.

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string URL { get; set; }
}

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string URL { get; set; }
}

Public Class Person
    Public Property FirstName As String
    Public Property LastName As String
    Public Property URL As String
End Class

Public Class Person
    Public Property FirstName As String
    Public Property LastName As String
    Public Property URL As String
End Class

Następnie odczytuje plik i wypełnia listę obiektów Person.

List<Person> people = new List<Person>();
List<string> lines = File.ReadAllLines(filePath).ToList();

foreach (string line in lines)
{
    string[] entries = line.Split(',');
    Person newPerson = new Person
    {
        FirstName = entries[0],
        LastName = entries[1],
        URL = entries[2]
    };
    people.Add(newPerson);
}

List<Person> people = new List<Person>();
List<string> lines = File.ReadAllLines(filePath).ToList();

foreach (string line in lines)
{
    string[] entries = line.Split(',');
    Person newPerson = new Person
    {
        FirstName = entries[0],
        LastName = entries[1],
        URL = entries[2]
    };
    people.Add(newPerson);
}

Dim people As New List(Of Person)()
Dim lines As List(Of String) = File.ReadAllLines(filePath).ToList()

For Each line As String In lines
    Dim entries As String() = line.Split(","c)
    Dim newPerson As New Person With {
        .FirstName = entries(0),
        .LastName = entries(1),
        .URL = entries(2)
    }
    people.Add(newPerson)
Next

Dim people As New List(Of Person)()
Dim lines As List(Of String) = File.ReadAllLines(filePath).ToList()

For Each line As String In lines
    Dim entries As String() = line.Split(","c)
    Dim newPerson As New Person With {
        .FirstName = entries(0),
        .LastName = entries(1),
        .URL = entries(2)
    }
    people.Add(newPerson)
Next

Ten kod odczytuje każdą linię, dzieli ją przecinkami i tworzy obiekt Person z wyodrębnionymi danymi.

Interpolacja ciagow

Tim wprowadza interpolacje ciagow, funkcje w C# 6.0, która upraszcza proces łączenia zmiennych i ciagow. Ta metoda używa symbolu $ przed łańcuchem oraz nawiasów klamrowych {} do osadzania zmiennych bezpośrednio w łańcuchu.

foreach (var person in people)
{
    Console.WriteLine($"{person.FirstName} {person.LastName}: {person.URL}");
}

foreach (var person in people)
{
    Console.WriteLine($"{person.FirstName} {person.LastName}: {person.URL}");
}

For Each person In people
    Console.WriteLine($"{person.FirstName} {person.LastName}: {person.URL}")
Next

For Each person In people
    Console.WriteLine($"{person.FirstName} {person.LastName}: {person.URL}")
Next

Ta składnia jest bardziej zwięzła i efektywna w porównaniu do tradycyjnej konkatenacji za pomocą operatora +.

Walidacja danych

Tim podkreśla znaczenie walidacji danych podczas odczytu z pliku tekstowego. Zwraca uwage na ryzyko zakladania struktury danych i zaleca sprawdzanie dlugosci podzielonych wpisow.

foreach (string line in lines)
{
    string[] entries = line.Split(',');
    if (entries.Length == 3)
    {
        Person newPerson = new Person
        {
            FirstName = entries[0],
            LastName = entries[1],
            URL = entries[2]
        };
        people.Add(newPerson);
    }
    else
    {
        // Handle error
        Console.WriteLine("Invalid data format.");
    }
}

foreach (string line in lines)
{
    string[] entries = line.Split(',');
    if (entries.Length == 3)
    {
        Person newPerson = new Person
        {
            FirstName = entries[0],
            LastName = entries[1],
            URL = entries[2]
        };
        people.Add(newPerson);
    }
    else
    {
        // Handle error
        Console.WriteLine("Invalid data format.");
    }
}

For Each line As String In lines
    Dim entries As String() = line.Split(","c)
    If entries.Length = 3 Then
        Dim newPerson As New Person With {
            .FirstName = entries(0),
            .LastName = entries(1),
            .URL = entries(2)
        }
        people.Add(newPerson)
    Else
        ' Handle error
        Console.WriteLine("Invalid data format.")
    End If
Next

For Each line As String In lines
    Dim entries As String() = line.Split(","c)
    If entries.Length = 3 Then
        Dim newPerson As New Person With {
            .FirstName = entries(0),
            .LastName = entries(1),
            .URL = entries(2)
        }
        people.Add(newPerson)
    Else
        ' Handle error
        Console.WriteLine("Invalid data format.")
    End If
Next

To zapewnia, ze tylko linie z poprawna liczba wpisow sa przetwarzane, unikajac potencjalnych błędow w czasie wykonywania.

Dodawanie obiektow do listy

Tim pokazuje, jak dodać nowe obiekty do listy. Używa anonimowej instancji klasy Person, aby dodać nową osobę do listy.

people.Add(new Person { FirstName = "Greg", LastName = "Jones", URL = "WOWT.com" });

people.Add(new Person { FirstName = "Greg", LastName = "Jones", URL = "WOWT.com" });

people.Add(New Person With {.FirstName = "Greg", .LastName = "Jones", .URL = "WOWT.com"})

people.Add(New Person With {.FirstName = "Greg", .LastName = "Jones", .URL = "WOWT.com"})

To tworzy i inicjalizuje nowy obiekt Person w jednej linii, który jest następnie dodawany do listy people.

Zapisywanie danych z powrotem do pliku tekstowego

Tim wyjaśnia, jak zapisać listę obiektów Person z powrotem do pliku tekstowego. Konwertuje listę obiektów Person na listę łańcuchów, gdzie każdy łańcuch reprezentuje linię w pliku.

List<string> output = new List<string>();
foreach (var person in people)
{
    output.Add($"{person.FirstName},{person.LastName},{person.URL}");
}
File.WriteAllLines(filePath, output);

List<string> output = new List<string>();
foreach (var person in people)
{
    output.Add($"{person.FirstName},{person.LastName},{person.URL}");
}
File.WriteAllLines(filePath, output);

Dim output As New List(Of String)()
For Each person In people
    output.Add($"{person.FirstName},{person.LastName},{person.URL}")
Next
File.WriteAllLines(filePath, output)

Dim output As New List(Of String)()
For Each person In people
    output.Add($"{person.FirstName},{person.LastName},{person.URL}")
Next
File.WriteAllLines(filePath, output)

Ten kod iteruje po liście people, tworzy łańcuch CSV dla każdego obiektu Person i zapisuje listę łańcuchów do pliku.

Wnioski

Szczegolowy przewodnik Tima Coreya na temat operacji I/O plików w C# dostarcza praktycznych wskazowek dotyczących odczytu i zapisu plików tekstowych. Podazajac za jego przykładami, deweloperzy mogą skutecznie zarządzać danymi za pomoca plików tekstowych i wdrazac solidne rozwiązania do przechowywania danych. Dla glebszego zrozumienia i praktycznego doswiadczenia, goraco zachecam do obejrzenia filmu Tima Coreya, w ktorym glebiej omawia te pojecia z przykładami ze świata rzeczywistego.