Examine the Principal Elements of.NET 9

Microsoft’s release of .NET 9 continues its mission to enhance the developer experience, optimize performance, and expand its feature set for modern application development. Whether you’re a seasoned .NET developer or just starting, the updates in .NET 9 bring powerful capabilities to streamline workflows, improve cross-platform support, and elevate application performance.

In this article, we’ll explore the key features of .NET 9 and dive into practical code examples to help you leverage its full potential.

Key Highlights of .NET 9

1. Native AOT (Ahead-of-Time) Compilation Enhancements
2. Improved JSON Serialization with Source Generators
3. C++ Interoperability Improvements
4. Linux and ARM64 Optimization
5. Modern Web Development with Minimal APIs
6. Performance and Security Enhancements

1. Native AOT (Ahead-of-Time) Compilation Enhancements

Native AOT continues to evolve in .NET 9, enabling developers to compile applications into self-contained executables optimized for performance and reduced size. This is particularly beneficial for microservices, CLI tools, and serverless applications, where startup time and memory footprint are critical.

Key Benefits

• Smaller executables with no runtime dependencies.
• Faster startup time compared to JIT-compiled applications.
• Improved diagnostics support for debugging AOT-compiled apps.

Example

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello from .NET 9 with Native AOT!");
    }
}

Building for Native AOT

dotnet publish -r win-x64 -c Release /p:PublishAot=true

2. Improved JSON Serialization with Source Generators

Serialization has always been a cornerstone of .NET development. In .NET 9, the JSON source generator enhancements deliver better performance and type safety, reducing the runtime overhead of serialization and deserialization.

Key Features

• Improved performance: Faster and more efficient serialization.
• Compile-time checks: Detect issues earlier in the development lifecycle.
• Support for polymorphic types.

Example

using System;
using System.Text.Json;
using System.Text.Json.Serialization;

[JsonSerializable(typeof(User))]
public partial class UserJsonContext : JsonSerializerContext
{
}

public class User
{
    public string Name { get; set; }
    public int Age { get; set; }
}

// Serialize and Deserialize
var user = new User { Name = "John", Age = 28 };
string json = JsonSerializer.Serialize(user, UserJsonContext.Default.User);

var deserializedUser = JsonSerializer.Deserialize<User>(json, UserJsonContext.Default.User);

Console.WriteLine(deserializedUser.Name);

3. C++ Interoperability Improvements

For developers working with legacy C++ libraries or requiring low-level performance optimizations, .NET 9 enhances the interop layer, making it easier to call C++ libraries from managed code.

Key Improvements

• Enhanced support for memory pinning and marshaling.
• Optimized interop scenarios for cross-platform compatibility.

Example

using System;
using System.Runtime.InteropServices;

[DllImport("native.dll", EntryPoint = "Add")]
public static extern int Add(int a, int b);

class Program
{
    static void Main()
    {
        int result = Add(5, 10);
        Console.WriteLine($"Result from native library: {result}");
    }
}

4. Linux and ARM64 Optimizations

As cloud-native and containerized applications become the norm, .NET 9 introduces optimizations for Linux and ARM64 platforms. These updates ensure smoother deployments and better performance in modern cloud environments.

Key Enhancements

• Reduced startup time for Linux-based containerized applications.
• Improved ARM64 support for energy-efficient workloads.
• Smaller base images for containerized applications.

Dockerfile Example

ROM mcr.microsoft.com/dotnet/runtime:9.0

WORKDIR /app

COPY . .

ENTRYPOINT ["dotnet", "MyApp.dll"]

5. Modern Web Development with Minimal APIs

Minimal APIs, introduced in .NET 6, continue to evolve in .NET 9, offering even greater flexibility and simplicity for building lightweight web services.

Example. Building a Minimal API

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Welcome to .NET 9!");
app.MapPost("/api/data", (DataModel data) => Results.Ok(data));

app.Run();
record DataModel(string Name, int Value);

Publishing for Production

dotnet publish -c Release -o ./publish

