Forem: Farman Guliyev

FG.CsvParser: A Powerful .NET Library for Working with CSV Files

Farman Guliyev — Sat, 18 Jan 2025 20:54:50 +0000

FG.CsvParser: A Powerful .NET Library for Working with CSV Files

Working with CSV files is a common task for developers. FG.CsvParser is a .NET Standard 2.1 library designed to make reading, writing, and querying CSV files simple and efficient. With its flexible API and extensive configuration options, FG.CsvParser is the perfect tool for handling your CSV-related tasks.

Key Features of FG.CsvParser

Read CSV Files: Convert CSV content into JSON or a list of strongly-typed objects.
Write CSV Files: Easily write CSV content to files or append to existing ones.
Highly Configurable: Adjust parsing options such as delimiters, row splitters, and encoding to suit your needs.
Query CSV Data: Use custom filters to query CSV content efficiently.

Installation

To start using FG.CsvParser, you can add it to your project via NuGet:

dotnet add package FG.CsvParser

Getting Started with FG.CsvParser

Creating a CsvParser Instance

FG.CsvParser allows you to create a parser instance in multiple ways. Here are some examples:

Open a CSV File with Default Settings

var parser = CsvParser.OpenFile("path/to/your/file.csv");

Open a CSV File with a Header Row

var parser = CsvParser.OpenFile("path/to/your/file.csv", hasHeader: true);

Open a CSV File with Custom Configuration

var configuration = new CsvParserConfiguration
{
    HasHeader = true,
    Delimitter = ',',
    RowSplitter = "\n",
    Encoding = Encoding.UTF8
};
var parser = CsvParser.OpenFile("path/to/your/file.csv", configuration);

Reading CSV Content

Convert CSV Content to JSON

using var parser = CsvParser.OpenFile("path/to/your/csvfile.csv", new CsvParserConfiguration
{
    HasHeader = true,
    Delimitter = ',',
    RowSplitter = "\r\n",
    Encoding = Encoding.UTF8
});

string? jsonContent = await parser.ReadAsJson();
Console.WriteLine(jsonContent);

Convert CSV Content to a List of Objects

using var parser = CsvParser.OpenFile("path/to/your/csvfile.csv", new CsvParserConfiguration
{
    HasHeader = true,
    Delimitter = ',',
    RowSplitter = "\r\n",
    Encoding = Encoding.UTF8
});

List<MyDataClass> dataList = await parser.ReadAs<MyDataClass>();
foreach (var data in dataList)
{
    Console.WriteLine(data);
}

public class MyDataClass
{
    public string Name { get; set; }

    [CsvColumn("Home address")]
    public string HomeAddress { get; set; }
}

Writing CSV Content

Write CSV Content as a String

using var parser = CsvParser.OpenFile("path/to/your/file.csv", new CsvParserConfiguration
{
    HasHeader = true,
    Delimitter = ',',
    RowSplitter = "\r\n",
    Encoding = Encoding.UTF8
});

string csvContent = "Column1,Column2\nValue1,Value2\nValue3,Value4";
await parser.WriteAsync(csvContent, append: false);
Console.WriteLine("CSV content written to file.");

Write a List of Objects to CSV

var dataList = new List<MyDataClass>
{
    new MyDataClass { Column1 = "Value1", Column2 = 1 },
    new MyDataClass { Column1 = "Value2", Column2 = 2 }
};

await parser.WriteAsync(dataList, append: false);
Console.WriteLine("List of objects written to CSV file.");

Querying CSV Content

You can query CSV data using custom filters to extract only the information you need.

using var parser = CsvParser.OpenFile("path/to/your/csvfile.csv", new CsvParserConfiguration
{
    HasHeader = true,
    Delimitter = ',',
    RowSplitter = "\r\n",
    Encoding = Encoding.UTF8
});

await foreach (var item in parser.Query<MyDataClass>(data => data.Column2 > 100))
{
    Console.WriteLine(item);
}

Configuration Options

The CsvParserConfiguration class provides extensive configuration options to customize your CSV parsing experience:

var configuration = new CsvParserConfiguration
{
    HasHeader = true,
    Delimitter = ';',
    RowSplitter = "\n",
    Encoding = Encoding.UTF8
};

