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.

What is Virtual Scrolling?

Virtual scrolling renders only the visible items in a list or grid, instead of loading the entire dataset at once. It dynamically creates and removes elements from the DOM as the user scrolls through the list. This approach is useful when dealing with huge data because it significantly improves performance and reduces memory consumption.

Benefits of Virtual Scrolling:

1. Improved Performance: Virtual scrolling dramatically enhances the performance of web applications by rendering only the visible items. This results in faster initial loading times and smoother scrolling.
2. Reduced Memory Usage: Since only a subset of items is in the DOM at any given time, memory usage reduces significantly, making it feasible to work with large datasets without causing memory-related issues.
3. Consistent User Experience: Virtual scrolling provides a consistent user experience, regardless of the data size, as the scrolling remains smooth and responsive.

Implementing Virtual Scrolling in Angular Material:

Angular Material provides a CdkVirtualScrollViewport directive to implement virtual scrolling. 

Below are the steps for the same

• Install Angular Material using the below command

        ng add @angular/material

    import { ScrollingModule } from '@angular/cdk/scrolling';
    @NgModule({
       imports: [ScrollingModule],
    })

<cdk-virtual-scroll-viewport itemSize="50" minBufferPx="200" maxBufferPx="400"
                             class="example-viewport">
  <div *cdkVirtualFor="let item of items" class="example-item">{{item}}</div>
</cdk-virtual-scroll-viewport>-->

<h4>Items list with Virtual scrolling enabled</h4>
<cdk-virtual-scroll-viewport itemSize="50" minBufferPx="200" maxBufferPx="400"
                             class="example-viewport">
  <div *cdkVirtualFor="let item of items" class="example-item">{{item}}</div>
</cdk-virtual-scroll-viewport>      

Performance:

• Displaying plain list without virtual scrolling

Code

<div>
  <h2>List of Items</h2>
  <ul>
    <li *ngFor="let item of items">{{ item }}</li>
  </ul>
</div>

Performance:

References
https://material.angular.io/cdk/scrolling/overview

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

https://codingizfun.com/

The post Angular Material Virtual scrolling 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.

Monolith

Monolith is an application deployed as a single unit in single or multiple servers behind a Load Balancer. You have a User Interface, Business Logic, and Data Access Layer interacting with a database.

Advantages

1. Easy to debug and deploy since there is only one application.
2. Easy to develop and maintain as we have a single application where UI calls the web service or API without worrying about API backward compatibility and version management. Also, there is only a single point of failure.
3. Only one repository or codebase is easy to maintain and test than integrating multiple services for testing.
4. Less latency as communication between layers in the application is local.

Disadvantages

1. Tightly coupled code as an issue in one piece of code might affect other parts of code.
2. Hard to maintain as the application grows in size.
3. Scalability is a concern as the application as a whole is scaled irrespective of usage. For instance, if we have a Monolith application created with Login, Storage, Retrieval, and Polling functionalities in place. During peak time, if the Retrieval part of the application experiences high traffic, the entire application is scaled up even though other independent parts do not need scaling.
4. Irreversible choice of coding language as a rewrite is required to choose a different language.

Microservices

Microservices is an architecture pattern where an application consists of several small deployable services, which communicate to share data.

Advantages

1. Decoupled code and lightweight.
2. Easy to maintain when the application has a lot of reusable code.
3. Better scalability as there is an option to scale components individually.
4. Choice of using multiple programming languages for different services based on the requirement.
5. Better Fault tolerance as an issue in a microservice will only affect that part of the application.

Disadvantages

1. Deployment is bit tedious as it involves maintenance across different services.
2. Difficulties in maintaining the code dependencies and testing multiple codebases.
3. Latency often arises due to the communication calls made between services across the network.

What to opt for?

Monolith

1. When the application is simple with less release time to market.
2. Limited scaling with moderate application size.

Microservices

1. For largescale applications which involve CPU-intensive business logic or complex real-time data processing.
2. When the application has independent, reusable modules.

References

For more details related to Monolithic vs Microservices, please refer links below

https://www.tutorialspoint.com/microservice_architecture/microservice_architecture_introduction.htm

https://www.geeksforgeeks.org/monolithic-architecture/

The post Monolithic vs Microservices appeared first on Coding Tutorial.

    Unanimous answer found in most of the websites is the reduction of complexity. Let’s dive into this in detail.

In a Nutshell, Maps hold key-value pairs and have below advantages over Objects

•     First, we can use different data types like objects, functions and Primitive types as keys which is not possible with objects. Objects can only have strings as keys.
•     Second, Maps are iterable. Objects can be iterated by converting to an array or checking if a property belongs to it and not a prototype.

       Confusing??? Let’s try iterating through a Javascript object.

Iterating through Javascript Object

        a. Use “Object.keys” or “Object.getOwnPropertyNames” with “foreach”

        b. Use “for..in” with “hasOwnProperty”

    Iterating through Maps in Javascript

     It is simple compared to objects. Just use a for loop, that’s it!!!

    3. Retrieving size of a map is easy by using “size” property. 

Where to use

Let’s see where we can use Javascript Maps. Javascript Maps are useful to store “key-value” pairs. For instance, let’s consider “Two-sum problem”. 

Problem Definition

Given an array, return indices of two numbers such that they add up to the given sum

Solution

1. Here, we are creating a Map with “Target-number”(difference of current number from required sum) as key and index as value.
2. From next index, we check if the “Target-number” exists in the array and return the Array indices if found.
3. If not found, we continue with step 1.

Let’s debug the code for given input

i=0    arrayMap[0] does not exist and it adds (7, 0) to arrayMap.

i=1    arrayMap[7] =0 and we will return [0,1] which are the indices.

Javascript Maps – The Tricky Part

    We all know about “NaN” in Javascript. It does not have a real value and comparing it to itself doesn’t return true.    

Now, here’s a tricky question. Guess the output of code below

                let obj= new Map();

                obj.set(“Name”,”Test”);

                obj.set(NaN,”Test1″);

                obj.get(Nan);

If you answer is “Test1”, you are right.

We can use “NaN” as key in Javascript Maps. Appropriate value rendered with “NaN” key.

                That’s it, there ends my first post. Hope it was not boring and happy coding!!!

References

Map – JavaScript | MDN (mozilla.org)

JavaScript Maps (w3schools.com)

The post Javascript Maps vs Objects appeared first on Coding Tutorial.