MSDN Documentation

RESTful APIs with ASP.NET Core

Representational State Transfer (REST) is an architectural style for designing networked applications. ASP.NET Core provides excellent support for building RESTful services, enabling seamless communication between clients and servers.

Key concepts include:

• Resources: Identified by URIs.
• HTTP Verbs: GET, POST, PUT, DELETE for operations.
• Representations: JSON or XML data formats.
• Statelessness: Each request from client to server must contain all of the information necessary to understand the request.

Example: A simple GET request to retrieve a list of users:

GET /api/users

ASP.NET Core MVC

ASP.NET Core MVC is a popular framework for building web applications using the Model-View-Controller (MVC) architectural pattern. It separates concerns into three interconnected parts, promoting maintainable and scalable code.

Model: Represents the data and business logic.

View: Responsible for presenting the data to the user.

Controller: Handles user input and interacts with the model and view.

MVC is ideal for building traditional web applications with server-side rendering and rich user interfaces.

ASP.NET Core Web API

ASP.NET Core Web API is a framework for building HTTP services that can be accessed from any client that can create an HTTP request. It's specifically designed for creating RESTful services and APIs.

It shares much of its infrastructure with ASP.NET Core MVC, but is more focused on returning data rather than HTML views.

Key Features:

Routing

Attribute-based routing for flexible API endpoint definition.

Model Binding

Automatic mapping of incoming request data to C# objects.

Serialization

Built-in support for JSON and XML serialization.

Dependency Injection

Seamless integration with .NET's built-in DI container.

Example Controller:

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    [HttpGet]
    public IEnumerable<string> Get()
    {
        return new string[] { "Product A", "Product B" };
    }

    [HttpGet("{id}")]
    public string Get(int id)
    {
        return $"Product {id}";
    }
}

ASP.NET Core SignalR

SignalR is a library for ASP.NET developers that simplifies the process of adding real-time web functionality to applications. Real-time web functionality enables server-side code to push content to connected clients instantly as new information becomes available.

SignalR supports:

• WebSockets: The primary transport mechanism.
• Server-Sent Events (SSE): Fallback for clients that don't support WebSockets.
• Long Polling: Another fallback for older clients.

Use SignalR for features like live chat, real-time dashboards, and collaborative applications.

HttpClient for Consuming APIs

The HttpClient class, available in System.Net.Http, is the modern, recommended way to send HTTP requests and receive HTTP responses from other services or APIs in .NET.

It's designed for modern applications, supporting asynchronous operations and efficient connection management.

Example Usage:

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

public class ApiClient
{
    private readonly HttpClient _httpClient;

    public ApiClient(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    public async Task<string> GetDataAsync(string url)
    {
        HttpResponseMessage response = await _httpClient.GetAsync(url);
        response.EnsureSuccessStatusCode(); // Throws if status code is not 2xx
        return await response.Content.ReadAsStringAsync();
    }
}

Web Sockets with .NET

WebSockets provide a full-duplex communication channel over a single TCP connection. This allows for real-time, bidirectional communication between the client and the server.

In .NET, you can work with WebSockets directly or leverage libraries like SignalR that abstract much of the complexity.

Use Cases: Online gaming, financial trading platforms, live notifications, and collaborative editing tools.