6. Performance and Security Enhancements

Performance is a hallmark of every .NET release, and .NET 9 is no exception. Developers can expect faster execution, improved garbage collection, and better threading.

Key Improvements

• Garbage Collection (GC): Reduced pauses and improved memory management.
• HTTP/3 Enhancements: Lower latency and faster handshakes for web apps.
• Security Updates: Improved cryptographic support and hardened runtime defenses.

Benchmarking Example

Using System.Diagnostics to measure performance:

using System.Diagnostics;
var sw = Stopwatch.StartNew();
// Perform a task
sw.Stop();
Console.WriteLine($"Elapsed time: {sw.ElapsedMilliseconds}ms");

Detailed Use Cases

1. Building Cloud-Native APIs

The cloud-native focus in .NET 9 makes it easier to integrate with Kubernetes and observability tools like OpenTelemetry.

using OpenTelemetry.Trace;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetryTracing(traceBuilder =>

{

    traceBuilder

        .AddAspNetCoreInstrumentation()

        .AddConsoleExporter();

});

var app = builder.Build();
app.MapGet("/", () => "Cloud-Native App with OpenTelemetry in .NET 9");
app.Run();

2. Serverless Applications

Deploy AOT-compiled applications for serverless environments to minimize cold start latency.

// Native AOT optimizes cold start times

Console.WriteLine("Optimized for serverless in .NET 9!");

Why Upgrade to .NET 9?

1. Performance Boost: Applications run faster with reduced memory consumption.
2. Simplified Development: Minimal APIs and improved tooling streamline the coding experience.
3. Future-Ready: Optimized for cloud-native, cross-platform, and microservices architectures.

Conclusion

.NET 9 is a robust release packed with features that cater to modern development challenges. From Native AOT to JSON source generator improvements, the platform empowers developers to create fast, secure, and scalable applications. By embracing .NET 9, you’re not only improving your application’s performance but also ensuring long-term compatibility with emerging technologies.

Start experimenting with .NET 9 today to unlock its full potential in your projects! For more information, visit the official Microsoft .NET documentation.

Windows Hosting Recommendation

HostForLIFE.eu receives Spotlight standing advantage award for providing recommended, cheap and fast ecommerce Hosting including the latest Magento. From the leading technology company, Microsoft. All the servers are equipped with the newest Windows Server 2022 R2, SQL Server 2022, ASP.NET Core 8.0 , ASP.NET MVC, Silverlight 5, WebMatrix and Visual Studio Lightswitch. Security and performance are at the core of their Magento hosting operations to confirm every website and/or application hosted on their servers is highly secured and performs at optimum level. mutually of the European ASP.NET hosting suppliers, HostForLIFE guarantees 99.9% uptime and fast loading speed. From €3.49/month , HostForLIFE provides you with unlimited disk space, unlimited domains, unlimited bandwidth,etc, for your website hosting needs.

 

Read More

Best Umbraco 15.0.0 Hosting in Europe

Based on its useful features and easy to use, many developer need powerful web hosting to support their Umbraco 15.0.0 site well. Because of that, we will inform you the Best Umbraco 15.0.0 Hosting in Europe provider with affordable price and high quality support. After reviewed 20+ Umbraco 15.0.0 Hosting in Europe, we had come out with the best Umbraco 15.0.0 Hosting in Europe, control libraries, databases, technical support, and web hosting price.

 

Umbraco CMS is a fully-featured open source content management system with the flexibility to run anything from small campaign or brochure sites right through to complex applications for Fortune 500's and some of the largest media sites in the world. Umbraco is easy to learn and use, making it perfect for web designers, developers and content creators alike.

Umbraco is strongly supported by both an active and welcoming community of users around the world, and backed up by a rock-solid commercial organization providing professional support and tools. Umbraco can be used in its free, open-source format with the additional option of professional tools and support if required.

How to Choose the Best Umbraco 15.0.0 Hosting in Europe?

