DEV Community: Matteo Maggiolini

Top 10 GitHub Projects Worth Contributing to in July 2023⭐

Matteo Maggiolini — Sun, 06 Aug 2023 12:58:26 +0000

DioxusLabs / dioxus

A versatile fullstack GUI library developed in Rust, designed for applications across desktop, web, and mobile platforms.

Why Contribute? Dive into the future of GUI development, and be at the forefront of creating cross-platform solutions with a cutting-edge language like Rust.

https://github.com/DioxusLabs/dioxus

microsoft / azurechatgpt

Microsoft's enterprise-focused ChatGPT solution, offering enhanced privacy and security features, developed in TypeScript.

Why Contribute? Collaborate with Microsoft to shape the future of enterprise chat solutions, ensuring businesses communicate securely and efficiently.

https://github.com/microsoft/azurechatgpt

nextui-org / nextui

A modern React UI library that combines speed and aesthetics, offering developers a fresh approach to web design.

Why Contribute? Be part of a community redefining UI design, and contribute to tools that will be used by developers globally.

https://github.com/nextui-org/nextui

jupyterlab / jupyter-ai

An innovative AI extension for JupyterLab, enabling generative AI capabilities within the popular notebook platform.

Why Contribute? Engage with the fusion of AI and data science, enhancing the capabilities of a platform trusted by researchers worldwide.

https://github.com/jupyterlab/jupyter-ai

manticoresoftware / manticoresearch

A fast, open-source database tailored for search, positioning itself as a robust alternative to Elasticsearch.

Why Contribute? Join the movement to provide a powerful alternative to mainstream search databases, and influence the future of search technology.

https://github.com/manticoresoftware/manticoresearch

public-apis / public-apis

A comprehensive collection of free APIs, serving as a valuable resource for developers seeking diverse integrations.

Why Contribute? Help expand this invaluable resource, ensuring developers have access to the best free tools available.

Repository Link: https://github.com/public-apis/public-apis

ReVanced / revanced-manager

An application designed to enhance the Android experience, developed using the Dart programming language.

Why Contribute? Shape the future of Android customization and contribute to a project that directly impacts millions of users.

Link: https://github.com/ReVanced/revanced-manager

Lissy93 / web-check

A comprehensive OSINT tool in TypeScript, designed for detailed website analysis, ideal for security research.

Why Contribute? Be at the forefront of online security, helping users and businesses protect their digital assets.

https://github.com/Lissy93/web-check

SimplifyJobs / Summer2024-Internships

A curated list of tech internships for Summer 2023 & 2024, providing insights and opportunities for aspiring tech interns.

Why Contribute? Play a role in shaping the careers of future tech leaders by ensuring they have access to the best opportunities.

https://github.com/SimplifyJobs/Summer2024-Internships

QwenLM / Qwen-7B

Alibaba Cloud's official repository for Qwen-7B, a chat and pretrained language model, showcasing advancements in AI.

Why Contribute? Collaborate with one of the tech giants, Alibaba Cloud, and be part of the next big leap in AI-driven communication.

https://github.com/QwenLM/Qwen-7B

Best AI Coding tools of 2023: A Comprehensive Pros/Cons Analysis

Matteo Maggiolini — Sun, 06 Aug 2023 12:36:43 +0000

GitHub Copilot

GitHub Copilot is an AI-powered code completion tool that helps developers generate code faster and more efficiently. It was developed by GitHub and OpenAI and has been gaining popularity since its technical preview release in June 2021.

Pros

Increased productivity: GitHub Copilot can generate code much faster than writing it from scratch, which is especially helpful for large projects or tight deadlines.
Code consistency: It helps ensure that your project's code is consistent, making it easier to maintain and understand.
Learning aid: It can be helpful for programmers who are new to a particular language or framework.

Cons

Unoptimized suggestions: Copilot can suggest code that is unoptimized or inefficient, leading to bad coding habits.
Limited understanding: It may not fully understand the context of the code and may generate incorrect or inappropriate suggestions.
Legal and copyright concerns: There are debates around the legality of the training process of Copilot, as it may infringe on copyrights by default.
Source
You can find GitHub Copilot at its official website: https://copilot.github.com/

OpenAI Codex

OpenAI Codex is a powerful AI code tool based on OpenAI's LLMs (GPT-3 and GPT-4) and trained on billions of lines of code. It can understand natural language inputs and perform a wide range of tasks such as programming, writing, and data analysis.

