.NET (ASP.NET) is a software framework developed by Microsoft that primarily runs on Microsoft Windows. It provides a controlled programming environment where software can be developed, installed, and executed. The framework includes a large class library called Framework Class Library (FCL) and provides language interoperability across several programming languages.
A brief explanation along with an example:
Explanation:
.NET allows developers to build applications more easily and efficiently by providing a range of pre-built functionalities and libraries. It supports multiple programming languages like C#, VB.NET, F#, and more, allowing developers to choose the language they are most comfortable with.
Example:
Let's consider a simple console application written in C# that greets the user:
csharpusing System;
class Program
{
static void Main()
{
Console.WriteLine("Enter your name:");
string name = Console.ReadLine();
string greeting = GetGreeting(name);
Console.WriteLine(greeting);
}
static string GetGreeting(string name)
{
// Return a personalized greeting
return $"Hello, {name}! Welcome to the .NET world!";
}
}We import the System namespace, which is part of the .NET Framework.
We define a Program class with a Main method, which is the entry point of the program.
Inside the Main method, we prompt the user to enter their name, read the input, and then call the GetGreeting method to generate a personalized greeting.
The GetGreeting method takes a name as input and returns a string containing a personalized greeting.
Finally, we output the greeting to the console.
When you compile and run this C# program using the .NET framework, it will ask for your name and then greet you with a message like "Hello, [your name]! Welcome to the .NET world!".
This is just a simple example to demonstrate the use of .NET framework and C#. In real-world applications, .NET can be used to build a wide range of software, including web applications, desktop applications, mobile apps, cloud services, and more.
Let's explore a few more examples to illustrate the versatility of the .NET framework across different types of applications:
ASP.NET Web Application:
ASP.NET is a web application framework within .NET that allows developers to build dynamic web applications and services. Here's a simple example of an ASP.NET web application that displays a "Hello, World!" message:
csharpusing System;
using System.Web.UI;
public partial class _Default : Page
{
protected void Page_Load(object sender, EventArgs e)
{
Response.Write("<h1>Hello, World!</h1>");
}
}In this example, we're using ASP.NET's Page class to handle the request. The Page_Load method is executed when the page loads, and it writes the "Hello, World!" message to the response.
Windows Forms Application:
Windows Forms is a graphical user interface (GUI) framework within .NET for building Windows desktop applications. Here's a simple Windows Forms application that displays a button and a message box when the button is clicked:
csharpusing System;
using System.Windows.Forms;
public class MyForm : Form
{
private Button myButton;
public MyForm()
{
myButton = new Button();
myButton.Text = "Click Me!";
myButton.Click += MyButton_Click;
Controls.Add(myButton);
}
private void MyButton_Click(object sender, EventArgs e)
{
MessageBox.Show("Button Clicked!");
}
[STAThread]
public static void Main()
{
Application.EnableVisualStyles();
Application.Run(new MyForm());
}
}In this example, we define a custom MyForm class that inherits from Form. We create a button (myButton) and add it to the form. When the button is clicked, it triggers the MyButton_Click event handler, which displays a message box.
Console Application with File I/O:
.NET provides powerful features for working with files and directories. Here's a simple console application that reads from and writes to a text file:
csharpusing System;
using System.IO;
class Program
{
static void Main()
{
string filePath = "example.txt";
// Write to file
using (StreamWriter writer = new StreamWriter(filePath))
{
writer.WriteLine("Hello, File!");
}
// Read from file
using (StreamReader reader = new StreamReader(filePath))
{
string line = reader.ReadLine();
Console.WriteLine(line);
}
}
}In this example, we use StreamWriter to write "Hello, File!" to a text file, and then StreamReader to read from the same file and display its contents to the console.
These examples demonstrate the flexibility and capability of the .NET framework across different types of applications, including web, desktop, and console applications, as well as various functionalities such as GUI development and file I/O operations.
Each of the examples provided earlier:
ASP.NET Web Application:
ASP.NET is a powerful web framework for building dynamic web applications and services. In the example provided, we have a simple ASP.NET web application that displays a "Hello, World!" message.
Page class:
ASP.NET provides the Page class, which serves as the base class for web pages. In our example, the _Default class inherits from Page.
Page_Load method:
This method is an event handler that gets triggered when the page loads. Inside this method, we use the Response.Write method to write HTML content directly to the response, which is then sent to the client's browser.
ASP.NET provides a wide range of features for building web applications, including server controls, data access, authentication, and more.
Windows Forms Application:
Windows Forms is a GUI framework within .NET for building Windows desktop applications. In the provided example, we create a simple Windows Forms application with a button that displays a message box when clicked.
Form class: Windows Forms applications typically start with a main form that serves as the main window of the application. In our example, the MyForm class inherits from Form.
Button control: We create a button (myButton) and customize its text. We also subscribe to the Click event of the button, specifying the MyButton_Click method as the event handler.
Event handling: When the button is clicked, the MyButton_Click method is executed, which displays a message box using the MessageBox.Show method.
Windows Forms provides a rich set of controls and events for creating interactive desktop applications with ease.
Console Application with File I/O:
.NET offers robust support for working with files and directories, making it easy to perform file I/O operations. In the provided example, we demonstrate how to write to and read from a text file in a console application.
StreamWriter and StreamReader classes: These classes are part of the System.IO namespace and are used for writing and reading text from files, respectively. We use StreamWriter to write data to a file and StreamReader to read data from it.
File operations: We create a text file named "example.txt" and write the string "Hello, File!" to it using StreamWriter. Then, we read the content of the file using StreamReader and display it to the console.
.NET's file I/O capabilities are versatile and include features for reading from and writing to various types of files, handling streams, and working with directories.
These examples highlight just a few aspects of what you can achieve with .NET. Whether you're building web applications, desktop applications, or performing file operations, .NET provides a rich set of tools and libraries to streamline development and enhance productivity.
ASP.NET MVC Web Application:
ASP.NET MVC (Model-View-Controller) is a web development framework within .NET that provides a pattern for building web applications. Unlike traditional ASP.NET Web Forms, ASP.NET MVC promotes separation of concerns and testability. Here's a basic example:
csharpusing System;
using System.Web.Mvc;
public class HomeController : Controller
{
public ActionResult Index()
{
return View();
}
}In this example, we have a controller named HomeController with an action method named Index. When a user navigates to the root URL of the application, this action method is invoked, and it returns a view.
WPF Desktop Application:
Windows Presentation Foundation (WPF) is a UI framework within .NET for building Windows desktop applications with rich graphical interfaces. Here's a simple example of a WPF application that displays a window with a button:
csharpusing System;
using System.Windows;
using System.Windows.Controls;
public class MainWindow : Window
{
public MainWindow()
{
Button button = new Button();
button.Content = "Click Me!";
button.Click += Button_Click;
Content = button;
}
private void Button_Click(object sender, RoutedEventArgs e)
{
MessageBox.Show("Button Clicked!");
}
[STAThread]
public static void Main()
{
Application app = new Application();
app.Run(new MainWindow());
}
}In this example, we create a MainWindow class that inherits from Window. We add a button to the window and subscribe to its Click event to display a message box when clicked.
.NET Core Console Application with Dependency Injection:
.NET Core is a cross-platform, open-source framework that is compatible with Windows, macOS, and Linux. It's widely used for building console applications, web APIs, and microservices. Here's an example of a .NET Core console application that demonstrates dependency injection:
csharpusing Microsoft.Extensions.DependencyInjection;
using System;
public interface IGreetingService
{
void Greet(string name);
}
public class GreetingService : IGreetingService
{
public void Greet(string name)
{
Console.WriteLine($"Hello, {name}!");
}
}
public class Program
{
public static void Main(string[] args)
{
var serviceProvider = new ServiceCollection()
.AddTransient<IGreetingService, GreetingService>()
.BuildServiceProvider();
var greetingService = serviceProvider.GetService<IGreetingService>();
greetingService.Greet("World");
}
}In this example, we define an interface IGreetingService and a class GreetingService that implements it. We then use the built-in dependency injection container provided by .NET Core to register the GreetingService and resolve it to greet the world.
These additional examples showcase the versatility of the .NET ecosystem, from building web applications with ASP.NET MVC to creating rich desktop interfaces with WPF and developing cross-platform console applications with .NET Core. Each example demonstrates different aspects of .NET development, including web development, desktop GUIs, and dependency injection.
Entity Framework Core with ASP.NET Core Web API:
Entity Framework Core (EF Core) is an Object-Relational Mapping (ORM) framework that enables developers to work with relational databases using .NET objects. Combined with ASP.NET Core, it provides a powerful solution for building RESTful APIs. Here's a simple example:
csharpusing Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
public class TodoItem
{
[Key]
public int Id { get; set; }
public string Name { get; set; }
public bool IsComplete { get; set; }
}
public class TodoContext : DbContext
{
public TodoContext(DbContextOptions<TodoContext> options)
: base(options)
{
}
public DbSet<TodoItem> TodoItems { get; set; }
}
[Route("api/[controller]")]
[ApiController]
public class TodoItemsController : ControllerBase
{
private readonly TodoContext _context;
public TodoItemsController(TodoContext context)
{
_context = context;
}
[HttpGet]
public ActionResult<List<TodoItem>> GetAll()
{
return _context.TodoItems.ToList();
}
[HttpPost]
public IActionResult Create(TodoItem item)
{
_context.TodoItems.Add(item);
_context.SaveChanges();
return CreatedAtRoute(nameof(GetAll), null);
}
}
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<TodoContext>(opt =>
opt.UseInMemoryDatabase("TodoList"));
services.AddControllers();
}
public void Configure(IApplicationBuilder app)
{
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
}In this example, we define a TodoItem class representing a todo item with properties like Id, Name, and IsComplete. We then create a TodoContext class that inherits from DbContext to interact with the database. The TodoItemsController class is an ASP.NET Core Web API controller providing endpoints to perform CRUD operations on todo items. Finally, the Startup class configures the application's services and middleware.
SignalR Real-time Communication:
SignalR is a library for ASP.NET Core that enables real-time communication between the server and clients over WebSockets, long-polling, or other transports. Here's a basic example of a chat application using SignalR:
csharpusing Microsoft.AspNetCore.SignalR;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using System.Threading.Tasks;
public class ChatHub : Hub
{
public async Task SendMessage(string user, string message)
{
await Clients.All.SendAsync("ReceiveMessage", user, message);
}
}
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddSignalR();
}
public void Configure(IApplicationBuilder app)
{
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapHub<ChatHub>("/chathub");
});
}
}In this example, we define a ChatHub class that inherits from Hub. It contains a method SendMessage that broadcasts messages to all connected clients. The Startup class configures SignalR services and adds a route for the ChatHub.
These examples showcase the usage of advanced .NET technologies like Entity Framework Core for database interaction and SignalR for real-time communication in web applications. They demonstrate how .NET enables developers to build robust, scalable, and modern applications across various domains.
Windows Service:
Windows Services are long-running background processes that don't have a user interface. They are commonly used for tasks such as monitoring, maintenance, or automation. Here's a simple example of a Windows Service using .NET:
csharpusing System.ServiceProcess;
using System.Threading;
public class MyService : ServiceBase
{
private Timer _timer;
protected override void OnStart(string[] args)
{
_timer = new Timer(DoWork, null, TimeSpan.Zero, TimeSpan.FromSeconds(60));
}
protected override void OnStop()
{
_timer.Dispose();
}
private void DoWork(object state)
{
// Perform periodic tasks here
}
public static void Main()
{
ServiceBase.Run(new MyService());
}
}In this example, we create a class MyService that inherits from ServiceBase, the base class for Windows Services. We override the OnStart and OnStop methods to start and stop the service, respectively. The DoWork method contains the actual work performed by the service, which in this case is executed periodically using a timer.
Azure Functions:
Azure Functions is a serverless compute service that allows you to run event-triggered code without having to explicitly provision or manage infrastructure. Here's an example of an Azure Function using .NET:
csharpusing System;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;
public class MyFunction
{
[Function("MyFunction")]
public static void Run([QueueTrigger("myqueue-items", Connection = "AzureWebJobsStorage")] string myQueueItem,
FunctionContext context)
{
var logger = context.GetLogger("MyFunction");
logger.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
}
}In this example, we define a function Run that is triggered by messages in an Azure Storage Queue (myqueue-items). When a message is added to the queue, the function is invoked, and it logs information about the processed message.
These examples demonstrate additional aspects of .NET development, including creating Windows Services for background tasks and building serverless functions using Azure Functions. They showcase the flexibility and versatility of the .NET ecosystem for developing a wide range of applications and services.
ASP.NET Core Identity:
ASP.NET Core Identity is a membership system that adds login functionality to ASP.NET Core web applications. It provides user authentication, authorization, and user management features. Here's an example of using ASP.NET Core Identity to create a simple user authentication system:
csharpusing Microsoft.AspNetCore.Identity;
public class ApplicationUser : IdentityUser
{
// Additional properties can be added here
}
public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
{
public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
: base(options)
{
}
}
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
services.AddIdentity<ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores<ApplicationDbContext>()
.AddDefaultTokenProviders();
services.Configure<IdentityOptions>(options =>
{
// Configure identity options
});
services.AddControllersWithViews();
services.AddRazorPages();
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
// Configure middleware, routing, etc.
}
}In this example, we define a SentimentData class representing sentiment analysis data and a SentimentPrediction class representing prediction results. We use ML.NET to load data, define a pipeline, train a model, and make predictions.
These examples demonstrate additional capabilities of .NET development, including user authentication and machine learning integration using ASP.NET Core Identity and ML.NET, respectively. They showcase how .NET empowers developers to build a wide range of applications, from web applications with user authentication to machine learning models for sentiment analysis.
Azure Blob Storage with .NET:
Azure Blob Storage is a cloud storage service for storing large amounts of unstructured data. .NET provides libraries for interacting with Azure Blob Storage, allowing you to upload, download, and manage files in the cloud. Here's an example of using Azure Blob Storage with .NET:
csharpusing Azure.Storage.Blobs;
using System;
using System.IO;
using System.Threading.Tasks;
public class BlobStorageService
{
private readonly string _connectionString;
public BlobStorageService(string connectionString)
{
_connectionString = connectionString;
}
public async Task UploadFileAsync(string containerName, string fileName, Stream stream)
{
BlobServiceClient blobServiceClient = new BlobServiceClient(_connectionString);
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
BlobClient blobClient = containerClient.GetBlobClient(fileName);
await blobClient.UploadAsync(stream, true);
}
public async Task<Stream> DownloadFileAsync(string containerName, string fileName)
{
BlobServiceClient blobServiceClient = new BlobServiceClient(_connectionString);
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
BlobClient blobClient = containerClient.GetBlobClient(fileName);
BlobDownloadInfo download = await blobClient.DownloadAsync();
return download.Content;
}
}In this example, we create a BlobStorageService class that allows uploading and downloading files to and from Azure Blob Storage. We use the Azure.Storage.Blobs package to interact with Azure Blob Storage. The UploadFileAsync method uploads a file from a stream to a specified container, while the DownloadFileAsync method downloads a file from a specified container as a stream.
Blazor Server-Side Application:
Blazor is a web framework for building interactive web UIs using C# instead of JavaScript. With Blazor Server-Side, the UI components run on the server and interact with the client via SignalR. Here's a simple example of a Blazor Server-Side application:
csharp@page "/"
@using System.Collections.Generic
<h1>Hello, Blazor!</h1>
@if (names != null)
{
<ul>
@foreach (var name in names)
{
<li>@name</li>
}
</ul>
}
@code {
private List<string> names;
protected override void OnInitialized()
{
names = new List<string> { "Alice", "Bob", "Charlie" };
}
}In this example, we define a Blazor component (Index.razor) that displays a list of names. The names are initialized in the OnInitialized method, which runs when the component is initialized. Blazor components combine markup and C# code, allowing you to build interactive web UIs entirely in C#.
These examples showcase additional capabilities of .NET development, including interacting with cloud storage using Azure Blob Storage and building interactive web UIs with Blazor Server-Side. They demonstrate the flexibility and versatility of the .NET ecosystem for building modern applications and integrating with cloud services.
Unit Testing with NUnit:
NUnit is a popular unit testing framework for .NET applications. It provides a way to write and execute automated tests to verify the correctness of individual units of code. Here's a simple example of writing a unit test using NUnit:
csharpusing NUnit.Framework;
public class Calculator
{
public int Add(int a, int b)
{
return a + b;
}
}
[TestFixture]
public class CalculatorTests
{
[Test]
public void Add_WhenCalled_ReturnsSum()
{
// Arrange
var calculator = new Calculator();
// Act
int result = calculator.Add(3, 5);
// Assert
Assert.AreEqual(8, result);
}
}In this example, we have a Calculator class with an Add method that adds two integers. We then write a unit test using NUnit's [Test] attribute to verify that the Add method returns the correct sum. The test passes if the expected result matches the actual result.
Windows Presentation Foundation (WPF) MVVM Application:
Windows Presentation Foundation (WPF) is a UI framework for building Windows desktop applications with rich user interfaces. The Model-View-ViewModel (MVVM) pattern is commonly used with WPF to separate concerns and improve testability. Here's a simple example of a WPF MVVM application:
xml<!-- View (MainWindow.xaml) -->
<Window x:Class="MVVMExample.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="MVVM Example" Height="250" Width="350">
<StackPanel>
<TextBox Text="{Binding InputText, Mode=TwoWay}" Margin="10"/>
<Button Content="Submit" Command="{Binding SubmitCommand}" Margin="10"/>
<TextBlock Text="{Binding OutputText}" Margin="10"/>
</StackPanel>
</Window>csharp// ViewModel (MainViewModel.cs)
using System.ComponentModel;
using System.Windows.Input;
using GalaSoft.MvvmLight;
using GalaSoft.MvvmLight.Command;
public class MainViewModel : ViewModelBase
{
private string _inputText;
private string _outputText;
public string InputText
{
get { return _inputText; }
set { Set(ref _inputText, value); }
}
public string OutputText
{
get { return _outputText; }
set { Set(ref _outputText, value); }
}
public ICommand SubmitCommand { get; }
public MainViewModel()
{
SubmitCommand = new RelayCommand(Submit);
}
private void Submit()
{
OutputText = $"You entered: {InputText}";
}
}In this example, we have a WPF window (View) named MainWindow.xaml that contains a TextBox for input, a Button to submit the input, and a TextBlock to display the output. The ViewModel (MainViewModel.cs) handles the logic and data binding between the View and the Model.
These examples cover unit testing using NUnit and building a WPF MVVM application, showcasing additional capabilities and best practices in .NET development.
ASP.NET Core Web API with JWT Authentication:
JWT (JSON Web Tokens) authentication is a popular method for securing APIs. ASP.NET Core provides built-in support for JWT authentication, allowing you to authenticate and authorize users accessing your API endpoints. Here's a simplified example:
csharpusing System;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.IdentityModel.Tokens;
[Route("api/[controller]")]
[ApiController]
public class AuthController : ControllerBase
{
private readonly string _secretKey = "your_secret_key"; // Replace with your secret key
private readonly string _issuer = "your_issuer"; // Replace with your issuer
[HttpPost("login")]
public IActionResult Login(string username, string password)
{
if (username == "user" && password == "password")
{
var token = GenerateToken(username);
return Ok(new { token });
}
return Unauthorized();
}
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
[HttpGet("data")]
public IActionResult GetData()
{
return Ok("Protected data");
}
private string GenerateToken(string username)
{
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_secretKey));
var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var claims = new[]
{
new Claim(ClaimTypes.Name, username)
};
var token = new JwtSecurityToken(
issuer: _issuer,
audience: _issuer,
claims: claims,
expires: DateTime.UtcNow.AddMinutes(30),
signingCredentials: credentials
);
return new JwtSecurityTokenHandler().WriteToken(token);
}
}In this example, we have an AuthController with two actions: Login for generating JWT tokens upon successful authentication and GetData for accessing protected data using JWT authentication. The Authorize attribute is used to secure the GetData action with JWT authentication.
Azure Cognitive Services with .NET:
Azure Cognitive Services provide pre-built AI models that you can easily integrate into your applications. With .NET, you can leverage these services to add AI capabilities such as image recognition, text analytics, and speech recognition. Here's a basic example of using Azure Cognitive Services for text translation:
csharpusing System;
using Microsoft.Azure.CognitiveServices.Translator.Text;
public class TranslatorService
{
private readonly string _subscriptionKey = "your_subscription_key"; // Replace with your subscription key
public string TranslateText(string text, string targetLanguage)
{
var client = new TranslatorTextClient(new ApiKeyServiceClientCredentials(_subscriptionKey));
var result = client.Translator.TranslateTextAsync(text, targetLanguage).Result;
return result.Translations[0].Text;
}
}In this example, we create a TranslatorService class that uses Azure Cognitive Services Translator Text API to translate text into the target language. You need to replace "your_subscription_key" with your Azure Cognitive Services subscription key.
These examples demonstrate integrating JWT authentication with ASP.NET Core Web API and leveraging Azure Cognitive Services in .NET applications, showcasing additional capabilities in securing APIs and adding AI capabilities to applications.
Machine Learning with ML.NET:
ML.NET is a cross-platform, open-source machine learning framework for .NET developers. It enables developers to build and integrate custom machine learning models into their .NET applications. Here's a simple example of using ML.NET to create a sentiment analysis model:
csharpusing Microsoft.ML;
public class SentimentData
{
public string SentimentText { get; set; }
public bool Sentiment { get; set; }
}
public class SentimentPrediction
{
[ColumnName("PredictedLabel")]
public bool Prediction { get; set; }
}
public class Program
{
public static void Main(string[] args)
{
MLContext mlContext = new MLContext();
// Load data
IDataView data = mlContext.Data.LoadFromTextFile<SentimentData>("sentiment_data.csv", separatorChar: ',');
// Define pipeline
var pipeline = mlContext.Transforms.Text.FeaturizeText("Features", nameof(SentimentData.SentimentText))
.Append(mlContext.BinaryClassification.Trainers.SdcaLogisticRegression());
// Train model
var model = pipeline.Fit(data);
// Make predictions
var predictionEngine = mlContext.Model.CreatePredictionEngine<SentimentData, SentimentPrediction>(model);
var prediction = predictionEngine.Predict(new SentimentData { SentimentText = "This is a great product!" });
// Display prediction
Console.WriteLine($"Predicted sentiment: {(prediction.Prediction ? "Positive" : "Negative")}");
}
}In this example, we define a SentimentData class representing sentiment analysis data and a SentimentPrediction class representing prediction results. We use ML.NET to load data, define a pipeline, train a model, and make predictions.
These examples demonstrate additional capabilities of .NET development, including user authentication and machine learning integration using ASP.NET Core Identity and ML.NET, respectively. They showcase how .NET empowers developers to build a wide range of applications, from web applications with user authentication to machine learning models for sentiment analysis.
