RestSharp in Practice (Part 1) Getting Started with RestSharp, GET Requests, and API Response Structures

RestSharp in Practice (Part 1)

Getting Started with RestSharp, GET Requests, and API Response Structures

Practical REST API patterns for real-world WinForms applications

When building enterprise WinForms applications, API communication code tends to become repetitive very quickly.

You serialize DTOs, configure headers, deserialize responses, and handle API errors over and over again across multiple screens.

RestSharp helps simplify these tasks by providing a clean and intuitive REST client for .NET applications.

In this series, we’ll walk through practical patterns that can be applied directly to real-world desktop business applications.

Series Overview

• Part 1 — Getting Started with RestSharp, GET Requests, and API Response Structures ← You Are Here
• Part 2 — POST, PUT, DELETE, and JWT Authentication
• Part 3 — Error Handling and Grid CRUD Save Patterns

Introduction

When calling REST APIs from WinForms or console applications, using HttpClient directly often results in more boilerplate code than expected.

You need to handle:

• Request serialization
• Query string generation
• Header configuration
• Response deserialization
• Error handling

While none of these tasks are difficult individually, repeating them throughout an application can quickly become tedious.

RestSharp is a popular REST client library for .NET that significantly reduces this overhead. It provides a cleaner way to build requests, manage headers, send JSON payloads, and process responses.

Throughout this series, we’ll focus on patterns that are actually used in production desktop applications rather than simple demo examples.

Environment

• .NET Framework 4.7.2
• RestSharp 110.x
• Newtonsoft.Json

Sample Domain

We’ll use a simple Product Management System throughout the series:

• Product List
• Product Detail
• Product Create
• Product Update
• Product Delete

Installing RestSharp

Install the required packages from NuGet:

Install-Package RestSharp
Install-Package Newtonsoft.Json

Understanding RestClient and RestRequest

The core of RestSharp revolves around two classes:

RestClient client = new RestClient("https://api.example.com");
RestRequest req = new RestRequest(
    "/products",
    Method.Get);
RestResponse response = client.Execute(req);

ClassResponsibilityRestClientManages the HTTP connection and client configurationRestRequestRepresents an individual API request

Think of it this way:

• RestClient = reusable connection settings
• RestRequest = a single API call

Typically, you’ll create a new request for each API call while reusing client configuration whenever possible.

Understanding the API Response Structure

Before writing any client code, it’s important to understand how the server responds.

Many enterprise applications use a common response envelope:

{
  "scs": true,
  "code": "0",
  "msg": "Processed successfully.",
  "data": {},
  "list": []
}

FieldDescriptionscsBusiness-level success flagcodeResult or error codemsgUser-friendly messagedataSingle object responselistCollection response

One of the most important concepts in this series:

An HTTP 200 response does not necessarily mean the business operation succeeded.

Always verify both:

• HTTP status
• scs flag

For example:

{
  "scs": false,
  "msg": "Product not found."
}

The server may still return HTTP 200 even though the operation failed.

GET Request Example — Loading a List

The following example retrieves a product list.

private void SearchProducts()
{
    RestClient client =
        new RestClient("https://api.example.com");
    RestRequest req =
        new RestRequest("/products", Method.Get);
    req.AddParameter(
        "name",
        txtSearchName.Text);
    req.AddParameter(
        "category",
        cboCategory.SelectedValue.ToString());
    RestResponse response =
        client.Execute(req);
    if (response.IsSuccessful)
    {
        JObject jObject =
            JObject.Parse(response.Content);
        if ((bool)jObject["scs"])
        {
            DataTable dt =
                (DataTable)
                JsonConvert.DeserializeObject(
                    jObject["list"].ToString(),
                    typeof(DataTable));
            dt.AcceptChanges();
            gridProduct.DataSource = dt;
        }
        else
        {
            MessageBox.Show(
                jObject["msg"].ToString());
        }
    }
}

Using AddParameter() automatically generates the query string:

/products?name=Laptop&category=Electronics

No manual string concatenation is required.

GET Request Example — Loading a Single Record

When a user selects a row from a grid, you’ll often need to load detailed information.

