Methods to use Refit to eat APIs in ASP.NET Core

Refit is an open-source library for .NET, .NET Core, and Xamarin that makes consuming REST APIs less complicated and simpler by enabling you to outline the API endpoints as C# interfaces, thereby eliminating the necessity to create HTTP requests and parse HTTP responses manually.

On this article we are going to delve into the Refit library for .NET and see first-hand the way it simplifies the event of APIs. To make use of the code examples offered on this article, it’s best to have Visible Studio 2022 put in in your system. In the event you don’t have already got a replica, you may obtain Visible Studio 2022 right here.

In sections beneath, we are going to implement two functions, a Contact API and a shopper utility for consuming the Contact API. The Contact API utility will comprise the next varieties:

• Contact: This represents the mannequin class.
• IContactRepository: This represents the interface for the contact repository.
• ContactRepository: This represents the contact repository class that incorporates strategies to return contact knowledge.
• ContactsController: This represents the API controller used to show Contact API endpoints to API purchasers.

The shopper utility will use Refit to eat the Contact API and show the information retrieved on the console window.

What’s Refit? Why is it helpful?

Refit is a type-safe, quick, REST library for .NET, .NET Core, and Xamarin that turns your REST API into an interface, making it simpler to eat RESTful net providers. Refit mechanically transforms HTTP calls into C# interfaces utilizing attributes to explain REST operations, thereby simplifying the method of connecting with APIs utilizing minimal code.

To eat APIs utilizing Refit, you want an interface that may work together along with your API. Refit acts as a wrapper across the strategies of this interface and handles HTTP requests and responses elegantly. Refit will mechanically generate the required boilerplate code so that you can entry your APIs.

In the event you’re utilizing Refit for the primary time, it’s essential to first configure the HTTP shopper occasion by specifying the bottom deal with, HTTP headers, serialization, and deserialization info, and so forth. The next code snippet reveals how we will configure the HTTP shopper occasion to connect with an endpoint in ASP.NET Core.

string baseAddress = "http://localhost:59904/";
HttpClient _client = new HttpClient();
_client.BaseAddress = new Uri($"{BaseUrl}");
_client.DefaultRequestHeaders.Settle for.Clear();
_client.DefaultRequestHeaders.Settle for.Add(new MediaTypeWithQualityHeaderValue("utility/json"));
string url = BaseUrl + "api/authors";
var response = await _client.GetAuthors(url);
if (response.IsSuccessStatusCode)
{ 
    var outcome = await response.Content material.ReadAsStringAsync();
    var knowledge = JsonSerializer.Deserialize<Checklist<Creator>>(outcome);
}

In the event you’re already utilizing Refit, you needn’t be bothered with the boilerplate code, as a result of Refit can deal with all of those duties with only a few traces of C# code.

string baseAddress = "http://localhost:59904/";
var endpoint = RestService.For<IAuthorService>(baseAddress);
var contacts = await endpoint.GetAuthors();

As you may see from the previous code snippets, Refit can save us lots of effort and time by eliminating the necessity to write the boilerplate code.

Within the subsequent sections, we’ll implement a easy net API in ASP.NET Core. After we create our API, we’ll implement a Refit shopper to eat it.

Create an ASP.NET Core Internet API undertaking in Visible Studio 2022

To create an ASP.NET Core 8 Internet API undertaking in Visible Studio 2022, comply with the steps outlined beneath.

1. Launch the Visible Studio 2022 IDE.
2. Click on on “Create new undertaking.”
3. Within the “Create new undertaking” window, choose “ASP.NET Core Internet API” from the checklist of templates displayed.
4. Click on Subsequent.
5. Within the “Configure your new undertaking” window, specify the title and site for the brand new undertaking. Optionally examine the “Place answer and undertaking in the identical listing” examine field, relying in your preferences.
6. Click on Subsequent.
7. Within the “Extra Info” window proven subsequent, choose “.NET 8.0 (Lengthy Time period Assist)” because the framework model and be sure that the “Use controllers” field is checked. We shall be utilizing controllers on this undertaking.
8. Elsewhere within the “Extra Info” window, depart the “Authentication Sort” set to “None” (the default) and make sure the examine packing containers “Allow Open API Assist,” “Configure for HTTPS,” and “Allow Docker” stay unchecked. We gained’t be utilizing any of these options right here.
9. Click on Create.

We’ll use this ASP.NET Core Internet API undertaking to create our API within the sections beneath.

Create the Contact mannequin class

Create a brand new class named Contact within the Internet API undertaking you simply created and enter the code given beneath.

