NET Core Interview Questions

Question: What is Web API in .NET?

Answer:

A Web API (Application Programming Interface) in .NET is a framework that allows developers to build HTTP-based services to provide functionality over the internet. Web APIs allow different applications, including web and mobile apps, to interact with each other by exposing endpoints that can be accessed over HTTP.

In the context of .NET, particularly ASP.NET Web API or ASP.NET Core Web API, this technology is used to build services that can be consumed by clients such as browsers, mobile applications, or other web services. Web APIs are designed to handle HTTP requests (like GET, POST, PUT, DELETE) and typically return data in formats like JSON or XML.

---

Key Features of Web API in .NET:

1. RESTful Design:

   • Web APIs in .NET are often RESTful (Representational State Transfer), meaning they follow the principles of REST architecture. This involves using standard HTTP methods (GET, POST, PUT, DELETE) for CRUD operations and using URLs to represent resources.
   • RESTful APIs are stateless, meaning each request from the client contains all the information the server needs to process it, and there is no session state maintained on the server.

2. HTTP-Based Communication:

   • Web APIs are built to be accessed over the HTTP protocol, making them lightweight and easy to consume by various types of clients (e.g., browsers, mobile apps, other APIs).
   • Requests and responses are typically formatted in JSON (the most common format for REST APIs) or XML, though other formats are also supported.

3. CRUD Operations:

   • Web APIs are often used to expose CRUD operations (Create, Read, Update, Delete) for interacting with data or resources over the web.
   • For example, you can use an API to manage records in a database, such as adding new users, updating user information, fetching user data, or deleting users.

4. Support for Multiple Client Types:

   • A key feature of Web APIs is that they can serve various types of clients, including web browsers, mobile applications (iOS, Android), desktop applications, and other web services.

5. Stateless:

   • Web APIs are designed to be stateless, meaning that each request is independent, and the server does not maintain any session information between requests. Each request from the client to the server must contain all the information necessary for the server to fulfill the request.

6. Routing:

   • Web APIs use routing to map HTTP requests to appropriate controller actions. In ASP.NET Core Web API, this is typically handled using attribute-based routing, where each action is mapped to a specific URL pattern.

7. Support for HTTP Methods:

   • Web APIs use various HTTP methods for different operations:
     • GET: Retrieve data from the server.
     • POST: Create new data or resource on the server.
     • PUT: Update an existing resource on the server.
     • DELETE: Delete a resource from the server.
     • PATCH: Partially update a resource.

8. Content Negotiation:

   • Web APIs support content negotiation, meaning they can return data in different formats based on the Accept header in the request. For example, a Web API can return data as JSON or XML, depending on the client’s needs.

9. Asynchronous Support:

   • Web APIs in .NET (especially in ASP.NET Core) support asynchronous programming, allowing developers to handle large numbers of requests without blocking threads, improving performance and scalability.

---

Example of Web API in .NET:

Consider a simple Web API to manage a list of products. We can use ASP.NET Core to define the API.

Step 1: Create a Model (Product)

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

Step 2: Create a Controller (ProductController)

In ASP.NET Core Web API, a controller handles incoming HTTP requests.

[Route("api/[controller]")]
[ApiController]
public class ProductController : ControllerBase
{
    private static List<Product> products = new List<Product>
    {
        new Product { Id = 1, Name = "Laptop", Price = 1000.00m },
        new Product { Id = 2, Name = "Smartphone", Price = 500.00m }
    };

    // GET api/product
    [HttpGet]
    public ActionResult<IEnumerable<Product>> Get()
    {
        return Ok(products);  // Returns all products
    }

    // GET api/product/5
    [HttpGet("{id}")]
    public ActionResult<Product> Get(int id)
    {
        var product = products.FirstOrDefault(p => p.Id == id);
        if (product == null)
        {
            return NotFound();  // If product not found, return 404
        }
        return Ok(product);  // Returns the product
    }

    // POST api/product
    [HttpPost]
    public ActionResult<Product> Post([FromBody] Product product)
    {
        product.Id = products.Max(p => p.Id) + 1;  // Assign a new ID
        products.Add(product);
        return CreatedAtAction(nameof(Get), new { id = product.Id }, product);  // Return a 201 status with the created product
    }

    // PUT api/product/5
    [HttpPut("{id}")]
    public IActionResult Put(int id, [FromBody] Product product)
    {
        var existingProduct = products.FirstOrDefault(p => p.Id == id);
        if (existingProduct == null)
        {
            return NotFound();  // If product not found, return 404
        }

        existingProduct.Name = product.Name;
        existingProduct.Price = product.Price;
        return NoContent();  // Returns 204 (No Content) status
    }