Pros

Impressive capacity: Codex can resolve references and write code for a variety of APIs and micro-tasks, saving developers time.
Customizability: It can generate code in multiple programming languages and can be trained on specific tasks.
Integration with ChatGPT: Codex has gained additional popularity by its incorporation into ChatGPT, which helps with code generation, language translation, creative content writing, and answering questions informatively.

Cons

Cost: OpenAI Codex may be expensive for some users.
Complexity: It can be challenging to set up and use effectively.
Limited interpretability and flexibility: Codex may not always provide the most efficient or appropriate code suggestions.
Source
You can find OpenAI Codex at its official website: https://www.openai.com/codex/

Tabnine

Tabnine is an AI assistant trusted by millions of developers, including Amazon, Gitlab, and Comcast, that speeds up the coding process by suggesting real-time code completions while typing.

Pros

Versatility: Tabnine supports a wide range of programming languages and is compatible with popular code editors and IDEs.
Free plan available: It offers a free plan for developers to try out the service.
Absolute code privacy & compliance: Tabnine never stores or shares any of your code or AI data, ensuring compliance and control over your data.

Cons

Limited language support: Tabnine may not support all programming languages.
Slow code completion: Some users have reported slow code completion times.
Flow interruption: The need to review code suggestions from Tabnine may cause a break in flow while working on projects.
Source
You can find Tabnine at its official website: https://www.tabnine.com/

CodeT5

CodeT5 is an AI model developed by Salesforce that is trained exclusively to produce code snippets. It is capable of carrying out operations like code completion, summarization, and translation between different programming languages.

Pros

State-of-the-art performance: CodeT5 achieves top performance on fourteen subtasks in a code intelligence benchmark called CodeXGLUE.
Built on a proven architecture: CodeT5 is based on the architecture of Google's T5 framework but incorporates better code-specific knowledge for improved code understanding.
Wide range of code intelligence applications: CodeT5 can be used for various tasks in the software development lifecycle.

Cons

Limited availability: CodeT5 is not as widely available as other AI programming tools like GitHub Copilot or OpenAI Codex.
Potentially less efficient than other tools: CodeT5 may not always provide the most efficient or appropriate code suggestions compared to other tools like Copilot or Codex.
Source
You can find more information about CodeT5 in the official blog post by Salesforce AI Research: https://blog.salesforceairesearch.com/codet5/

Cody by Sourcegraph

Cody by Sourcegraph is an AI-driven coding assistant that offers automated code reviews and identifies and fixes potential bugs in the code. It helps developers improve their code quality and maintainability.

Pros

Automated code reviews: Cody helps identify potential issues in your code and suggests improvements.
Bug detection: It can detect and fix potential bugs, reducing the time spent on debugging.
Integration with popular code editors: Cody integrates with popular code editors like Visual Studio Code, making it easy to use in your existing workflow.
Cons

Limited language support: Cody may not support all programming languages.
Subscription cost: Some users may find the subscription cost prohibitive.
Source
You can find more information about Cody by Sourcegraph on their official website: https://sourcegraph.com/

Codiga

Codiga is a code analysis and improvement tool that helps developers write better code by providing automated code reviews, refactoring suggestions, and more. It aims to improve code quality and maintainability.

Pros

Code quality improvement: Codiga helps identify issues in your code and suggests improvements.
Refactoring suggestions: It provides refactoring suggestions to make your code more efficient and maintainable.
Integration with popular code editors: Codiga integrates with popular code editors like Visual Studio Code, making it easy to use in your existing workflow.

Cons

Limited language support: Codiga may not support all programming languages.
Subscription cost: Some users may find the subscription cost prohibitive.
Source
You can find more information about Codiga on their official website: https://www.codiga.io/

Snyk

Snyk is a security tool that helps developers find and fix vulnerabilities in their code. It integrates with popular code editors and repositories to provide real-time security feedback.

Pros

Security-focused: Snyk helps identify and fix security vulnerabilities in your code.
Integration with popular code editors and repositories: Snyk integrates with popular code editors like Visual Studio Code and repositories like GitHub, making it easy to use in your existing workflow.
Continuous monitoring: Snyk continuously monitors your code for vulnerabilities, ensuring your code remains secure.
Cons

Limited language support: Snyk may not support all programming languages.
Subscription cost: Some users may find the subscription cost prohibitive.
Source
You can find more information about Snyk on their official website: https://snyk.io/