Our Best, Cheap Umbraco 15.0.0 Hosting in Europe Recommendation goes to HostForLIFE.eu, a leading web hosts who is well-known for offering high quality Windows hosting from shared hosting. HostForLIFE.eu founded in United Kingdom, and with years’ expansion, HostForLIFE.eu has grown into one of top 10 Umbraco 15.0.0 Hosting in Europe hosting providers for offers reliable and affordable web hosting services on Windows platforms. HostForLIFE.eu a worldwide provider of hosting support the latest release of Microsoft's widely-used Umbraco 15.0.0 Hosting in Europe. You can take advantage of the powerful Umbraco 15.0.0 Hosting in Europe technology in all Windows Shared Hosting, Windows Reseller Hosting and Windows Cloud Hosting Packages.

Is Price Affordable ?

HostForLIFE.eu Budget Friendly Price – The service includes 4 packages called as HostForLIFE Basic, Budget, Economy and Business with the price starting at Є3.49/mo and now, with 15% OFF you can get only Є3.49/month.

• 30 Days Money Back Guarantee – This means webmasters are allowed to get a refund if they cancel the services because of dissatisfaction within the first 30 days.
• Satisfactory Uptime – HostForLIFE.eu employs state-of-the-art data centers and advanced technologies guaranteeing 99.99% uptime shown by the following chart. 

HostForLIFE Umbraco 15.0.0 Hosting in Europe Performance

HostForLIFE.eu Umbraco 15.0.0 web host reliability is absolutely outstanding compared to other comprehensive web hosting companies. HostForLIFE.eu is managed by a sophisticated team with lots of Windows server experts. With the correct IIS, website and file system permission configuration, the security of the hosting websites is well isolated. That means, when one website is hacked by improper code, it’s rare opportunity for other websites be affected.

Technical Support

As introduced above, HostForLIFE.eu has an experienced team on supporting ASP.NET and Umbraco 15.0.0 Hosting in Europe. All of their technical support staffs are kindly, sophisticated and knowledgeable on either Windows platform or SQL Server 2014 databases. HostForLIFE.eu provides 24/7 email and ticket system support mainly. Based on our testing, the average of the first response is about 30 minutes, and it could be faster in working time. HostForLIFE.eu guarantees to respond each support ticket in 12 hours.

Conclusion – HostForLIFE is Best Option for Umbraco 15.0.0 Hosting in Europe

Frankly speaking, HostForLIFE is best option to host your Umbraco 15.0.0 Hosting in Europe. You just need to spend €2.97/month to host your site with them and you can install the latest Umbraco via their Plesk control panel. We would highly recommend them as your Umbraco 15.0.0 Hosting in Europe.

 

Read More

FG.CsvParser: A Powerful .NET Library for Working with CSV Files

For developers, working with CSV files is a routine activity. A.NET Standard 2.1 library called FG.CsvParser was created to simplify and expedite the reading, writing, and querying of CSV files. The ideal solution for managing your CSV-related duties is FG.CsvParser because of its broad customizable options and versatile API.

Key Features of FG.CsvParser

• Read CSV Files: Convert CSV content into JSON or a list of strongly typed objects.
• Write CSV Files: Easily write CSV content for files or append to existing ones.
• Highly Configurable: Adjust parsing options such as delimiters, row splitters, and encoding to suit your needs.
• Query CSV Data: Use custom filters to query CSV content efficiently.

Installation

To start using FG.CsvParser, you can add it to your project via NuGet:

dotnet add package FG.CsvParser

Getting Started with FG.CsvParser

Creating a CsvParser Instance

FG.CsvParser allows you to create a parser instance in multiple ways. Here are some examples:

Open a CSV File with Default Settings

var parser = CsvParser.OpenFile("path/to/your/file.csv");

Open a CSV File with a Header Row

var parser = CsvParser.OpenFile("path/to/your/file.csv", hasHeader: true);

Open a CSV File with Custom Configuration

var configuration = new CsvParserConfiguration
{
    HasHeader = true,
    Delimitter = ',',
    RowSplitter = "\n",
    Encoding = Encoding.UTF8
};
var parser = CsvParser.OpenFile("path/to/your/file.csv", configuration);