    // DELETE api/product/5
    [HttpDelete("{id}")]
    public IActionResult Delete(int id)
    {
        var product = products.FirstOrDefault(p => p.Id == id);
        if (product == null)
        {
            return NotFound();  // If product not found, return 404
        }

        products.Remove(product);
        return NoContent();  // Return 204 (No Content) status after deletion
    }
}

In this example, the ProductController exposes the following endpoints:

• GET api/product: Returns all products.
• GET api/product/{id}: Returns a specific product by its ID.
• POST api/product: Creates a new product.
• PUT api/product/{id}: Updates an existing product.
• DELETE api/product/{id}: Deletes a product.

---

Key Advantages of Using Web API in .NET:

1. Cross-platform:

   • ASP.NET Core Web API is cross-platform, which means it can run on Windows, Linux, and macOS. This makes it a versatile choice for building APIs that need to run on various operating systems.

2. Scalability:

   • Web APIs can scale easily. ASP.NET Core provides built-in support for asynchronous programming, which improves scalability by enabling the application to handle more concurrent requests without blocking threads.

3. Decoupling Frontend and Backend:

   • Web APIs enable decoupling of the frontend (UI) from the backend (server-side logic). This is particularly useful in modern applications where the frontend might be a mobile app or a JavaScript-based single-page application (SPA), while the backend API handles data access and business logic.

4. Standardized Protocol:

   • Web APIs use the standard HTTP protocol, which is well-understood and widely used. Clients can interact with Web APIs using any HTTP-based library or framework (like HttpClient in .NET, or fetch in JavaScript).

5. Interoperability:

   • Web APIs in .NET can easily interact with other systems, regardless of the platform or programming language used on the client side, as long as they support HTTP and can consume JSON or XML.

6. Security:

   • Web APIs in .NET support industry-standard security protocols like OAuth, JWT (JSON Web Tokens), API keys, and SSL/TLS encryption, making it easy to secure your API endpoints.

---

Conclusion:

• Web API in .NET (particularly ASP.NET Core Web API) is a framework for building HTTP-based services that expose data and functionality to clients via the web.
• It allows you to create RESTful services using standard HTTP methods (GET, POST, PUT, DELETE), and data is typically returned in JSON or XML format.
• Web APIs are stateless, cross-platform, scalable, and provide flexibility for building modern applications that need to interact with other systems over the internet.
• Web APIs are essential for developing decoupled systems where the backend logic and frontend UI are separated, especially in mobile apps, SPAs, and microservices architectures.

Question: What is SignalR in .NET?

Answer:

SignalR is a real-time communication library for ASP.NET that enables bi-directional communication between server and client. It allows the server to push content to connected clients instantly as it becomes available, without the client having to repeatedly poll the server for updates. SignalR is used to build real-time web applications, where the server can send updates to clients in real time, making it ideal for applications like chat apps, live notifications, gaming, collaborative applications, and live data streaming.

SignalR abstracts away the complexities of real-time communication and provides an easy-to-use API to implement features like push notifications, live chat, real-time dashboards, and more.

---

Key Features of SignalR:

1. Real-Time Communication:

   • SignalR allows the server to send data to clients as soon as it becomes available. This is in contrast to traditional web applications, where the client has to request updates from the server, often through repeated polling.
   • SignalR enables the server to push updates to the client at any time, providing a push-based model instead of the client continuously checking for new information.

2. Automatic Reconnection:

   • SignalR automatically handles connection management, including connection establishment and reconnection. If a connection is lost (due to network issues, for example), SignalR will automatically attempt to reconnect, ensuring minimal downtime for real-time features.

3. Cross-Platform Support:

   • SignalR is designed to be used across different platforms and supports many different types of clients, including web browsers, desktop applications, mobile devices, and IoT devices.
   • SignalR supports ASP.NET Core, which makes it cross-platform (Windows, Linux, macOS) and can be used in cloud-hosted environments (like Azure).

4. Hub-based Communication:

   • SignalR uses a Hub abstraction for communication between the server and client. A Hub is a high-level pipeline that allows client and server code to call methods on each other.
   • The server can call methods on clients (push data), and clients can call methods on the server (request data).

   Example Hub:

   public class ChatHub : Hub
   {
       // Sends a message to all clients
       public async Task SendMessage(string user, string message)
       {
           await Clients.All.SendAsync("ReceiveMessage", user, message);
       }
   }

   In this example, the ChatHub is a SignalR Hub that sends a message to all connected clients.

5. Connection Management:

   • SignalR enables easy management of connections between clients and servers. You can track connections, groups of connections, and manage how messages are sent to groups of clients.
   • You can send messages to specific clients or groups of clients using their connection IDs or group names.