Mintlify

Mintlify is an AI-powered code generator that specializes in creating full-fledged eCommerce websites from scratch. It helps developers build responsive and functional online stores quickly and efficiently.

Pros

eCommerce-focused: Mintlify is specifically designed for creating eCommerce websites.
Rapid development: It helps developers build online stores quickly and efficiently.
Customizable templates: Mintlify offers customizable templates to create unique and visually appealing websites.

Cons

Limited scope: Mintlify is focused on eCommerce websites, making it less suitable for other types of web development projects.
Subscription cost: Some users may find the subscription cost prohibitive.
Source
You can find more information about Mintlify on their official website: https://www.mintlify.com/

MutableAI

MutableAI is an advanced AI-powered platform designed to empower developers with cutting-edge tools for software development and data science tasks. Leveraging the latest advancements in artificial intelligence, MutableAI offers a range of features that enhance coding efficiency and data analysis capabilities.

Pros

Code generation and completion: MutableAI accelerates coding by providing smart code generation and completion, significantly reducing development time.
Automated testing: The platform offers automated testing capabilities, ensuring code quality and reducing the burden of manual testing.
Collaboration and version control: MutableAI supports seamless collaboration among team members and includes version control features for efficient project management.
Data analysis and visualization: For data scientists, MutableAI enables quick data analysis and interactive visualization for deeper insights.
API integration: The platform seamlessly integrates with various APIs, expanding its functionality and enhancing developers' productivity.

Cons

Learning curve: As an advanced AI platform, MutableAI may have a learning curve for new users to fully harness its capabilities.
Limited support for niche programming languages: While MutableAI covers a wide range of programming languages, some niche languages may have limited support.
Source
You can find more information about MutableAI on their official website: mutable.ai

Replit GhostWriter

Replit GhostWriter is an innovative AI-powered writing assistant that provides developers and content creators with valuable support in generating high-quality content. Whether you need help with writing code documentation, blog articles, or any other form of written content, GhostWriter is designed to streamline the writing process and enhance creativity.

Pros

Intelligent code documentation: GhostWriter can automatically generate clear and concise code documentation, saving developers time and effort in explaining their code.
Blog article generation: For content creators, GhostWriter offers assistance in writing engaging blog articles, providing relevant content ideas and suggestions.
Grammar and style improvements: The platform helps refine writing by offering grammar and style suggestions, ensuring polished and professional output.
Customizability: GhostWriter can be tailored to suit individual writing styles and preferences, making it a versatile tool for various writing tasks.
Seamless integration: GhostWriter integrates smoothly with the Replit coding environment, enhancing the writing experience for developers.

Cons

Language limitations: While GhostWriter supports multiple programming languages, it may have limited support for certain niche languages.
Dependency on internet connection: As an online tool, GhostWriter relies on an internet connection, which may pose challenges in offline environments.
Source
You can find more information about Replit GhostWriter on their official website: replit.com/ghostwriter

Durable

Durable is an AI-powered software testing tool that empowers developers to identify and resolve bugs and performance issues in their applications efficiently. With its advanced testing capabilities and intelligent analysis, Durable streamlines the testing process and ensures the robustness and reliability of your software.

Pros

Automated testing: Durable automates the testing process, enabling developers to conduct comprehensive tests without manual intervention, saving valuable time and effort.
Bug detection: The tool identifies and reports bugs and errors, allowing developers to address issues promptly and improve the overall quality of their software.
Performance analysis: Durable offers in-depth performance analysis, helping developers optimize the speed and efficiency of their applications.
Test coverage assessment: The platform evaluates test coverage, ensuring that all critical functionalities of the software are thoroughly tested.
Integration with CI/CD pipelines: Durable seamlessly integrates with continuous integration/continuous deployment (CI/CD) pipelines, enabling automated testing throughout the development process.

Cons

Learning curve: As a sophisticated testing tool, Durable may require some learning and familiarization to utilize its full potential.
Limited platform support: While Durable supports various platforms, some niche platforms may have limited compatibility.
Source
You can find more information about Durable on their official website: durable.com

Bugasura

Bugasura is an AI-powered bug tracking and issue management tool designed to streamline the bug fixing process for developers and software teams. By leveraging artificial intelligence, Bugasura assists in detecting, tracking, and resolving bugs, ensuring smoother development workflows and enhanced software quality.

Pros