Reading CSV Content

Convert CSV Content to JSON

using var parser = CsvParser.OpenFile("path/to/your/csvfile.csv", new CsvParserConfiguration
{
    HasHeader = true,
    Delimitter = ',',
    RowSplitter = "\r\n",
    Encoding = Encoding.UTF8
});

string? jsonContent = await parser.ReadAsJson();
Console.WriteLine(jsonContent);

Convert CSV Content to a List of Objects

using var parser = CsvParser.OpenFile("path/to/your/csvfile.csv", new CsvParserConfiguration
{
    HasHeader = true,
    Delimitter = ',',
    RowSplitter = "\r\n",
    Encoding = Encoding.UTF8
});

List<MyDataClass> dataList = await parser.ReadAs<MyDataClass>();
foreach (var data in dataList)
{
    Console.WriteLine(data);
}

public class MyDataClass
{
    public string Name { get; set; }

    [CsvColumn("Home address")]
    public string HomeAddress { get; set; }
}

Writing CSV Content

Write CSV Content as a String

using var parser = CsvParser.OpenFile("path/to/your/file.csv", new CsvParserConfiguration
{
    HasHeader = true,
    Delimitter = ',',
    RowSplitter = "\r\n",
    Encoding = Encoding.UTF8
});

string csvContent = "Column1,Column2\nValue1,Value2\nValue3,Value4";
await parser.WriteAsync(csvContent, append: false);
Console.WriteLine("CSV content written to file.");

Write a List of Objects to CSV

var dataList = new List<MyDataClass>
{
    new MyDataClass { Column1 = "Value1", Column2 = 1 },
    new MyDataClass { Column1 = "Value2", Column2 = 2 }
};

await parser.WriteAsync(dataList, append: false);
Console.WriteLine("List of objects written to CSV file.");

Querying CSV Content

You can query CSV data using custom filters to extract only the information you need.

using var parser = CsvParser.OpenFile("path/to/your/csvfile.csv", new CsvParserConfiguration
{
    HasHeader = true,
    Delimitter = ',',
    RowSplitter = "\r\n",
    Encoding = Encoding.UTF8
});

await foreach (var item in parser.Query<MyDataClass>(data => data.Column2 > 100))
{
    Console.WriteLine(item);
}

Configuration Options

The CsvParserConfiguration class provides extensive configuration options to customize your CSV parsing experience:

var configuration = new CsvParserConfiguration
{
    HasHeader = true,
    Delimitter = ';',
    RowSplitter = "\n",
    Encoding = Encoding.UTF8
};

using var parser = CsvParser.OpenFile("path/to/your/file.csv", configuration);

Why Choose FG.CsvParser?

FG.CsvParser simplifies working with CSV files by providing a clean and intuitive API. Whether you need to process CSV files for small tasks or large-scale applications, FG.CsvParser offers the tools and flexibility required to handle your data efficiently.

Windows Hosting Recommendation

HostForLIFEASP.NET receives Spotlight standing advantage award for providing recommended, cheap and fast ecommerce Hosting including the latest Magento. From the leading technology company, Microsoft. All the servers are equipped with the newest Windows Server 2022 R2, SQL Server 2022, ASP.NET Core 7.0.10 , ASP.NET MVC, Silverlight 5, WebMatrix and Visual Studio Lightswitch. Security and performance are at the core of their Magento hosting operations to confirm every website and/or application hosted on their servers is highly secured and performs at optimum level. mutually of the European ASP.NET hosting suppliers, HostForLIFE guarantees 99.9% uptime and fast loading speed. From €3.49/month , HostForLIFE provides you with unlimited disk space, unlimited domains, unlimited bandwidth,etc, for your website hosting needs.

 

Read More

The Importance of Unit Testing in .NET Applications

 A crucial component of contemporary software development is unit testing. It focuses on testing distinct program elements (or "units") one at a time to ensure that each one functions as expected. Unit testing is essential for enhancing code quality, reducing errors, and increasing an application's general maintainability in the context of.NET applications.