6. Supports Multiple Transport Methods:

   • SignalR automatically chooses the best available transport method for communication. If WebSockets are available (preferred method), it will use WebSockets, which is efficient and provides low-latency communication.
   • If WebSockets is not available (e.g., due to network limitations), SignalR will fall back to other transports like Long Polling or Server-Sent Events (SSE) to ensure real-time communication still works.

7. Scalability:

   • SignalR supports scale-out capabilities, which allows the application to scale across multiple servers. For example, it can distribute messages to clients connected to different servers using a backplane like Azure SignalR Service, Redis, or SQL Server.

---

Common Use Cases for SignalR:

1. Real-Time Chat Applications:

   • SignalR is commonly used in chat applications, where messages are pushed to all connected users instantly. Each time a user sends a message, it is broadcast to all other connected users in real time.

2. Live Notifications:

   • SignalR is used for live push notifications in web applications. For example, social media platforms can send real-time notifications to users when they receive new messages, likes, or comments.

3. Live Data Dashboards:

   • SignalR is used in real-time data dashboards where the server pushes updates to the client as soon as data changes. For example, financial trading apps or system monitoring tools can use SignalR to push live data like stock prices, CPU usage, or website traffic to the clients.

4. Online Gaming:

   • Multiplayer games use SignalR to provide real-time updates between the server and multiple players. The server can push game state updates, player actions, and events in real time to all participants.

5. Collaborative Applications:

   • In apps where multiple users work on the same document or project simultaneously (like Google Docs or collaborative whiteboards), SignalR allows changes made by one user to be instantly reflected to all other connected users.

6. IoT and Device Communication:

   • SignalR can be used to communicate with IoT devices, allowing the server to send real-time commands or updates to connected devices.

---

Example of Using SignalR in an ASP.NET Core Application:

Step 1: Create a SignalR Hub

public class ChatHub : Hub
{
    public async Task SendMessage(string user, string message)
    {
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

This ChatHub class represents a SignalR Hub. It has a SendMessage method that the server will call to send a message to all connected clients.

Step 2: Configure SignalR in Startup.cs

In the Startup.cs file, you need to configure SignalR and add the necessary middleware for it to work:

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddSignalR();  // Add SignalR services
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseRouting();

        app.UseEndpoints(endpoints =>
        {
            // Map the SignalR hub to a route
            endpoints.MapHub<ChatHub>("/chathub");
        });
    }
}

Step 3: Create a Client-side JavaScript to Connect to SignalR Hub

On the client-side, you can use the SignalR JavaScript client to connect to the SignalR Hub and listen for updates.

<script src="https://cdn.jsdelivr.net/npm/@microsoft/[email protected]/dist/browser/signalr.min.js"></script>

<script>
    const connection = new signalR.HubConnectionBuilder()
        .withUrl("/chathub")
        .build();

    // Receive messages from the server
    connection.on("ReceiveMessage", function (user, message) {
        const msg = user + ": " + message;
        document.getElementById("messagesList").innerHTML += "<li>" + msg + "</li>";
    });

    // Start the connection
    connection.start().catch(function (err) {
        return console.error(err.toString());
    });

    // Send a message to the server
    function sendMessage() {
        const user = document.getElementById("user").value;
        const message = document.getElementById("message").value;
        connection.invoke("SendMessage", user, message).catch(function (err) {
            return console.error(err.toString());
        });
    }
</script>

This script connects to the SignalR ChatHub and listens for messages from the server. It also sends messages to the server using the SendMessage method.

---

Advantages of SignalR:

1. Real-Time Communication:

   • SignalR enables real-time communication between the server and client, which is ideal for applications that require live updates, such as chat applications, live data dashboards, and multiplayer games.

2. Automatic Connection Management:

   • SignalR automatically handles issues like connection loss and reconnection, making it easy to build resilient real-time apps without worrying about connection details.

3. Cross-Platform:

   • SignalR works seamlessly across various platforms and clients, including web browsers, mobile apps, and desktop applications. It also works with ASP.NET Core, which is cross-platform.

4. Scalability:

   • SignalR supports scaling out across multiple servers using technologies like Azure SignalR Service, Redis, or SQL Server, allowing applications to scale as needed.

5. Multiple Transport Methods:

   • SignalR supports multiple transport methods (WebSockets, long polling, Server-Sent Events), ensuring that real-time communication can still work even if WebSockets are not available in certain network environments.

---

Conclusion:

SignalR is a powerful library for enabling real-time, two-way communication in web applications built with ASP.NET Core. It simplifies the process of building applications that require live updates, such as chat systems, collaborative apps, and live data feeds. SignalR handles connection management, message distribution, and real-time updates, making it a great choice for modern, interactive web applications.

Read More

If you can’t get enough from this article, Aihirely has plenty more related information, such as .NET interview questions, .NET interview experiences, and details about various .NET job positions. Click here to check it out.