Intelligent bug detection: Bugasura uses AI algorithms to automatically detect and categorize bugs, saving developers time in identifying issues within their codebase.
Issue management: The platform provides a centralized and organized interface to manage and track bugs, enabling seamless collaboration among team members.
Real-time alerts: Bugasura offers real-time notifications for newly detected bugs, allowing developers to address issues promptly.
Insights and analytics: The tool provides valuable insights and analytics on bug trends, helping developers identify recurring issues and improve code quality.
Integration with popular development tools: Bugasura integrates with various popular development tools, ensuring a smooth workflow within existing development environments.

Cons

Learning curve: As a sophisticated bug tracking tool, Bugasura may require some learning and onboarding for new users to fully utilize its features.
Limited platform support: While Bugasura supports various platforms, some less common platforms may have limited compatibility.
Source
You can find more information about Bugasura on their official website: bugasura.io

AI Helper Bot

AI Helper Bot is an intelligent virtual assistant designed to provide valuable support and assistance to developers and users alike. Powered by advanced artificial intelligence, the AI Helper Bot offers a wide range of functionalities and capabilities to simplify tasks and enhance productivity.

Pros

Code assistance: AI Helper Bot can assist developers by providing code snippets, syntax suggestions, and debugging help, making coding tasks more efficient and error-free.
Natural language understanding: The bot can understand and respond to natural language queries, enabling seamless communication and interaction with users.
Task automation: AI Helper Bot can automate repetitive tasks, saving time and effort for users and allowing them to focus on more complex and creative work.
Personalization: The bot can be customized to adapt to individual preferences and workflows, providing personalized assistance for each user.
Continuous learning: AI Helper Bot continuously learns from user interactions, improving its responses and capabilities over time.
Cons

Initial setup: Setting up and configuring AI Helper Bot may require some initial effort and customization to align with specific user needs.
Limited context understanding: While AI Helper Bot is capable of natural language understanding, it may have limitations in fully grasping complex context or nuances.
Source
You can find more information about AI Helper Bot on their official website: aihelperbot.com

Android Studio Bot

Android Studio Bot is an intelligent virtual assistant specifically designed to assist Android developers throughout their app development journey. Powered by advanced AI technologies, the bot offers a range of functionalities tailored to simplify Android app development and boost productivity.

Pros

Code completion and suggestions: Android Studio Bot provides smart code completion and intelligent suggestions, helping developers write code more efficiently and accurately.
Error detection and debugging: The bot can identify and flag errors in the code, making debugging and issue resolution faster and more effective.
Project management: Android Studio Bot assists with project organization and version control, streamlining collaboration among team members.
Integration with Android Studio IDE: Seamlessly integrated with Android Studio, the bot enhances the IDE's capabilities and offers a cohesive development experience.
Instant documentation: Android Studio Bot provides quick access to Android documentation, saving developers time in searching for relevant information.

Cons

Learning curve: As a sophisticated virtual assistant, Android Studio Bot may have a learning curve for developers new to AI-driven development tools.
Limited to Android development: The bot's functionalities are tailored specifically for Android app development, limiting its scope to other platforms.
Source
You can find more information about Android Studio Bot on their official website: androidstudiobot.com

some cool improvements introduced in .NET 8

Matteo Maggiolini — Thu, 03 Aug 2023 10:15:42 +0000

dotnet publish and dotnet pack Release Mode: The dotnet publish and dotnet pack commands now build and pack with the Release mode by default. To produce in Debug mode, you need to set the parameter -p:PublishRelease as false.

System.Text.Json Serialization: Several enhancements have been made to object serialization and deserialization. The source generator now offers improved performance and reliability for Native AOT apps when used with ASP.NET Core. It also allows serializing types with required and init properties already supported in reflection-based serialization. There is now an option to customize the handling of members that are not present in the JSON payload. Support for serializing properties from interface hierarchies has been added. The JsonNamingPolicy feature has been expanded to include new naming policies for snake_case and kebab-case property name conversions. JsonSerializerOptions.MakeReadOnly method allows for explicit control over when a JsonSerializerOptions instance is frozen, and you can check its status using the IsReadOnly property.

Randomness: Two new methods, Random.GetItems and RandomNumberGenerator.GetItems, have been introduced that enable developers to randomly select a set number of items from a given input set. If you need to randomize the order of a span in your application, you can take advantage of two new methods: Random.Shuffle and RandomNumberGenerator.Shuffle.