The importance of unit testing in.NET programs, its benefits, and the proper use of tools like NUnit and MSTest will all be covered in this article. To further elucidate important ideas, we will also include real-world code examples.

What is Unit Testing?

Unit testing refers to testing the smallest units of code (usually individual methods or functions) in isolation from the rest of the system. It makes sure each unit functions as intended in its own way. In the case of .NET, we would do this with the help of xUnit, NUnit, or MSTest frameworks probably.

Why is Unit Testing important?

1. Early Bug Detection: We're talking about unit tests here; they help catch bugs early. Unit tests focus on test cases of small, isolated code units, making it easier for the developer to locate bugs and resolve them before they become larger issues.
2. Code Refactoring: Developers need to refactor code from time to time as projects grow. Unit tests provide a safety net that allows developers to confidently modify code and be notified via green/red test results if they break something.
3. Documentation: Good unit tests act as documentation for the code. They define explicitly the external behavior of each unit of code and thereby help other developers understand and use the code more easily.
4. Improved Code Quality: Unit testing requires developers to reflect more on their code's design. It promotes better, modular code that is more manageable and extensible.
5. Faster Development: Having a strong unit testing strategy allows developers to implement changes and roll out new features at a faster pace. Automated tests help maintain the application's integrity even as new modifications are made.

Tools for Unit Testing in .NET

There are multiple tools available for unit testing by .NET developers. Some of the popular frameworks are,

1. NUnit: NUnit is a popular unit testing framework in .NET. It is simple to use and provides built-in features for assertions and organizing tests.
2. MSTest: MS Unit test Gen is an extension that generates unit tests for existing code. NET applications.
3. xUnit: Another widely used testing framework that tends to be preferred for its simplicity and community-driven improvements.

We will be using NUnit for this article.

Example. Simple Calculator Class

Let’s consider a simple calculator class with basic arithmetic operations. We will write unit tests to ensure that the calculator methods behave as expected.

Setting Up NUnit: To get started, you need to install the NUnit and NUnit3TestAdapter packages. You can do this via NuGet or through the .NET CLI.

dotnet add package NUnit
dotnet add package NUnit3TestAdapter
dotnet add package Microsoft.NET.Test.Sdk

Step 1. Implement the Calculator Class.

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public int Subtract(int a, int b)
    {
        return a - b;
    }

    public int Multiply(int a, int b)
    {
        return a * b;
    }

    public int Divide(int a, int b)
    {
        if (b == 0)
            throw new ArgumentException("Cannot divide by zero.");

        return a / b;
    }
}

Step 2. Create Unit Tests for the Calculator Class.

using NUnit.Framework;

[TestFixture]
public class CalculatorTests
{
    private Calculator _calculator;

    [SetUp]
    public void SetUp()
    {
        _calculator = new Calculator();
    }

    [Test]
    public void Add_TwoNumbers_ReturnsCorrectSum()
    {
        int result = _calculator.Add(3, 5);
        ClassicAssert.AreEqual(8, result);
    }

    [Test]
    public void Subtract_TwoNumbers_ReturnsCorrectDifference()
    {
        int result = _calculator.Subtract(10, 5);
        ClassicAssert.AreEqual(5, result);
    }

    [Test]
    public void Multiply_TwoNumbers_ReturnsCorrectProduct()
    {
        int result = _calculator.Multiply(3, 5);
        ClassicAssert.AreEqual(15, result);
    }

    [Test]
    public void Divide_TwoNumbers_ReturnsCorrectQuotient()
    {
        int result = _calculator.Divide(10, 2);
        ClassicAssert.AreEqual(5, result);
    }

    [Test]
    public void Divide_ByZero_ThrowsArgumentException()
    {
        ClassicAssert.Throws<ArgumentException>(() => _calculator.Divide(10, 0));
    }
}

Explanation