private void LoadProductDetail(long productId)
{
    RestClient client =
        new RestClient("https://api.example.com");
    RestRequest req =
        new RestRequest(
            "/products/" + productId,
            Method.Get);
    RestResponse response =
        client.Execute(req);
    if (response.IsSuccessful)
    {
        JObject jObject =
            JObject.Parse(response.Content);
        if ((bool)jObject["scs"])
        {
            ProductDto dto =
                JsonConvert.DeserializeObject<ProductDto>(
                    jObject["data"].ToString());
            txtName.Text = dto.name;
            txtPrice.Text = dto.price.ToString();
        }
    }
}

The DTO structure must match the JSON field names:

public class ProductDto
{
    public long productId { get; set; }
    public string name { get; set; }
    public int price { get; set; }
    public string category { get; set; }
}

This allows automatic deserialization.

Important Considerations

Don’t Rely Solely on IsSuccessful

Many developers assume response.IsSuccessful only checks HTTP status codes.

In reality, RestSharp also verifies the internal response status:

public bool IsSuccessful =>
    (int)StatusCode >= 200
    && (int)StatusCode <= 299
    && ResponseStatus ==
       ResponseStatus.Completed;

This means:

• HTTP errors are detected
• Timeouts are detected
• Network failures are detected

Because of this, many teams create their own helper method:

public static class RestSharpExtensions
{
    public static bool IsSuccessful(
        RestResponse response)
    {
        return
            (int)response.StatusCode >= 200 &&
            (int)response.StatusCode <= 399 &&
            response.ResponseStatus ==
            ResponseStatus.Completed;
    }
}

Whether you treat 3xx redirects as successful depends on your API design.

Why AcceptChanges() Matters

This is one of the most commonly overlooked issues when binding API data to a DataTable.

After deserialization:

All Rows → RowState = Added

After calling:

dt.AcceptChanges();

The state becomes:

All Rows → RowState = Unchanged

Then:

User edits row → RowState = Modified

Without AcceptChanges(), every row may later appear as newly inserted data.

DataTable dt =
    (DataTable)
    JsonConvert.DeserializeObject(
        jObject["list"].ToString(),
        typeof(DataTable));
dt.AcceptChanges();
gridProduct.DataSource = dt;

This becomes extremely important when implementing batch save logic.

We’ll revisit this topic in Part 3.

Architecture and Performance Tips

Centralize API URLs

Avoid hardcoding server URLs in every form.

Instead:

[SERVER]
URL=https://api.example.com/

Then:

string baseUrl =
    ConfigManager.GetServerUrl();
RestClient client =
    new RestClient(baseUrl);

This makes environment changes much easier.

Configure Timeouts Per Scenario

Not every request should have the same timeout value.

Example:

RestClientOptions options =
    new RestClientOptions(
        "https://api.example.com")
{
    MaxTimeout = 2 * 60 * 1000
};

Use longer timeouts only for:

• Large data exports
• Batch processing
• Heavy reporting queries

This improves the overall user experience.

RestClient Lifetime Strategy

For web applications and APIs, keeping a shared client instance is generally recommended to avoid socket exhaustion.

For WinForms desktop applications, where concurrent requests are typically low, creating clients per request is often acceptable and keeps the code straightforward.

However, for high-performance scenarios, reusing client instances may still be beneficial.

Conclusion

In this article, we covered the foundations of using RestSharp in enterprise desktop applications.

Key takeaways:

• Use AddParameter() to build query strings automatically.
• Always validate both HTTP success and business success (scs).
• Understand how IsSuccessful works internally.
• Call AcceptChanges() after deserializing DataTables.
• Centralize server configuration.
• Configure timeouts according to the request type.

These patterns provide a solid foundation for the CRUD workflows commonly found in business applications.

Coming Next

In Part 2, we’ll move beyond read operations and focus on writing data.

Topics include:

• JWT authentication
• Authorization headers
• POST requests
• PUT requests
• DELETE requests
• Unified Create/Update save patterns

These are the patterns you’ll use most frequently when building real-world business applications.

Series Overview

• Part 1 — Getting Started with RestSharp, GET Requests, and API Response Structures ← You Are Here
• Part 2 — POST, PUT, DELETE, and JWT Authentication
• Part 3 — Error Handling and Grid CRUD Save Patterns

Final Thoughts

The patterns covered in this article are especially useful for enterprise-style CRUD screens.

If your application repeatedly follows this workflow:

Search → Bind Grid → Edit → Save Changed Rows

you can apply these patterns almost directly.