Menu

How to Send an HTTP GET Request in C# Using HttpClient

Making HTTP requests is a fundamental task in modern application development. In C#, the HttpClient class provides a powerful and flexible way to send HTTP requests and receive responses.

This guide will show you how to make HTTP GET requests properly in C#.

Basic HTTP GET Request

Here's a simple example of how to make an HTTP GET request:

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class Program
{
    static async Task Main()
    {
        // Create a single HttpClient instance to reuse throughout your application
        using HttpClient client = new HttpClient();
        
        try
        {
            // Send GET request
            HttpResponseMessage response = await client.GetAsync("https://api.example.com/data");
            
            // Check if the request was successful
            response.EnsureSuccessStatusCode();
            
            // Read response content
            string responseBody = await response.Content.ReadAsStringAsync();
            
            // Process the response
            Console.WriteLine(responseBody);
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"Request error: {e.Message}");
        }
    }
}

Adding Request Headers

Often, you'll need to add headers to your request, such as authentication tokens:

// Add default headers to be used with all requests
client.DefaultRequestHeaders.Add("User-Agent", "My C# Application");
client.DefaultRequestHeaders.Add("API-Key", "your-api-key");

// For specific content type
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));

// For Bearer authentication
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "your-token-here");

Handling Query Parameters

If you need to include query parameters in your URL:

// Option 1: Build the URL with query parameters manually
string baseUrl = "https://api.example.com/search";
string query = "search_term";
int page = 1;
string requestUri = $"{baseUrl}?q={Uri.EscapeDataString(query)}&page={page}";

// Option 2: Use HttpRequestMessage with UriBuilder
var uriBuilder = new UriBuilder("https://api.example.com/search");
var query = System.Web.HttpUtility.ParseQueryString(string.Empty);
query["q"] = "search_term";
query["page"] = "1";
uriBuilder.Query = query.ToString();

var request = new HttpRequestMessage(HttpMethod.Get, uriBuilder.Uri);
var response = await client.SendAsync(request);

Best Practices

  1. Reuse HttpClient: Create a single HttpClient instance and reuse it throughout your application's lifecycle to avoid socket exhaustion.

  2. Use Cancellation Tokens: For operations that might take time, implement cancellation tokens:

using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10)); // Timeout after 10 seconds
var response = await client.GetAsync("https://api.example.com/data", cts.Token);
  1. Configure Timeouts: Set appropriate timeouts for your requests:
client.Timeout = TimeSpan.FromSeconds(30);
  1. Dispose HttpClient Properly: Use using statements or implement IDisposable in containing classes.

  2. Use HttpClientFactory: In ASP.NET Core applications, use the built-in HttpClientFactory to manage HttpClient instances:

// In Startup.ConfigureServices
services.AddHttpClient("api", client =>
{
    client.BaseAddress = new Uri("https://api.example.com/");
    client.DefaultRequestHeaders.Add("User-Agent", "My C# Application");
});

// In your service/controller
public class MyService
{
    private readonly IHttpClientFactory _clientFactory;
    
    public MyService(IHttpClientFactory clientFactory)
    {
        _clientFactory = clientFactory;
    }
    
    public async Task GetDataAsync()
    {
        var client = _clientFactory.CreateClient("api");
        var response = await client.GetAsync("data");
        // Process response...
    }
}

Deserializing JSON Responses

Most modern APIs return data in JSON format. You can easily deserialize it using System.Text.Json:

using System.Text.Json;

// Send request
var response = await client.GetAsync("https://api.example.com/users/1");
response.EnsureSuccessStatusCode();

// Read and deserialize the response
var content = await response.Content.ReadAsStringAsync();
var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
var user = JsonSerializer.Deserialize<User>(content, options);

Console.WriteLine($"User name: {user.Name}");

// User class
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

Conclusion

The HttpClient class provides a modern and efficient way to make HTTP requests in C#. By following the best practices outlined above, you can ensure your application handles network communication efficiently and robustly.

Remember that proper exception handling, timeouts, and resource management are crucial for building reliable networked applications. The HttpClient class makes these tasks straightforward, allowing you to focus on your application's core functionality.

0
136

Related