• [TestFixture]: This is an attribute used to indicate that the class contains tests and is a test fixture.
• [SetUp]: This characteristic defines a method that is going to run before each test. In this case, it initializes the Calculator object before each test is run.
• [Test]: This attribute marks methods as test methods.
• ClassicAssert.AreEqual(): This is an assertion that checks if the actual result matches the expected result.

We can run the tests using the dotnet test command in the terminal or using an IDE like Visual Studio. The test runner will execute the tests and report any failures or successes.

 Best Practices for Unit Testing in .NET

• Test One Thing at a Time: A unit test should verify only one behavior or condition. Avoid testing multiple behaviors within a single test.
• Use Mocks and Stubs: In complex applications, we might need to isolate the unit from dependencies like databases or external services. We can use mocking frameworks like Moq to create mocks and stubs for these dependencies.
• Write Readable Tests: Tests should be easy to read and understand. Use descriptive names for test methods that clearly state what behavior is being tested.
• Test Edge Cases: Not only the expected behavior but also edge cases and error conditions (like dividing by zero, null values, etc.) should be tested.
• Keep Tests Independent: Each unit test should be independent of others, so changes in one test shouldn't affect the results of another.

Conclusion

Unit tests are instrumental in writing software with high quality for any modern .NET application. This extremely valuable practice helps to spot bugs as early as possible, thereby directly impacting the maintainability of long-running software projects. By including unit tests in your development workflow, you create a safety net that allows you to confidently change things, refactor without fear, and guarantee that your application really works the way it should. By keeping your tests clean, explicit, and independent, you can enormously boost the quality and maintainability of your software. Recall that unit tests are not information-heavy but rather light text in terms of volume.

Windows Hosting Recommendation

HostForLIFEASP.NET receives Spotlight standing advantage award for providing recommended, cheap and fast ecommerce Hosting including the latest Magento. From the leading technology company, Microsoft. All the servers are equipped with the newest Windows Server 2022 R2, SQL Server 2022, ASP.NET Core 8.0 , ASP.NET MVC, Silverlight 5, WebMatrix and Visual Studio Lightswitch. Security and performance are at the core of their Magento hosting operations to confirm every website and/or application hosted on their servers is highly secured and performs at optimum level. mutually of the European ASP.NET hosting suppliers, HostForLIFE guarantees 99.9% uptime and fast loading speed. From €3.49/month , HostForLIFE provides you with unlimited disk space, unlimited domains, unlimited bandwidth,etc, for your website hosting needs.

 

Read More

Preventing XSS in AJAX Web Apps: Best Practices & Prevention

AJAX-based online applications have also grown rapidly with the introduction of online 2.0 architecture. Perceiving AJAX-based web apps as more secure than standard web applications is a major mistake that some firms still make in current modern times. In actuality, there are no unique security features associated with AJAX technology. Like traditional online applications, AJAX-built web apps are equally vulnerable to attack. Cross-Site Scripting in AJAX-based web applications is covered in this article.

AJAX

AJAX is a new technology brought about by the Web 2.0 architecture.It connects to the server asynchronously. It makes use of JavaScript, XML, HTML, and CSS to deal with data objects in web applications using XMLHttpRequest. This means that a web application that uses AJAX can easily update specific parts of a web page without having to refresh the entire page. This AJAX capability has its pros and cons since AJAX carries some of its data objects in plain text to and from the server making it vulnerable to attacks such as XSS and CSRF.

XSS in AJAX

XSS can be used in AJAX to manipulate user data if web applications are deployed without sanitizing input and output data streams that the web application deals with. XSS can easily be used to hijack sessions or user identities. All forms of XSS such as Stored, Reflected, and DOM-based XSS can also be exploited on AJAX-based web applications. Developers should ensure that they encode the data before presenting to safeguard the application from possible attacks.

It is important that developers closely check the entire application for any loopholes where XSS can be exploited especially through user input or output from the server. AJAX functions that fetch data from the server may contain XSS entry points which attackers may use to steal information from the user. A browser can be attacked if the developer uses JavaScript functions such as ‘document. write()’ or ‘eval()' which may result in a DOM-based XSS attack.

