Embark on an exciting journey into the realm of .NET Core! Before we dive into the technicalities, let’s take a quick stroll through the history of .NET and uncover details about .NET Core introduction.

.NET, a robust framework crafted by Microsoft, has been a stalwart in software development. As technology evolved, a demand for a more adaptable, cross-platform solution arose. This demand gave birth to .NET Core, a framework designed to meet the dynamic needs of modern development.

Unlocking .NET Core’s Power: Key Features and Advantages

Now, let’s unravel the fascinating features that set .NET Core apart.

• Cross-Platform Flexibility: Build and run dotnet applications on Windows, macOS, and Linux.
• Open-Source Transparency: With the source code available to everyone, .NET Core promotes transparency and encourages community contributions.
• Modular: .NET Core’s modular architecture empowers developers to pick only the components needed.

Contrasting .NET Core with the Traditional .NET Framework

Let’s compare the innovative .NET Core and the traditional .NET Framework.

• Cross-Platform Prowess: While .NET Core effortlessly spans Windows, macOS, and Linux, the .NET Framework primarily caters to Windows.
• Open-Source Collaboration: .NET Core embraces an open-source ethos, fostering community collaboration, while the .NET Framework relies heavily on Microsoft’s development.
• Modularity vs. Monolith: .NET Core’s modular design allows component selection, whereas the .NET Framework operates as a monolithic entity.
• Ability to house multiplt dotnet versions: In .NET Core, projects can independently specify and switch between different SDK versions using SDK-style projects and the global.json file. This flexibility contrasts with .NET Framework, where SDK versions are determined system-wide, making it less adaptable for projects with varying SDK requirements.

Hands-On Adventure: Crafting a “Hello World” Application

Let’s get our hands dirty and create a simple yet impactful “Hello World” application.

1. Install .NET Core SDK: Set the stage by installing the .NET Core Software Development Kit.
2. Open a Terminal or Command Prompt: It’s your gateway to the world of coding.
3. Create a Console Masterpiece: Execute the magic command, dotnet new console -n HelloWorld, or leverage the user-friendly Visual Studio editor.
4. Navigate to the HelloWorld Directory: Dive into your newly created project with cd HelloWorld.
5. Run the Application: Witness the magic unfold with dotnet run.

Congratulations! You’ve taken the first steps into the exciting universe of .NET Core. Keep the momentum going, and in the next leg of our journey, we’ll explore even more captivating concepts and practical applications.

Ready to delve deeper? Stay tuned for the next post in our .NET Core series!

References:

https://learn.microsoft.com/en-us/archive/msdn-magazine/2017/september/net-standard-demystifying-net-core-and-net-standard

The post Unveiling .NET Core: Introduction appeared first on Coding Tutorial.

.NET Core Minimal API was introduced with .NET 6 to simplify creating focused APIs. These APIs reduce setup complexity by fluently declaring routes and actions, bypassing traditional scaffolding and controller overhead.

While conventional API setup involves controllers, routes, and middleware, Minimal APIs use concise syntax. They accommodate scaling, handling complex routing, authorization, and content control.

Core features include:

1. Simplicity: Syntax is concise, reducing setup compared to MVC-based APIs.
2. No Controllers: Avoid separate controllers; declare routes and handlers directly.
3. Single File: Suitable for small APIs, fit the entire API within a single file.
4. Inline Configuration: Define configuration inline for intuitive setup.
5. Convention-Based: Reduce explicit configuration needs.

Advantages:

1. Simplicity: Readable syntax aids understanding.
2. Reduced Boilerplate: Less code, quicker development.
3. Inline Configuration: Intuitive settings, simple scenarios.
4. Single File: Manageable for small projects and prototypes.
5. Quick Prototyping: Ideal for fast microservices development.

Disadvantages:

1. Limited Flexibility: May not suit complex projects if not well designed.
2. Scalability and Maintainability: Better for simple cases.
3. Testing and Separation: Effort needed for concerns separation.
4. Learning Curve: Adaptation for experienced developers.

Now, let’s understand Minimal API with a practical TODO list example

Building a Todo List API with .NET Core Minimal APIs: A Step-by-Step Guide

Are you ready to dive into the world of API development using the power of .NET Core Minimal APIs? In this comprehensive guide, we’ll go through the process of building a Todo List API from scratch. By the end, you’ll have a clear understanding of each step and how Minimal APIs can streamline your development process.

Step 1: Get Started with a New .NET Core Project

Creating a Minimal API using Command Prompt

To kick things off, let’s create a new .NET Core project named “TodoApi” using the command-line interface:

dotnet new web -n TodoApi

