Usprawnij przetwarzanie danych za pomocą C# parsera CSV (Przewodnik)

Dłączego podstawowe dzielenie ciągów znaków nie działa?

Rozważmy najczęstsze podejście początkujących do analizowania pliku CSV:

string line = "John,Doe,30,Engineer";
string[] values = line.Split(','); // string array

string line = "John,Doe,30,Engineer";
string[] values = line.Split(','); // string array

Dim line As String = "John,Doe,30,Engineer"
Dim values As String() = line.Split(","c) ' string array

Działa to idealnie w prostych przypadkach, ale natychmiast zawodzi w obliczu danych z prawdziwego świata. Pola w cudzysłowie z wbudowanymi przecinkami stanowią poważny problem: wiersz CSV, taki jak "Smith, John",Developer,"New York, NY",50000, zostaje podzielony na pięć pól zamiast czterech, co powoduje uszkodzenie struktury danych i nieprawidłowości w dalszym przetwarzaniu.

Problemy powodują również znaki końca linii w polach. Zgodnie z RFC 4180 pola mogą zawierać znaki końca linii, jeśli są odpowiednio ujęte w cudzysłowy. Wielowierszowe pole adresu uniemożliwia czytanie wiersz po wierszu, co wymaga zaawansowanego zarządzania stanem w celu śledzenia, czy znak końca wiersza występuje w cytowanym polu, czy też oznacza nowy rekord.

Dodatkowe komplikacje wynikają z obsługi znaków escape i cudzysłowów. Pliki CSV stosują różne konwencje dotyczące escapowania cudzysłowów w polach z cudzysłowami. Niektórzy używają podwójnych cudzysłowów (""), podczas gdy inni stosują ukośniki odwrotne lub inne znaki escape. Bez odpowiedniego postępowania dane takie jak "She said, ""Hello!""",greeting ulegają uszkodzeniu lub powodują błędy parsowania.

Różne separatory i kodowania dodatkowo zwiększają złożoność zadania. Nie wszystkie pliki "CSV" używają przecinków. Powszechnie spotykane są pliki z wartościami rozdzielonymi tabulatorami (TSV), pliki rozdzielone znakami pipe oraz pliki z wartościami rozdzielonymi średnikami. Standard RFC 4180 określa specyfikacje formatu CSV, ale wiele implementacji odbiega od niego.

Jak zarządzanie pamięcią wpływa na przetwarzanie dużych plików?

Wczytanie całego pliku CSV o rozmiarze 500 MB do pamięci przy użyciu File.ReadAllLines() może spowodować znaczne pogorszenie wydajności lub wyjątki związane z brakiem pamięci. Przetwarzanie milionów wierszy wymaga zastosowania metod strumieniowych i wydajnego zarządzania pamięcią w celu zachowania responsywności aplikacji.

Złożoność ta potęguje się w przypadku plików CSV pochodzących z różnych źródeł, z których każde może stosować inne konwencje. Stworzenie parsera, który niezawodnie obsługuje wszystkie scenariusze, wymaga znacznego nakładu pracy programistycznej oraz ciągłej konserwacji w miarę pojawiania się nowych, skrajnych przypadków.

Jakie są etapy instalacji?

Zainstaluj IronXL za pomocą konsoli menedżera pakietów NuGet lub interfejsu CLI .NET:

# NuGet Package Manager Console
Install-Package IronXl.Excel

# .NET CLI
dotnet add package IronXl.Excel

# NuGet Package Manager Console
Install-Package IronXl.Excel

# .NET CLI
dotnet add package IronXl.Excel

Jeśli chodzi o licencjonowanie, przed zakupem można uzyskać Licencję Trial, aby w pełni przetestować IronXL.

Jak załadować swój pierwszy plik CSV?

Po zainstalowaniu dodaj przestrzeń nazw IronXL do plików C# i załaduj plik CSV za pomocą zaledwie kilku wierszy:

using IronXL;