Performance Improvements: Various new types have been introduced to enhance application performance. The System.Collections.Frozen namespace in .NET 8 includes the FrozenDictionary and FrozenSet collection types. These types are designed to prevent changes to keys and values once a collection is created, resulting in faster read operations such as TryGetValue(). They are particularly useful for collections populated on first use and then persisted for a long-lived service. Buffers.IndexOfAnyValues is a new type in .NET 8, designed to be passed to methods that search for the first occurrence of any value in a passed collection. Text.CompositeFormat is a new type in .NET 8 useful for optimizing format strings that aren't known at compile time.

Improvements in System.Numerics and System.Runtime.Intrinsics: Enhancements have been made to the System.Numerics and System.Runtime.Intrinsics namespaces, including better hardware acceleration for Vector256, Matrix3x2, and Matrix4x4 in .NET 8. Vector256 was redesigned to utilize 2x Vector128 operations internally to achieve partial acceleration of certain functions on Arm64 processors. The introduction of Vector512 is also included in .NET 8. The ConstExpected attribute has been added to hardware intrinsic to alert users when a non-constant value might cause unexpected performance issues. The Lerp(TSelf, TSelf, TSelf) API has been added to IFloatingPointIeee754, enabling the efficient and accurate linear interpolation of two values in float(Single), double (Double), and Half.

New Data Validation Attributes: The DataAnnotations namespace has been expanded with new attributes aimed specifically for validation in cloud-native services. These new attributes are meant to validate data, not entered by users, like configuration options. Apart from the new attributes, the RangeAttribute and RequiredAttribute types also received new properties.

Function Pointers Introspection Support: Function pointers were released with .NET 5. In .NET 8, a System.Type object is returned instead when using typeof or reflection on a function pointer, providing access to function pointer metadata, such as calling conventions, return type, and parameters.

Native AOT: The option to publish an application as native AOT enables the creation of a self-contained version of the app that does not require a separate runtime, bundling everything into a single file. In .NET 8, the support for native AOT now encompasses the x64 and Arm64 architectures on macOS. Moreover, native AOT applications on Linux are now up to 50% smaller in size.

Code Generation Improvements: .NET 8 includes enhancements to code generation and just-in-time (JIT) compilation, including JIT throughput improvements, Arm64 performance improvements, Profile-guided optimization (PGO) improvements, support for AVX-512 ISA extensions, SIMD improvements, cloud-native improvements, and loop and general optimizations.

.NET 8 DevOps Improvements: There are some changes with .NET 8 on image containers. Debian 12 is the default Linux distribution in the container images. The images include a non-root user to make the images non-root capable. The default port has also changed from 80 to 8080 and a new environment variable ASPNETCORE_HTTP_PORTS is available to change ports easily. .NET 8 is now supported on Chiseled Ubuntu images, available at the Ubuntu/DotNet-deps Docker Hub. Chiseled images are designed to have a smaller attack surface as they are stripped down to be ultra-compact, and do not include a package manager or shell. Chiseled images are non-root, making them ideal for developers looking for the benefits of appliance-style computing.

Building Your .NET on Linux: In .NET 8, you can build .NET directly on Linux using dotnet/source-build to create runtimes, tools, and SDKs. Red Hat and Canonical also use this build for .NET. Building in a container is the easiest approach for most people since the dotnet-buildtools/prereqs container images have all the necessary dependencies.

Minimum support baselines for Linux: The support requirements for Linux have been updated for .NET 8, with changes to the minimum support baselines. All architectures will target Ubuntu 16.04 for building .NET. Red Hat Enterprise Linux 7 is no longer supported with .NET 8. Only supporting RHEL 8 and later.

Tips & Tricks About Entity Framework Core 7.x Every .NET Developer Should Know

Matteo Maggiolini — Sun, 16 Jul 2023 11:15:02 +0000

First of all, some common tricks

Eager Loading: To load related data at the same time as its parent, use the Include method.

var blogs = context.Blogs
    .Include(blog => blog.Posts)
    .ToList();

Shadow Properties: Shadow properties are properties that aren't defined in your entity class but are defined for that entity in the EF Core model.

modelBuilder.Entity<Blog>()
    .Property<DateTime>("LastUpdated");

Concurrency Control: It's important to handle conflicts when multiple users are updating the same record. You can use the [ConcurrencyCheck] data annotation attribute.