namespace Refit_Demo
{
    public class Contact
    {
        public int Id { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Deal with { get; set; }
        public string Cellphone { get; set; }
    }
}

We’ll use the Contact class within the subsequent part to work with knowledge.

Create the ContactRepository class

Subsequent, we’ll create a repository class to work with the Contact knowledge. For the sake of simplicity and brevity, we’ll retailer our knowledge in an inventory in reminiscence. You’ll be able to be happy to alter this implementation to retailer the info in a database as per your necessities. The ContactRepository class implements the IContactRepository. This interface incorporates the declaration of two strategies, specifically, the GetContact and the GetContacts strategies. Whereas the previous returns one contact document based mostly on the id handed to it as a parameter, the latter returns all contacts.

The next code itemizing illustrates each the IContactRepository interface and the ContactRepository class.

public interface IContactRepository
{
    public Contact GetContact(int id);
    public Checklist<Contact> GetContacts();
}
public class ContactRepository: IContactRepository
{
    non-public readonly Checklist<Contact> contacts = new Checklist<Contact>();
    public ContactRepository()
    {
        contacts = new Checklist<Contact>()
        {
            new Contact()
            { Id =1, FirstName = "Keaton", LastName = "Underwood",
                Deal with = "12/3 ABC Street, Chicago, USA",
            Cellphone = "1234567890"},
            new Contact(){ Id = 2, FirstName = "John", LastName = "Smith",
                Deal with = "12/3 ABC Street, New York, USA",
            Cellphone = "0987654321"}
        };
    }
    public Contact GetContact(int id)
    {
        return contacts.SingleOrDefault(c => c.Id == id);
    }
    public Checklist<Contact> GetContacts()
    {
        return contacts;
    }
}

You’ll be able to register an occasion of sort IContactRepository with the providers assortment within the Program.cs utilizing the next piece of code.

builder.Companies.AddScoped<IContactRepository, ContactRepository>();

It will allow you to make use of dependency injection to create an occasion of sort IContactRepository within the utility.

Create the API controller

Allow us to now create the controller class for our Contacts API. To do that, create a brand new API controller named ContactsController and substitute the generated code with the next code.

utilizing Microsoft.AspNetCore.Mvc;
namespace Refit_Demo.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ContactsController : ControllerBase
    {
        non-public readonly IContactRepository _contactRepository;
        public ContactsController(IContactRepository contactRepository)
        {
            _contactRepository = contactRepository;
        }
        [HttpGet]
        public async Process<Checklist<Contact>> Get()
        {
            return await _contactRepository.GetContacts();
        }
        [HttpGet("{id}")]
        public async Process<Contact> Get(int id)
        {
            return await _contactRepository.GetContact(id);
        }
    }
}

Be aware how we now have used constructor injection to create an occasion of sort IContactRepository within the previous code itemizing.

Within the subsequent sections, we’ll create a console utility undertaking and construct the Refit shopper that may eat our contacts API.

Create a .NET Core console utility undertaking in Visible Studio

Comply with the steps outlined beneath to create a brand new .NET Core console utility undertaking in Visible Studio.

1. Launch the Visible Studio IDE.
2. Click on on “Create new undertaking.”
3. Within the “Create new undertaking” window, choose “Console App (.NET Core)” from the checklist of templates displayed.
4. Click on Subsequent.
5. Within the “Configure your new undertaking” window, specify the title and site for the brand new undertaking.
6. Click on Subsequent.
7. Within the “Extra info” window proven subsequent, select “.NET 8.0 (Lengthy Time period Assist)” because the framework model you wish to use.
8. Click on Create.

We’ll use this .NET Core console utility undertaking to create our Refit API shopper.

Set up the Refit NuGet package deal

To put in Refit into your undertaking, choose the undertaking within the Answer Explorer window, then right-click and choose “Handle NuGet Packages.”

Within the NuGet Package deal Supervisor window, seek for the Refit package deal and set up it. Alternatively, you may set up the package deal(s) through the NuGet Package deal Supervisor console by coming into the instructions proven beneath.

PM> Set up-Package deal Refit

Create the Refit API shopper

Now substitute the generated code within the Program.cs file with the next code itemizing.

utilizing Refit;
string baseAddress = "http://localhost:59904/";
var contactsAPI = RestService.For<IContactService>(baseAddress);
var contacts = await contactsAPI.GetContacts();
foreach (var contact in contacts)
{
    Console.WriteLine($"{contact.Id} | {contact.FirstName} |
    {contact.LastName}");
}
Console.ReadLine();
[Headers("Accept: application/json", "Content-type: application/json")]
public interface IContactService
{
    [Get("/api/contacts")]
    public Process<Contact> GetContact(int id);
    [Get("/api/contacts")]
    public Process<Checklist<Contact>> GetContacts();
}
public class Contact
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Deal with { get; set; }
    public string Cellphone { get; set; }
}

Execute the applying

Since there are two functions on this instance, it’s best to run each one after the other. First, run the API utility adopted by the API shopper console utility. When each functions have been launched, you’ll observe the info retrieved from the Contacts API utility displayed on the console as proven in Determine 1.

IDG

Refit is a good alternative for implementing HTTP REST API purchasers. Refit tremendously simplifies the boilerplate code required to connect with and work with REST APIs in your ASP.NET Core functions. One essential level to notice is that once you’re utilizing Refit, all requests have to be asynchronous. Refit doesn’t help synchronous community calls.