Since AJAX-based applications are normally used to provide real-time updates such as RSS feed an application can be exposed to XSS attacks if the developer fetches the data from untrusted Web Service APIs and presents the received data without properly filtering and validating it. AJAX applications are also required to check for special characters such as ‘<, >, /’ to avoid malicious code on user input that goes to make requests to the server.

Prevention

• Sanitize XMLHttpRequest data before sending it back and ensure that all proper validations and escaping of characters have been properly implemented.
• Lock invalid requests.
• Check the application for simultaneous logins to protect users from identity theft.
• Not to use functions like ‘write()’ or ‘eval()’.
• Implement Content-Security-Policy to ensure that any XSS attempts are mitigated by allowing data from trusted sources only.
• Replace special characters such as ?, &, /, < with their HTML and URL equivalents to avoid malicious input from users.

Conclusion

Developers and organizations respectively should take note that AJAX-based applications can also be vulnerable to XSS attacks and take time to sanitize and scan their applications for XSS as well as other common vulnerabilities before deploying them. Perhaps developers should take caution on how the XMLHttpRequests are handled and how data is sanitized and scanned before being presented to avoid common XSS attacks.

Best AJAX Hosting for you Ecommerce Site

After we try HostForLIFE.eu service for 3 months, our site never down and with just one click our AJAX hosting success installed. Their loading speed is so fast and recommended for you who want to get powerful AJAX hosting. 

Read More

An Example of a Modern Feature-Rich Entity Framework using SQLite DB

Modern features like C#'s async/await will be employed, along with an entity framework and SQLite database to handle user addition and fetching.Net Core software. Let's install the Entity framework and SQLite Database packages from Manage NuGet Packages and construct a basic.NET Core application in Visual Studio 2022.

Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.Sqlite
Microsoft.EntityFrameworkCore.Tools

Asynchronous methods can help to perform tasks without blocking the running threads. Asynchronous functions generally contain the await expression and Task keyword Task<T> with returns.

Example

static async Task Main(string[] args)
    {
        Console.WriteLine("Fetching data...");
        //
    }
static async Task<string> FetchDataAsync(string url)
    {
        using (HttpClient client = new HttpClient())
        {

            string response = await client.GetStringAsync(url);
            return response;
        }
    }

Create a model Class file for table structure and execute application SQLite DB file will create

Example Model Class

public class ItemContext : DbContext
{
    public ItemContext() { }

    public DbSet<Item> Products { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlite("Data Source=Item.db");
    }
}

public class Item
  {

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

public static async Task  ClassDBExample()
{
    using (var db = new ItemContext())
    {
        await db.Database.EnsureCreatedAsync();
        var product = new Item { Name = "PC", Price = 899.99m};
        db.Products.Add(product);
        await db.SaveChangesAsync();
        var products = await db.Products.ToListAsync();
        foreach (var item in products)
        {
            Console.WriteLine($"ID: {item.Id}, Name: {item.Name}, Price: {item.Price}");
        }

        product.Price = 899.99m;
        await db.SaveChangesAsync();

        db.Products.Remove(product);
        await db.SaveChangesAsync();
    }
 }

Output

 

Windows Hosting Recommendation

HostForLIFEASP.NET receives Spotlight standing advantage award for providing recommended, cheap and fast ecommerce Hosting including the latest Magento. From the leading technology company, Microsoft. All the servers are equipped with the newest Windows Server 2022 R2, SQL Server 2022, ASP.NET Core 7.0.10 , ASP.NET MVC, Silverlight 5, WebMatrix and Visual Studio Lightswitch. Security and performance are at the core of their Magento hosting operations to confirm every website and/or application hosted on their servers is highly secured and performs at optimum level. mutually of the European ASP.NET hosting suppliers, HostForLIFE guarantees 99.9% uptime and fast loading speed. From €3.49/month , HostForLIFE provides you with unlimited disk space, unlimited domains, unlimited bandwidth,etc, for your website hosting needs.

 

Read More