public class Blog
{
    public int BlogId { get; set; }
    [ConcurrencyCheck]
    public string Url { get; set; }
}

Database Seeding. You can seed data to your database in EF Core

modelBuilder.Entity<Blog>()
.HasData(new Blog {BlogId = 1, Url = "http://sample.com"});

Disable Automatic Detect Changes: For better performance, consider turning off the AutoDetectChanges behavior when you don’t need it.

context.ChangeTracker.AutoDetectChangesEnabled = false;

var products = context.Products.AsNoTracking().ToList();

Streaming instead of buffering: Streaming allows you to process data as it is being read from the database, rather than buffering it all in memory first. This can help reduce memory usage and improve performance.

using var context = new MyDbContext();
using var stream = context.Blogs.AsNoTracking().Select(b => b.Url)
.AsStream();
await stream.CopyToAsync(Response.Body);

Compiled queries: Compiled queries can help improve performance by caching the query execution plan.

private static readonly Func<MyDbContext, int, Blog> _blogById =
    EF.CompileQuery((MyDbContext context, int id) =>
        context.Blogs.FirstOrDefault(b => b.Id == id));

var blog = _blogById(context, 1);

InMemory database provider for testing: The InMemory database provider allows you to create an in-memory database for testing purposes. It provides a lightweight and fast way to test your code without the need for a real database. Here's an example of using the InMemory provider:

services.AddDbContext<MyDbContext>(options =>
    options.UseInMemoryDatabase("TestDatabase"));

Database Views: Database views can provide a simplified and optimized representation of your data.

modelBuilder.Entity<Blog>()
    .ToView("View_Blogs")
    .HasNoKey();

Query Filters: Query filters allow you to apply global filters to your queries, which can be useful for implementing soft delete or multi-tenancy scenarios. Here's an example of using query filters:

modelBuilder.Entity<Blog>()
    .HasQueryFilter(b => !b.IsDeleted);

DbContext pooling can improve the performance of your web applications by reusing the same context instance across requests. This reduces the overhead of creating and disposing DbContext instances. To enable DbContext pooling in an ASP.NET Core application, use the AddDbContextPool method when configuring services in the Startup class:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContextPool<MyDbContext>(options =>
    {
        options.UseSqlServer(
        Configuration.GetConnectionString("DefaultConnection")
        );
    });
}

The AsSplitQuery method can be used to avoid the Cartesian explosion problem when including multiple navigational properties. This method configures EF Core to load the collections in the query results through separate database queries:

var customersWithOrdersAndProducts = context.Customers
    .Include(c => c.Orders)
        .ThenInclude(o => o.Products)
    .AsSplitQuery()
    .ToList();

Now let's dive into ef core 7 specific features

Inserting a single row

var blog = new Blog { Name = "MyBlog" };
ctx.Blogs.Add(blog);
await ctx.SaveChangesAsync();

In EF Core 6.0, this code would start a transaction, execute the command, and then commit the transaction. In EF Core 7.0, the transaction is removed, resulting in a 25% improvement in performance on localhost and a 45% improvement on a remote server.

Inserting multiple rows

for (var i = 0; i < 4; i++)
{
    var blog = new Blog { Name = "Foo" + i };
    ctx.Blogs.Add(blog);
}
await ctx.SaveChangesAsync();

In EF Core 6.0, this would use a MERGE statement to insert four rows, which is significantly faster than four separate INSERT statements. In EF Core 7.0, the transaction is removed, and the temporary table is also removed, resulting in a 61% improvement in performance on a remote server and a 74% improvement on localhost.

Using HiLo feature for integer keys:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>().Property(b => b.Id).UseHiLo();
}

Once HiLo is enabled, the SaveChanges output is efficient, and resembles the GUID scenario.

SQL Server Temporal Tables. EF Core 7.0 now supports SQL Server Temporal Tables. This allows you to keep a history of data changes directly in the database

modelBuilder.Entity<YourEntity>()
    .UseTemporalTable();

Compiled Models. EF Core 7.0 introduces compiled models, which can significantly improve startup performance. Here's how you can use it:

var options = new DbContextOptionsBuilder<YourContext>()
    .UseModel(YourCompiledModel.Instance)
    .Options;

Table-per-Type (TPT) Mapping. EF Core 7.0 introduces support for Table-per-Type (TPT) mapping.

modelBuilder.Entity<YourBaseEntity>()
    .ToTable("YourBaseTable");