This simple command sets up the foundation for our Todo List API project.

We can even create a new project using Visual Studio by following below steps.

Creating a Minimal API with Visual Studio: Step-by-Step Guide

• Open Visual Studio and click on “Create a New Project”

• Select “ASP.NET Core Web API” project templete as shown below and click on Next

• Enter a project name, choose a location, and click “Create.”

• In the next screen, we configure the Minimal API. Choose options such as HTTPS, OpenAPI support. Make sure to uncheck “Use Controllers (uncheck ro use minimal APIs)”. Click on Create.

Step 2: Navigate to the Minimal API Project Directory

Navigate to the project directory just created:

cd TodoApi

Step 3: Define Your Todo Model

Create Models folder within the project and create a file named Todo.cs. This is where you’ll define the structure of your todo items:

Todo model will hold essential information about each todo task, including an Id, Title, and IsCompleted flag.

Step 4: Create the Minimal API

Open the Program.cs file and add the following code before app.Run():

if (todoToRemove != null)
{
    todos.Remove(todoToRemove); // Remove the todo from the list
    return Results.Ok(); // Return "Ok" to indicate success
}

return Results.NotFound(); // Return "Not Found" if the todo doesn't exist

Let’s break it down:

• WebApplication.CreateBuilder initializes a builder for the web application.
• builder.Build() creates your application.
• We set up an empty list named todos to hold your todo items.
• nextId helps manage the IDs for new todos.
• We define a GET endpoint at /todos to retrieve your list of todos.

// POST endpoint to add a new todo
app.MapPost(“/todos”, (Todo todo) => {
todo.Id = nextId++;
todos.Add(todo);
return todo;
});

In this block:

• We define a POST endpoint at /todos for adding new todos.
• Each new todo is assigned a unique ID and added to the todos list.
• The newly added todo is then returned as a response.

// PUT endpoint to update an existing todo
app.MapPut(“/todos/{id}”, (int id, Todo updatedTodo) => {
// Find the existing todo with the provided ID
var existingTodo = todos.FirstOrDefault(t => t.Id == id);
if (existingTodo != null)
{
// Update the title and completion status with the new values
existingTodo.Title = updatedTodo.Title;
existingTodo.IsCompleted = updatedTodo.IsCompleted;
return Results.Ok(existingTodo);
}
return Results.NotFound();// Return “Not Found” if the todo doesn’t exist
});

Now for the PUT endpoint:

• We define a PUT endpoint at /todos/{id} for updating existing todos.
• We find the todo with the provided id in the todos list.
• If the todo exists, we update its Title and IsCompleted properties based on the provided updatedTodo and return the updated todo.
• If the todo doesn’t exist, a “Not Found” result is returned.

if (todoToRemove != null)
{
    todos.Remove(todoToRemove); // Remove the todo from the list
    return Results.Ok(); // Return "Ok" to indicate success
}

return Results.NotFound(); // Return "Not Found" if the todo doesn't exist

And finally, the DELETE endpoint:

• We define a DELETE endpoint at /todos/{id} for removing todos.
• We locate the todo to remove in the todos list based on the provided id.
• If the todo exists, we remove it from the list and return an “Ok” result to indicate success.
• If the todo doesn’t exist, a “Not Found” result is returned.

Step 5: Run Your Application

Time to see your Todo List API in action! Run the application with:

Run dotnet run in command prompt or click on TodoApi in Visual Studio as highlighted below.

Step 6: Interact with Your Todo List API

Here’s how you can interact with your Todo List API:

• GET /todos: Retrieve the list of todos.
• POST /todos: Add a new todo.
• PUT /todos/{id}: Update an existing todo.
• DELETE /todos/{id}: Delete a todo.

Congratulations! You’ve successfully built a Todo List API using .NET Core Minimal APIs. This guide took you through the process step by step and provided sample code for each stage.

By following this comprehensive guide, you’ve unlocked the power of .NET Core Minimal APIs to create a functional Todo List API. This step-by-step journey, complete with detailed explanations and code samples, will equip you with the knowledge you need to craft your own APIs efficiently. This code can further be enhanced by adding Repositories and other functinalilties based on requirement.

If you like this post and are interested to learn more about MInimal API, please go through below links for other related posts

Minimal API Archives – Coding Tutorial (codingizfun.com)

References

https://learn.microsoft.com/en-us/aspnet/core/fundamentals/minimal-apis/overview?view=aspnetcore-7.0

https://learn.microsoft.com/en-us/aspnet/core/fundamentals/minimal-apis?view=aspnetcore-7.0

The post Minimal API appeared first on Coding Tutorial.