Reading a file line by line is useful when handling large files without loading everything into memory at once.

✅ Best Practice: Use File.ReadLines() which is more memory efficient.

Example

foreach (string line in File.ReadLines("file.txt"))
{
    Console.WriteLine(line);
}

Why use ReadLines()?

Reads one line at a time, reducing overall memory usage. Ideal for large files (e.g., logs, CSVs).

Alternative: Use StreamReader (More Control)

For scenarios where you need custom processing while reading the contents of the file:

using (StreamReader reader = new StreamReader("file.txt"))
{
    string? line;
    while ((line = reader.ReadLine()) != null)
    {
        Console.WriteLine(line);
    }
}

Why use StreamReader?

Lets you handle exceptions, encoding, and buffering. Supports custom processing (e.g., search for a keyword while reading).

When to Use ReadAllLines()? If you need all lines at once, use:

string[] lines = File.ReadAllLines("file.txt");

Caution: Loads the entire file into memory—avoid for large files!

2
178

When working with SQL Server, you may often need to count the number of unique values in a specific column. This is useful for analyzing data, detecting duplicates, and understanding dataset distributions.

Using COUNT(DISTINCT column_name)

To count the number of unique values in a column, SQL Server provides the COUNT(DISTINCT column_name) function. Here’s a simple example:

SELECT COUNT(DISTINCT column_name) AS distinct_count
FROM table_name;

This query will return the number of unique values in column_name.

Counting Distinct Values Across Multiple Columns

If you need to count distinct combinations of multiple columns, you can use a subquery:

SELECT COUNT(*) AS distinct_count
FROM (SELECT DISTINCT column1, column2 FROM table_name) AS subquery;

This approach ensures that only unique pairs of column1 and column2 are counted.

Why Use COUNT DISTINCT?

  • Helps in identifying unique entries in a dataset.
  • Useful for reporting and analytics.
  • Efficient way to check for duplicates.

By leveraging COUNT(DISTINCT column_name), you can efficiently analyze your database and extract meaningful insights. Happy querying!

0
94

Raw string literals in C# provide a flexible way to work with multiline strings, with some interesting rules around how quotes work.

The key insight is that you can use any number of double quotes (three or more) to delimit your string, as long as the opening and closing sequences have the same number of quotes.

The Basic Rules

  1. You must use at least three double quotes (""") to start and end a raw string literal
  2. The opening and closing quotes must have the same count
  3. The closing quotes must be on their own line for proper indentation
  4. If your string content contains a sequence of double quotes, you need to use more quotes in your delimiter than the longest sequence in your content

Examples with Different Quote Counts

// Three quotes - most common usage
string basic = """
    This is a basic
    multiline string
    """;

// Four quotes - when your content has three quotes
string withThreeQuotes = """"
    Here's some text with """quoted""" content
    """";

// Five quotes - when your content has four quotes
string withFourQuotes = """""
    Here's text with """"nested"""" quotes
    """"";

// Six quotes - for even more complex scenarios
string withFiveQuotes = """"""
    Look at these """""nested""""" quotes!
    """""";

The N+1 Rule

The general rule is that if your string content contains N consecutive double quotes, you need to wrap the entire string with at least N+1 quotes. This ensures the compiler can properly distinguish between your content and the string's delimiters.

// Example demonstrating the N+1 rule
string example1 = """
    No quotes inside
    """; // 3 quotes is fine

string example2 = """"
    Contains """three quotes"""
    """"; // Needs 4 quotes (3+1)

string example3 = """""
    Has """"four quotes""""
    """""; // Needs 5 quotes (4+1)

Practical Tips

  • Start with three quotes (""") as your default
  • Only increase the quote count when you actually need to embed quote sequences in your content
  • The closing quotes must be on their own line and should line up with the indentation you want
  • Any whitespace to the left of the closing quotes defines the baseline indentation
// Indentation example
string properlyIndented = """
    {
        "property": "value",
        "nested": {
            "deeper": "content"
        }
    }
    """; // This line's position determines the indentation

This flexibility with quote counts makes raw string literals extremely versatile, especially when dealing with content that itself contains quotes, like JSON, XML, or other structured text formats.

0
68