modelBuilder.Entity<YourDerivedEntity>()
    .ToTable("YourDerivedTable");

SQLite Online Schema Migrations. EF Core 7.0 introduces support for SQLite online schema migrations.

var options = new DbContextOptionsBuilder<YourContext>()
.UseSqlite("YourConnectionString", b => 
b.MigrationsAssembly("YourAssembly"))
    .Options;

ExecuteUpdate and ExecuteDelete Methods. EF Core 7 introduces two new methods, ExecuteUpdate and ExecuteDelete, that perform changes and deletions of records without loading the entities in memory, resulting in performance gains. However, changes must be specified explicitly as they are not automatically detected by EF Core.

await db.Posts
    .Where(p => p.Id == "3fa85f64-5717-4562-b3fc-2c963f66afa6")
    .ExecuteUpdateAsync(s => s
    .SetProperty(b => b.AuthorName, "John Smith")
    .SetProperty(b => b.Title, b =>  "EF7 is here!")
    .SetProperty(b => b.Text, b =>  "\t")
    .SetProperty(b => 
     b.LastUpdateDate, "2022-30-11 17:29:46.5028235"));

await db.Posts
.Where(p => p.Id == "3fa85f64-5717-4562-b3fc-2c963f66afa6")
.ExecuteDeleteAsync();

JSON Columns. EF7 has native support for JSON columns, which allows mapping .NET types to JSON documents. This includes LINQ queries that can be used in aggregations and will be converted to the appropriate query constructs for JSON. It's also possible to update and save changes to JSON documents.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Author>().OwnsOne(
        author => author.Contact, ownedNavigationBuilder =>
        {
            ownedNavigationBuilder.ToJson();
            ownedNavigationBuilder
            .OwnsOne(contactDetails => contactDetails.Address);
        });
}

var authorsByCity = await db.Authors.Where(author => author
.Contact.Address.City == city).ToListAsync();

var authorExists = await db.Authors
.Where(author => author.Id == id)
.FirstOrDefaultAsync();
authorExists.Contact.Address.Street = "1523 Stellar Dr";
await db.SaveChangesAsync();

New Query Options. EF7 brought new features to queries like GroupBy as the final operator. The example below shows how grouping can be done using the GroupBy extension method:

var groupByAuthor = db.Posts.GroupBy(p => p.AuthorName).ToList();

Bulk Updates and Deletes. EF Core 7 introduces the ability to perform bulk updates and deletes. This allows you to express something similar to a LINQ query to push the changes directly to the database. The new ExecuteDelete and ExecuteUpdate methods are appended to LINQ queries in the same way that you'd apply a LINQ execution method.

context.People
    .Where(p => p.PersonId == 1)
    .ExecuteDelete();

context.People
    .Where(p => p.LastName == "Lehrman")
    .ExecuteUpdate(s => s.SetProperty(c => c.LastName, c => "Lerman"));

Mapping Stored Procedures. EF Core 7 introduces the ability to map stored procedures to entities. This allows you to use stored procedures to perform database operations when you call SaveChanges. The new InsertUsingStoredProcedure, UpdateUsingStoredProcedure, and DeleteUsingStoredProcedure methods allow you to map stored procedures to entities.

modelBuilder.Entity<Person>()
    .InsertUsingStoredProcedure("PeopleInsert",
        spbuilder => spbuilder
            .HasParameter(p => p.PersonId, pb => pb.IsOutput()
            .HasName("id"))
            .HasParameter(p => p.FirstName)
            .HasParameter(p => p.LastName)
    );

Unleashing the Power of Unit Testing: Supercharge Blazor Server Async Components' UI Behavior with .NET Core and BUnit

Matteo Maggiolini — Sun, 25 Jun 2023 15:51:47 +0000

Hi folks,

We are all familiar with unit testing frameworks like Angular, React, and Vue on the client side. But what if we want to test the UI of hybrid or server-side frameworks like Blazor?

Blazor, the web framework by Microsoft, has gained popularity for building interactive web applications using C#. With the release of .NET 8, Blazor has become even more powerful.

Testing is a crucial part of software development, and BUnit, a testing framework, makes it easy to write unit tests for Blazor components. In this blog post, we will explore how to use BUnit (and of course NUnit) to test button clicks in a server-side Blazor component.

Assuming that you are already familiar with Blazor server-side projects