// Load a CSV file using top-level statements
WorkBook workbook = WorkBook.LoadCSV("customers.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read a specific cell value
string customerName = sheet["B2"].StringValue;
Console.WriteLine($"Customer: {customerName}");

using IronXL;

// Load a CSV file using top-level statements
WorkBook workbook = WorkBook.LoadCSV("customers.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read a specific cell value
string customerName = sheet["B2"].StringValue;
Console.WriteLine($"Customer: {customerName}");

Imports IronXL

' Load a CSV file using top-level statements
Dim workbook As WorkBook = WorkBook.LoadCSV("customers.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Read a specific cell value
Dim customerName As String = sheet("B2").StringValue
Console.WriteLine($"Customer: {customerName}")

Metoda WorkBook.LoadCSV() inteligentnie analizuje plik CSV, automatycznie wykrywając separatory i obsługując pola w cudzysłowie. Ponieważ pliki CSV zawierają pojedyncze arkusze, dostęp do danych odbywa się poprzez DefaultWorkSheet. Akcesor typu StringValue zapewnia pobieranie wartości w sposób bezpieczny pod względem typów.

Dane wejściowe

Wynik

Jak iterować po wierszach pliku CSV?

Najbardziej bezpośrednim podejściem jest użycie LoadCSV z ustawieniami domyślnymi i iteracja przez wszystkie wiersze:

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("sales_data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Iterate through all data rows (skipping header at row 0)
for (var row = 1; row <= sheet.RowCount; row++)
{
    string productName = sheet[$"A{row}"].StringValue;
    decimal price = sheet[$"B{row}"].DecimalValue;
    int quantity = sheet[$"C{row}"].IntValue;
    Console.WriteLine($"Product: {productName}, Price: ${price}, Qty: {quantity}");
}

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("sales_data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Iterate through all data rows (skipping header at row 0)
for (var row = 1; row <= sheet.RowCount; row++)
{
    string productName = sheet[$"A{row}"].StringValue;
    decimal price = sheet[$"B{row}"].DecimalValue;
    int quantity = sheet[$"C{row}"].IntValue;
    Console.WriteLine($"Product: {productName}, Price: ${price}, Qty: {quantity}");
}

Imports IronXL

Dim workbook As WorkBook = WorkBook.LoadCSV("sales_data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Iterate through all data rows (skipping header at row 0)
For row As Integer = 1 To sheet.RowCount
    Dim productName As String = sheet($"A{row}").StringValue
    Dim price As Decimal = sheet($"B{row}").DecimalValue
    Dim quantity As Integer = sheet($"C{row}").IntValue
    Console.WriteLine($"Product: {productName}, Price: ${price}, Qty: {quantity}")
Next row

Typowane akcesory IronXL automatycznie konwertują tekst na odpowiednie typy .NET, eliminując ręczne parsowanie. Pętla przechodzi przez wszystkie wiersze, używając RowCount, co dokładnie odzwierciedla całkowitą liczbę wierszy danych w pliku.

Jak radzisz sobie z niestandardowymi separatorami?

W przypadku plików CSV z niestandardowymi separatorami IronXL udostępnia opcje konfiguracyjne za pomocą parametru listDelimiter:

using IronXL;

// Load a tab-separated file
WorkBook workbook = WorkBook.LoadCSV("inventory.tsv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: "\t");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Build header list from column 0
var headers = new List<string>();
for (int col = 0; col < sheet.ColumnCount; col++)
{
    headers.Add(sheet.GetCellAt(0, col).StringValue);
}
Console.WriteLine("Columns: " + string.Join(" | ", headers));

using IronXL;

// Load a tab-separated file
WorkBook workbook = WorkBook.LoadCSV("inventory.tsv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: "\t");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Build header list from column 0
var headers = new List<string>();
for (int col = 0; col < sheet.ColumnCount; col++)
{
    headers.Add(sheet.GetCellAt(0, col).StringValue);
}
Console.WriteLine("Columns: " + string.Join(" | ", headers));

Imports IronXL

' Load a tab-separated file
Dim workbook As WorkBook = WorkBook.LoadCSV("inventory.tsv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=vbTab)
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Build header list from column 0
Dim headers As New List(Of String)()
For col As Integer = 0 To sheet.ColumnCount - 1
    headers.Add(sheet.GetCellAt(0, col).StringValue)
Next
Console.WriteLine("Columns: " & String.Join(" | ", headers))

Parametr listDelimiter określa separatory pól — w tym przypadku są to tabulatory dla plików TSV. Parametr fileFormat określa wewnętrzną reprezentację po parsowaniu. Więcej informacji na temat odczytu plików Excel można znaleźć w sekcji dotyczącej dodatkowych opcji formatów plików.

Jak IronXL radzi sobie z polami w cudzysłowie i znakami specjalnymi?

IronXL automatycznie obsługuje pliki CSV z polami w cudzysłowie zawierającymi separatory. Parser działa zgodnie ze standardami CSV, traktując podwójne cudzysłowy jako sekwencje escape:

using IronXL;

// Create sample CSV with complex quoted fields
string csvContent = @"Name,Opis,Price,Category
""Johnson, Mike"",""Premium keyboard with mechanical switches"",149.99,Electronics
""O'Brien, Sarah"",""Children's toy - ages 3+"",29.99,Toys";

File.WriteAllText("complex_data.csv", csvContent);

WorkBook workbook = WorkBook.LoadCSV("complex_data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

for (int row = 1; row <= sheet.RowCount; row++)
{
    string name = sheet[$"A{row}"].StringValue;
    string description = sheet[$"B{row}"].StringValue;
    Console.WriteLine($"Name: {name}");
    Console.WriteLine($"Opis: {description}");
}

using IronXL;

// Create sample CSV with complex quoted fields
string csvContent = @"Name,Opis,Price,Category
""Johnson, Mike"",""Premium keyboard with mechanical switches"",149.99,Electronics
""O'Brien, Sarah"",""Children's toy - ages 3+"",29.99,Toys";

File.WriteAllText("complex_data.csv", csvContent);

WorkBook workbook = WorkBook.LoadCSV("complex_data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

for (int row = 1; row <= sheet.RowCount; row++)
{
    string name = sheet[$"A{row}"].StringValue;
    string description = sheet[$"B{row}"].StringValue;
    Console.WriteLine($"Name: {name}");
    Console.WriteLine($"Opis: {description}");
}

Imports IronXL

' Create sample CSV with complex quoted fields
Dim csvContent As String = "Name,Opis,Price,Category" & vbCrLf & _
    """Johnson, Mike"",""Premium keyboard with mechanical switches"",149.99,Electronics" & vbCrLf & _
    """O'Brien, Sarah"",""Children's toy - ages 3+"",29.99,Toys"

File.WriteAllText("complex_data.csv", csvContent)

Dim workbook As WorkBook = WorkBook.LoadCSV("complex_data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

For row As Integer = 1 To sheet.RowCount
    Dim name As String = sheet($"A{row}").StringValue
    Dim description As String = sheet($"B{row}").StringValue
    Console.WriteLine($"Name: {name}")
    Console.WriteLine($"Opis: {description}")
Next row

IronXL poprawnie interpretuje "Johnson, Mike" jako pojedyncze pole, mimo że zawiera ono przecinek, oraz prawidłowo przetwarza zagnieżdżone cudzysłowy w opisach. Ta automatyczna obsługa eliminuje złożone wyrażenia regularne lub maszyny stanów, których wymagają niestandardowe parsery.

A co z problemami związanymi z kodowaniem znaków?

Praca z różnymi kodowaniami znaków wymaga szczególnej uwagi. IronXL automatycznie obsługuje różne kodowania, zapewniając prawidłowe wyświetlanie znaków międzynarodowych:

using IronXL;

WorkBook workbook = WorkBook.Load("international_data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

for (int row = 1; row <= sheet.RowCount; row++)
{
    string city = sheet[$"A{row}"].StringValue;
    string country = sheet[$"B{row}"].StringValue;
    // Characters like n~, u-umlaut, e-acute display correctly
    Console.WriteLine($"Location: {city}, {country}");
}

// Save with UTF-8 encoding to preserve characters
workbook.SaveAsCsv("output_utf8.csv");

using IronXL;

WorkBook workbook = WorkBook.Load("international_data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

for (int row = 1; row <= sheet.RowCount; row++)
{
    string city = sheet[$"A{row}"].StringValue;
    string country = sheet[$"B{row}"].StringValue;
    // Characters like n~, u-umlaut, e-acute display correctly
    Console.WriteLine($"Location: {city}, {country}");
}

// Save with UTF-8 encoding to preserve characters
workbook.SaveAsCsv("output_utf8.csv");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("international_data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

For row As Integer = 1 To sheet.RowCount
    Dim city As String = sheet($"A{row}").StringValue
    Dim country As String = sheet($"B{row}").StringValue
    ' Characters like n~, u-umlaut, e-acute display correctly
    Console.WriteLine($"Location: {city}, {country}")
Next

' Save with UTF-8 encoding to preserve characters
workbook.SaveAsCsv("output_utf8.csv")

Niezależnie od tego, czy pracujesz z kodowaniem UTF-8, UTF-16 czy starszym kodowaniem ANSI, IronXL zachowuje integralność znaków podczas cykli odczytu i zapisu. Podczas zapisywania plików CSV domyślnie używany jest kodowanie UTF-8 w celu zapewnienia maksymalnej kompatybilności. Zapoznaj się z przewodnikiem eksportu, aby poznać wszystkie opcje formatów wyjściowych.

Dane wejściowe

Wynik

Jak pracować z niestandardowymi separatorami i formatami regionalnymi?

Niestandardowe separatory i formaty regionalne wymagają elastycznej konfiguracji. W europejskich plikach CSV często stosuje się średniki jako separatory, a przecinki jako separatory dziesiętne:

using IronXL;

// European CSV format (semicolon delimiter, comma decimal)
string europeanCsv = @"Product;Price;Quantity
Widget A;12,50;100
Gadget B;24,99;50";

File.WriteAllText("european.csv", europeanCsv);

WorkBook workbook = WorkBook.LoadCSV("european.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ";");
WorkSheet sheet = workbook.DefaultWorkSheet;

for (int row = 1; row <= sheet.RowCount; row++)
{
    string product = sheet[$"A{row}"].StringValue;
    string priceText = sheet[$"B{row}"].StringValue;
    decimal price = decimal.Parse(priceText.Replace(',', '.'));
    Console.WriteLine($"{product}: euro{price}");
}

using IronXL;

// European CSV format (semicolon delimiter, comma decimal)
string europeanCsv = @"Product;Price;Quantity
Widget A;12,50;100
Gadget B;24,99;50";

File.WriteAllText("european.csv", europeanCsv);

WorkBook workbook = WorkBook.LoadCSV("european.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ";");
WorkSheet sheet = workbook.DefaultWorkSheet;

for (int row = 1; row <= sheet.RowCount; row++)
{
    string product = sheet[$"A{row}"].StringValue;
    string priceText = sheet[$"B{row}"].StringValue;
    decimal price = decimal.Parse(priceText.Replace(',', '.'));
    Console.WriteLine($"{product}: euro{price}");
}

Imports IronXL

' European CSV format (semicolon delimiter, comma decimal)
Dim europeanCsv As String = "Product;Price;Quantity" & vbCrLf & "Widget A;12,50;100" & vbCrLf & "Gadget B;24,99;50"

File.WriteAllText("european.csv", europeanCsv)

Dim workbook As WorkBook = WorkBook.LoadCSV("european.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=";")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

For row As Integer = 1 To sheet.RowCount
    Dim product As String = sheet($"A{row}").StringValue
    Dim priceText As String = sheet($"B{row}").StringValue
    Dim price As Decimal = Decimal.Parse(priceText.Replace(","c, "."c))
    Console.WriteLine($"{product}: euro{price}")
Next row

Parametr listDelimiter konfiguruje podział pól, a parsowanie liczb konwertuje europejski zapis dziesiętny na format oczekiwany przez platformę .NET. Ta elastyczność pozwala na przetwarzanie plików CSV z dowolnego regionu bez modyfikowania danych źródłowych. Przewodnik po importowaniu danych obejmuje dodatkowe scenariusze importu danych.

Jak wykorzystać przetwarzanie wsadowe w przypadku dużych zbiorów danych?

Przetwarzanie wsadowe dzieli duże zbiory danych na łatwe do zarządzania fragmenty, zapobiegając przeciążeniu pamięci i umożliwiając śledzenie postępów:

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("large_dataset.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

int batchSize = 1000;
int totalRows = sheet.RowCount;

for (int startRow = 1; startRow <= totalRows; startRow += batchSize)
{
    int endRow = Math.Min(startRow + batchSize - 1, totalRows);
    var batchResults = new List<(string Id, decimal Amount)>();

    for (int row = startRow; row <= endRow; row++)
    {
        string id = sheet[$"A{row}"].StringValue;
        decimal amount = sheet[$"B{row}"].DecimalValue;
        batchResults.Add((id, amount));
    }

    // Save batch results to database or file
    Console.WriteLine($"Processed rows {startRow} to {endRow}: {batchResults.Count} records");
}

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("large_dataset.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

int batchSize = 1000;
int totalRows = sheet.RowCount;

for (int startRow = 1; startRow <= totalRows; startRow += batchSize)
{
    int endRow = Math.Min(startRow + batchSize - 1, totalRows);
    var batchResults = new List<(string Id, decimal Amount)>();

    for (int row = startRow; row <= endRow; row++)
    {
        string id = sheet[$"A{row}"].StringValue;
        decimal amount = sheet[$"B{row}"].DecimalValue;
        batchResults.Add((id, amount));
    }

    // Save batch results to database or file
    Console.WriteLine($"Processed rows {startRow} to {endRow}: {batchResults.Count} records");
}

Imports IronXL

Dim workbook As WorkBook = WorkBook.LoadCSV("large_dataset.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

Dim batchSize As Integer = 1000
Dim totalRows As Integer = sheet.RowCount

For startRow As Integer = 1 To totalRows Step batchSize
    Dim endRow As Integer = Math.Min(startRow + batchSize - 1, totalRows)
    Dim batchResults As New List(Of (Id As String, Amount As Decimal))()

    For row As Integer = startRow To endRow
        Dim id As String = sheet($"A{row}").StringValue
        Dim amount As Decimal = sheet($"B{row}").DecimalValue
        batchResults.Add((id, amount))
    Next

    ' Save batch results to database or file
    Console.WriteLine($"Processed rows {startRow} to {endRow}: {batchResults.Count} records")
Next

Przetwarzanie 1000 wierszy naraz pozwala na czyszczenie pamięci między partiami, co zapewnia stałe zużycie pamięci. Ten wzorzec ułatwia również odzyskiwanie danych po błędzie — można wznowić przetwarzanie od ostatniej pomyślnie zakończonej partii, zamiast zaczynać od nowa. Przewodnik "Excel to DataSet" pokazuje, jak efektywnie pracować z dużymi zbiorami danych w pamięci.

Jak przekonwertować plik CSV na sformatowany skoroszyt programu Excel?

Konwersja pliku CSV do formatu Excel z zachowaniem formatowania poprawia prezentację danych i umożliwia korzystanie z zaawansowanych funkcji, takich jak formuły, wykresy i stylizacja:

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("sales_report.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Format header row
for (int col = 0; col < sheet.ColumnCount; col++)
{
    var headerCell = sheet.GetCellAt(0, col);
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.Color = "#FFFFFF";
}

// Format currency columns
for (int row = 1; row <= sheet.RowCount; row++)
{
    var priceCell = sheet[$"C{row}"];
    priceCell.FormatString = "$#,##0.00";
}

// Auto-fit columns for better display
for (int col = 0; col < sheet.ColumnCount; col++)
{
    sheet.AutoSizeColumn(col);
}

workbook.SaveAs("formatted_report.xlsx");
Console.WriteLine("CSV converted to formatted Excel file");

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("sales_report.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Format header row
for (int col = 0; col < sheet.ColumnCount; col++)
{
    var headerCell = sheet.GetCellAt(0, col);
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.Color = "#FFFFFF";
}

// Format currency columns
for (int row = 1; row <= sheet.RowCount; row++)
{
    var priceCell = sheet[$"C{row}"];
    priceCell.FormatString = "$#,##0.00";
}

// Auto-fit columns for better display
for (int col = 0; col < sheet.ColumnCount; col++)
{
    sheet.AutoSizeColumn(col);
}

workbook.SaveAs("formatted_report.xlsx");
Console.WriteLine("CSV converted to formatted Excel file");

Imports IronXL

Dim workbook As WorkBook = WorkBook.LoadCSV("sales_report.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Format header row
For col As Integer = 0 To sheet.ColumnCount - 1
    Dim headerCell = sheet.GetCellAt(0, col)
    headerCell.Style.Font.Bold = True
    headerCell.Style.BackgroundColor = "#4472C4"
    headerCell.Style.Font.Color = "#FFFFFF"
Next

' Format currency columns
For row As Integer = 1 To sheet.RowCount
    Dim priceCell = sheet($"C{row}")
    priceCell.FormatString = "$#,##0.00"
Next

' Auto-fit columns for better display
For col As Integer = 0 To sheet.ColumnCount - 1
    sheet.AutoSizeColumn(col)
Next

workbook.SaveAs("formatted_report.xlsx")
Console.WriteLine("CSV converted to formatted Excel file")

W kodzie zastosowano pogrubienie i kolory w nagłówkach, tworząc wizualną hierarchię. Formatowanie walut z separatorami tysięcy poprawia czytelność liczb. AutoSizeColumn dostosowuje szerokość kolumn do zawartości. Przewodnik po formatowaniu komórek oraz samouczek dotyczący pisania plików Excel zawierają dodatkowe techniki formatowania.

Dane wejściowe

Wynik

Jak tworzyć nowe pliki Excel na podstawie danych CSV?

Oprócz prostego konwertowania, IronXL umożliwia tworzenie plików Excel z wieloma arkuszami, formułami i danymi strukturalnymi ze źródeł CSV. Przewodnik po scałaniu komórek pokazuje, jak tworzyć profesjonalnie wyglądające raporty ze scalonymi nagłówkami.

W przypadku wdrożeń kontenerowych funkcje konwersji IronXL działają w środowiskach Docker bez zewnętrznych zależności lub instalacji pakietu Office. Dzięki temu idealnie nadaje się do architektur natywnych dla chmury, gdzie niezbędne jest lekkie, samodzielne przetwarzanie.