How to Read a File Line by Line in C#?

Using SqlDataReader asynchronously prevents blocking the main thread, improving performance in web apps and large queries. Here’s how to do it properly.

Use await with ExecuteReaderAsync()

using (SqlConnection conn = new SqlConnection(connectionString))
{
    await conn.OpenAsync();
    using (SqlCommand cmd = new SqlCommand("SELECT * FROM Users", conn))
    using (SqlDataReader reader = await cmd.ExecuteReaderAsync()) 
    {
        while (await reader.ReadAsync()) 
        {
            Console.WriteLine(reader["Username"]);
        }
    } // ✅ Auto-closes reader
} // ✅ Auto-closes connection

Why use async?

A couple of reasons:

• Frees up the thread while waiting for the database.
• Improves scalability in ASP.NET Core and web apps.

⚡ Alternative: ConfigureAwait(false) for ASP.NET

Use ConfigureAwait(false) in library code to avoid deadlocks in UI frameworks like ASP.NET.

using (SqlConnection conn = new SqlConnection(connectionString))
{
    await conn.OpenAsync().ConfigureAwait(false);
    using (SqlCommand cmd = new SqlCommand("SELECT * FROM Users", conn))
    using (SqlDataReader reader = await cmd.ExecuteReaderAsync().ConfigureAwait(false)) 
    {
        while (await reader.ReadAsync().ConfigureAwait(false)) 
        {
            Console.WriteLine(reader["Username"]);
        }
    }
}

When working with URLs in C#, encoding is essential to ensure that special characters (like spaces, ?, &, and =) don’t break the URL structure. The recommended way to encode a string for a URL is by using Uri.EscapeDataString(), which converts unsafe characters into their percent-encoded equivalents.

string rawText = "hello world!";
string encodedText = Uri.EscapeDataString(rawText);

Console.WriteLine(encodedText); // Output: hello%20world%21

This method encodes spaces as %20, making it ideal for query parameters.

For ASP.NET applications, you can also use HttpUtility.UrlEncode() (from System.Web), which encodes spaces as +:

using System.Web;

string encodedText = HttpUtility.UrlEncode("hello world!");
Console.WriteLine(encodedText); // Output: hello+world%21

For .NET Core and later, Uri.EscapeDataString() is the preferred choice.

XML (Extensible Markup Language) is a widely used format for storing and transporting data.

In C#, you can create XML files efficiently using the XmlWriter and XDocument classes. This guide covers both methods with practical examples.

Writing XML Using XmlWriter

XmlWriter provides a fast and memory-efficient way to generate XML files by writing elements sequentially.

Example:

using System;
using System.Xml;

class Program
{
    static void Main()
    {
        using (XmlWriter writer = XmlWriter.Create("person.xml"))
        {
            writer.WriteStartDocument();
            writer.WriteStartElement("Person");

            writer.WriteElementString("FirstName", "John");
            writer.WriteElementString("LastName", "Doe");
            writer.WriteElementString("Age", "30");

            writer.WriteEndElement();
            writer.WriteEndDocument();
        }
        Console.WriteLine("XML file created successfully.");
    }
}

Output (person.xml):

<?xml version="1.0" encoding="utf-8"?>
<Person>
    <FirstName>John</FirstName>
    <LastName>Doe</LastName>
    <Age>30</Age>
</Person>

Writing XML Using XDocument

The XDocument class from LINQ to XML provides a more readable and flexible way to create XML files.

Example:

using System;
using System.Xml.Linq;

class Program
{
    static void Main()
    {
        XDocument doc = new XDocument(
            new XElement("Person",
                new XElement("FirstName", "John"),
                new XElement("LastName", "Doe"),
                new XElement("Age", "30")
            )
        );
        doc.Save("person.xml");
        Console.WriteLine("XML file created successfully.");
    }
}

This approach is ideal for working with complex XML structures and integrating LINQ queries.

When to Use Each Method

• Use XmlWriter when performance is critical and you need to write XML sequentially.
• Use XDocument when you need a more readable, maintainable, and flexible way to manipulate XML.

Conclusion

Writing XML files in C# is straightforward with XmlWriter and XDocument. Choose the method that best suits your needs for performance, readability, and maintainability.