Let's consider a component similar to the one provided, incorporating asynchronous streaming rendering capabilities to enhance complexity. Additionally, it utilizes JS interop for interaction, dynamically rendering buttons, and so on...

@using Microsoft.AspNetCore.Components
@inject IJSRuntime JSRuntime

<h3>Test Component</h3>

<p>Click the button to call a server action and display data:</p>

@if (dataList != null && dataList.Any())
{
    <h4>Data List</h4>
    <ul>
        @foreach (var item in dataList)
        {
            <li>
                @item
                <button class="server-action-button" @onclick="() => CallServerAction(item)">Call Server Action</button>
            </li>
        }
    </ul>
}

@code {
    private List<string> dataList;

    private async Task CallServerAction(string item)
    {
        await Task.Delay(1000);

        dataList.Add(item + " (Added on server)");

        await JSRuntime.InvokeVoidAsync("myCustomJsFunction", "Server action completed!");

        await InvokeAsync(StateHasChanged);
    }

    protected override void OnInitialized()
    {
        dataList = new List<string> { "Item 1", "Item 2", "Item 3" };
    }
}

Now, we can test the button click behavior in a simple and straightforward way

 [Test]
        public void Test_ButtonClick()
        {
            using var ctx = new TestContext();

            var jsInteropMock = new Mock<IJSRuntime>();
            var jsRuntime = jsInteropMock.Object;
            ctx.Services.AddSingleton(jsRuntime);

            var component = ctx.RenderComponent<TestComponent>();
            component.WaitForState(() => component.Instance.dataList != null, TimeSpan.FromSeconds(10));
            component.Render();

            var button = component.FindAll("button.server-action-button")[0];

            var serializeObject = JsonConvert.SerializeObject(component.Instance.dataList);

            Assert.DoesNotThrow(() => button.Click());

            component.WaitForState(() =>
            {
                var serializeObjectToCheck = JsonConvert.SerializeObject(component.Instance.dataList);
                return !serializeObjectToCheck.Equals(serializeObject);
            }, TimeSpan.FromSeconds(30));

            Assert.Pass("data has changed successfully.");
        }

The test case sets up a *TestContext *(Bunit.TestContext, the factory that makes it possible to create components under tests)

A mock instance of IJSRuntime is created using Mock and assigned to jsRuntime. It is then added to the services collection of the TestContext using ctx.Services.AddSingleton(jsRuntime). This allows us to provide a mock implementation of IJSRuntime to the component.

Of course, you will understand that in this context, you can add all the necessary injected services and, if needed, mock them for testing purposes.

The TestComponent is rendered by calling ctx.RenderComponent(). The WaitForState method is used to wait until the initial state of the dataList is not null before rendering the component.

component.Render() is called explicitly to render the component.

The button element with the CSS class "server-action-button" is found using component.FindAll("button.server-action-button")...

The button is simulated to be clicked by calling button.Click().

The test case waits for the state to change using component.WaitForState(). It provides a condition that checks if the dataList has been updated by comparing the serialized dataList before and after the button click.

Of course, we can see that the testing assertions used here are for demonstration purposes only. In reality, you have the flexibility to perform various types of checks and validations, including verifying UI state changes, user interactions, and much more. The possibilities are virtually limitless when it comes to testing and ensuring the desired behavior of your Blazor components.

That's all Folks!

IMHO the Automated testing in Blazor opens up a world of possibilities for ensuring the functionality and reliability of real user interfaces. The example we discussed represents a simple case scenario where we tested the button click behavior and state update in a Blazor component.

By utilizing BUnit and NUnit, we were able to simulate user interactions, trigger server actions, and validate the resulting changes in the component's state. This demonstrates the potential of automated testing in Blazor to catch bugs, validate expected behavior, and provide confidence in the quality of the application.

I think this is a good point to start from

Conclusion

The flexibility and extensibility of automated testing allow you to test various scenarios and handle complex interactions within Blazor components. From validating UI elements to testing complex user workflows, the only limit is your imagination and the specific requirements of your application.

Automated testing in Blazor not only saves time and effort in manual testing but also provides a safety net for detecting issues early in the development cycle. It enables developers to iterate quickly, make changes confidently, and deliver a high-quality user experience.

So, unleash your creativity and explore the full potential of automated testing to ensure that your Blazor applications are robust, reliable, and provide an exceptional user experience.

See you for the next Blazor and .NET post!
Stay tuned