using var parser = CsvParser.OpenFile("path/to/your/file.csv", configuration);

Why Choose FG.CsvParser?

FG.CsvParser simplifies working with CSV files by providing a clean and intuitive API. Whether you need to process CSV files for small tasks or large-scale applications, FG.CsvParser offers the tools and flexibility required to handle your data efficiently.

Install FG.CsvParser today and take control of your CSV workflows!

Visit FG.CsvParser on GitHub for More Information

Streamline Your Background Tasks with the Task Repetitor Library

Farman Guliyev — Fri, 17 Jan 2025 18:46:58 +0000

Streamline Your Background Tasks with the Task Repetitor Library

Efficiently managing repetitive and scheduled background tasks is a common challenge in modern software development. The FG.TaskRepetitor Library offers a robust and flexible solution for developers working with .NET applications. In this article, we’ll explore what this library offers, how it works, and why it can make a significant difference in your projects.

What Is the Task Repetitor Library?

The FG Task Repetitor Library is a .NET library designed to handle repetitive or one-time background tasks with ease. Whether you need to run hourly cleanup jobs, weekly reports, or asynchronous processes that retry on failure, this library simplifies scheduling and execution.

The library provides both synchronous and asynchronous task handling, ensuring compatibility with a wide range of use cases. Additionally, its built-in error-handling and retry mechanisms ensure that tasks are executed reliably, even in the face of occasional errors.

Key Features

Customizable Scheduling:
- Schedule tasks to run every second, minute, hour, day, or week.
- Support for custom schedules, specific times of day, and cron expressions.
Robust Error Handling:
- Define custom retry intervals for failed tasks.
- Implement error-handling logic to handle exceptions gracefully.
Asynchronous and Synchronous Support:
- Handle both blocking and non-blocking tasks.
- Use built-in hosted services for task management.
Ease of Integration:
- Simple registration of tasks via dependency injection.
- Hosted services for automatic task scheduling and execution.

How It Works

The Task Repetitor Library uses a combination of dependency injection, background hosted services, and scheduling logic to manage tasks. Here’s a quick overview of the key components:

RepetitiveTask and AsyncRepetitiveTask:
- Abstract base classes that define the structure for synchronous and asynchronous tasks.
- Includes scheduling properties and retry intervals.
Schedule Class:
- Provides predefined scheduling options (e.g., every minute, hour, or day).
- Supports advanced scheduling such as cron expressions or specific times of the month.

Getting Started

Here’s how you can start using the Task Repetitor Library in your .NET project:

Install the Library:

   dotnet add package FG.TaskRepetitor

Define Your Task: Create a class that inherits from RepetitiveTask or AsyncRepetitiveTask.

   public class MyTask : RepetitiveTask
   {
       public override required Schedule Schedule { get; init; } = Schedule.EveryHour();

       public override void Execute()
       {
           Console.WriteLine($"Task executed at: {DateTime.Now}");
       }
   }

Register Services: Add the library to your IServiceCollection in Program.cs.

   builder.Services.AddTaskRepetitor();

Run Your Application: The library will automatically discover and execute the tasks based on their schedules.

Advanced Usage

Custom Error Handling:
You can override the OnError or OnErrorAsync methods to implement custom logic when an error occurs.

public override void OnError(Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

Dynamic Scheduling:
Use the Schedule.Cron or Schedule.Custom methods for more granular control.

public override required Schedule Schedule { get; init; } = Schedule.Cron("0 0 * * 1"); // Every Monday at midnight

Why Use Task Repetitor?

Reliability: The library ensures tasks are executed on schedule with retry capabilities in case of failure.
Scalability: Easily manage multiple tasks without bloating your application logic.
Simplicity: With intuitive APIs, you can focus on your business logic rather than task management.
Flexibility: Custom schedules and error-handling give you full control over your tasks.

Conclusion

The FG Task Repetitor Library is a powerful tool for .NET developers looking to streamline their background task execution. With robust features, ease of integration, and support for both synchronous and asynchronous workflows, it’s a must-have for any project requiring scheduled tasks.

Start using the library today and simplify your task management workflow! The source code and documentation are available on GitHub for further exploration.

Have questions or feedback? Feel free to reach out or contribute to the project on GitHub. Together, we can make background task management easier for everyone!