DEV Community: JKC

💎 .NET 9 Hidden Gems: 7 Power Features Most Developers Are Missing

JKC — Sat, 16 Aug 2025 04:02:46 +0000

.NET 9 has been out for almost a year now, but most developers are still using it like .NET 8.

The real gains aren't in the headline features. They're in the overlooked improvements that solve daily friction.

The Hidden Arsenal

SearchValues for Strings
.NET 8 had SearchValues for chars. .NET 9 etends it to strings with SIMD optimizations.

 private static readonly SearchValues<string> BadWords = 
     SearchValues.Create(["spam", "scam"], StringComparison.OrdinalIgnoreCase);

 public static bool ContainsSuspiciousContent(string message) =>
     message.AsSpan().ContainsAny(BadWords);

Task.WhenEach for Async Processing
Process async operations as they complete instead of waiting for all.

 var tasks = urls.Select(url => httpClient.GetStringAsync(url));

 await foreach (var task in Task.WhenEach(tasks))
 {
     var result = await task;
     ProcessImmediately(result);
 }

UnsafeAccessor with Generics
.NET 8 introduced UnsafeAccessor. .NET 9 adds generic support for zerooverhead private access.

[UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_value")]
public etern static ref T GetPrivateField<T>(Cache<T> cache);

// In tests: direct access without reflection overhead
ref var field = ref GetPrivateField(cache);

Frozen Collections for Performance
Read-optimized collections that are 40% faster for lookups.

private static readonly FrozenSet<string> ValidEtensions = 
     new[] { ".jpg", ".png", ".pdf" }.ToFrozenSet();

public static bool IsValidFile(string filename) =>
     ValidEtensions.Contains(Path.GetEtension(filename));

DATAS Garbage Collection
Dynamic adaptation is now enabled by default. Your GC automatically adjusts heap size based on workload. No code changes needed.

Why This Matters

These features solve specific performance and productivity pain points that add up over time.

Multi-string search becomes efficient. Async coordination gets simpler. Testing private members becomes fast. Collection lookups get faster. Memory management becomes smarter.

The Reality

Most teams ship .NET 9 apps that perform like .NET 6 because they stick to old patterns.

The developers using these features are already building faster systems while others struggle with familiar bottlenecks.

Final Thought

I've been running .NET 9 in production for months now, and honestly, I can't go back.

When I see 20-30% faster response times and better memory usage, sticking with older versions feels like driving with the parking brake on. The performance gains aren't just nice to have anymore, they're real money left on the table."

👾 GPT 5 is coming and it might be smarter than Sam Altman

JKC — Thu, 10 Jul 2025 14:49:04 +0000

GPT-5 is Coming: The AI Revolution You're Not Ready For

GPT-5 is launching soon. OpenAI is aiming for a release between July and September 2025, and it will be free to use.

Sam Altman, the CEO of OpenAI, recently said that GPT-5 may already be smarter than he is. That's not a marketing line, it's a clear signal that AI is entering a new phase.

What's Different This Time

You won't need to choose between models anymore. GPT-5 is built as a single, unified system that adapts to whatever task you give it. Whether you're coding, writing, researching, or creating content, it just works.

It now reasons by default. You don't have to prompt it to think through steps—it already does.

It also remembers. GPT-5 learns your tone, your goals, and your working style across sessions.

You can talk to it, upload images or files, and it understands everything in one conversation. And thanks to its epanded memory, it can handle huge amounts of contet—full books, long chats, or entire project documents.

The biggest shift might be that GPT-5 doesn't just wait for instructions. It takes initiative based on what it sees and what you need.

Why This Matters

For developers, GPT-5 can write production-ready code, fi bugs, and even help design systems. You'll get work done faster, with fewer manual steps.

For founders, it can act like a partner—helping with strategy, marketing, and eecution without needing a full team.

For creators, the content pipeline becomes much smoother. You bring the idea, and GPT-5 helps shape everything else around it.

How It Stands Out

Other models like Claude, Gemini, and Grok each have strengths. Claude is great at research. Gemini does well with visuals. Grok is strong on live social data.

GPT-5 is aiming to do all of it. One model, one interface, full capability, grow the most.

Final Thought

GPT-5 is not just another release. It's a shift in how we'll build, create, and work moving forward.

The question is no longer if it will change everything.

The real question is how fast you're ready to move.

5 Best New Features in .NET 9 & 10 That Every Developer Should Know

JKC — Thu, 12 Jun 2025 15:37:30 +0000

Introduction

I’ve worked with nearly every .NET version in real-world projects, and every major release brings something that either surprises me or genuinely boosts my productivity. With .NET 9 and .NET 10, Microsoft has really stepped up their game these aren’t just incremental updates, but feature drops that can change how you architect and ship your software. If you’re maintaining legacy APIs or jumping into greenfield cloud apps, there’s plenty to get excited about. Here’s a quick rundown of the five features that made me stop, dig in, and say “wow, this is going to save time.
Explore the official release notes:
.NET 9 What's New
.NET 10 What's New

1. Native AOT (Ahead-of-Time Compilation) for All App Types

One of the pain points I’ve run into especially with microservices or background tasks is startup lag and heavy memory usage. Native AOT changes the rules. Now, you can compile your .NET code straight to native binaries, meaning apps launch instantly, use less memory, and don’t drag the entire .NET runtime along for the ride. This is especially huge for anyone pushing containers or building serverless functions.

How to enable Native AOT in your project:

<PropertyGroup>
  <PublishAot>true</PublishAot>
</PropertyGroup>

Publish your app as a native executable:

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

2. Built-in OpenTelemetry and Observability

Tracing and monitoring used to mean fighting with extra NuGet packages or gluing together logging libraries. With .NET 9/10, OpenTelemetry is built right in. The first time I saw distributed tracing flow from ASP.NET Core through my data layer without much config, I was honestly relieved.

Benefits:

Automatic tracing and metrics
Easier integration with popular monitoring tools
Better visibility into distributed systems

3. C# 13: Primary Constructors and More

I’m a huge fan of anything that helps me write less boilerplate and keeps code clean. C# 13’s Primary Constructors for classes do exactly that. No more repetitive constructor assignments just declare your parameters once, and you’re set.

Here’s a quick example:

public class User(string name, string email)
{
    public string Name { get; } = name;
    public string Email { get; } = email;
}

Besides that, lambdas and pattern matching keep improving every release, and string interpolation is now both faster and safer. All these little changes add up and make daily coding genuinely nicer.

4. ASP.NET Core: Strongly Typed Minimal APIs with Source Generators

Minimal APIs were already a breath of fresh air for small services, but .NET 10 takes it up a notch. The new source generators make reflection mostly a thing of the past, and you get full type safety for your endpoints. It’s the sort of feature that makes refactoring APIs less nerve-wracking and really speeds up the "write it, test it, ship it" cycle.

Here’s how clear your endpoint code can look now:

app.MapPost("/users", (UserRequest request) => Results.Ok(request))
   .WithName("CreateUser");

Less magic, more compile-time safety, and no more second-guessing your routes.

5. Smarter Entity Framework Core: Bulk Operations & Performance

If you work with large datasets or ever had to write a manual loop just to update rows, this one’s for you. The new bulk operations like BulkUpdate and BulkDelete in EF Core have saved me from so much tedium and boosted performance in the process.

Here’s an example:

context.Users.Where(u => u.IsActive)
    .ExecuteUpdate(u => u.SetProperty(x => x.LastLogin, DateTime.UtcNow));

You can now update or delete hundreds or thousands of rows with a single, efficient query. I wish this existed a few projects ago!

Conclusion

I’ll be honest: I don’t adopt every new .NET feature right away, but .NET 9 and 10 have a lot of compelling reasons to upgrade. Native AOT and observability alone are enough to simplify deployment and maintenance, and the C# and EF Core upgrades make writing and maintaining code more enjoyable. If you’re looking for ways to build faster, cleaner, and more reliable apps, these releases are well worth your attention.

What new .NET feature are you most excited to try? Drop your thoughts below always happy to geek out about new tech!

Happy coding! 🚀

C# 12: Embracing the Quirks and Magic of Modern Programming

JKC — Sun, 30 Jul 2023 14:56:41 +0000

Introduction:

Welcome to the exciting world of C# 12, where modern programming meets a touch of magic and humor! In this blog, we will explore the latest features introduced in C# 12, from primary constructors to code sorcery. So fasten your seatbelts, and let's dive into the quirky wonders of C#!

Constructors: A Constructor Revolution

Constructors are the architects of object creation, and C# 12 brings a revolution with "Primary Constructors." Now, they are not just for record types; you can use them in any class or struct! Primary constructor parameters are in scope for the entire class, reducing boilerplate code. And remember to call the primary constructor from other constructors using "this()". Say goodbye to the mundane and welcome cleaner, more concise code!

// Primary constructor example
public class Person
{
    public string Name { get; }
    public int Age { get; }

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

Default Lambda Parameters: Embracing Laziness!

Lambdas are powerful, and C# 12 takes them a step further with "Default Lambda Parameters." Now, you can give your lambdas default values, just like regular methods. This lazy addition to lambdas simplifies your code without sacrificing functionality. Embrace the power of defaults and let your lambdas take it easy!

// Default Lambda Parameters
Func<int, int, int> addNumbers = (x, y = 10) => x + y;

// Usage
int result1 = addNumbers(5);      // result1 = 5 + 10 = 15
int result2 = addNumbers(5, 7);   // result2 = 5 + 7 = 12

Alias Any Type: The Language of Your Code

Aliases just got a significant upgrade! With "Alias Any Type," you can create semantic aliases for any type, not just named ones. Tuple types, array types, pointers - anything you want! Give your code a unique language of its own and let your creativity flow.

// Alias Any Type
using MyArray = int[];  // Alias for int array

public class Example
{
    public void UseAlias()
    {
        MyArray numbers = new MyArray { 1, 2, 3, 4, 5 };
        foreach (var num in numbers)
        {
            Console.WriteLine(num);
        }
    }
}

Inline Arrays: Compact and Speedy!

Inline arrays are here to supercharge your apps! They allow developers to create fixed-size arrays in struct types without the usual overhead. As a developer, you might not create them directly, but you'll enjoy their benefits through System.Span or System.ReadOnlySpan objects from runtime APIs. Get ready for compact and speedy performance!

[System.Runtime.CompilerServices.InlineArray(10)]
public struct Buffer
{
    private int _element0;
}

// Usage
var buffer = new Buffer();
for (int i = 0; i < 10; i++)
{
    buffer[i] = i;
}

foreach (var i in buffer)
{
    Console.WriteLine(i);
}

Interceptors: Unleashing Code Sorcery (Experimental)

Caution: Interceptors are experimental and not for production use.

Interceptors provide a glimpse into the world of code sorcery! This experimental feature allows you to declaratively substitute calls to interceptable methods with your custom logic at compile time. Think of it as a source generator's magic wand, modifying existing code rather than adding new code. But beware, with great power comes great responsibility!

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

// Interceptor method
[Interceptor(nameof(CustomAdd))]
public int InterceptedAdd(int a, int b)
{
    Console.WriteLine("Interceptor activated!");
    return CustomAdd(a, b);
}

// Usage
var calculator = new Calculator();
int result = calculator.Add(5, 7);   // The Interceptor will be invoked if enabled.

Conclusion:

Congratulations, adventurous programmers! You've now journeyed through the quirky world of C# 12, from primary constructors to code sorcery. Embrace these new features and let them infuse magic into your code. But remember, with great magic comes great responsibility! Enjoy exploring these innovative additions to C# and continue pushing the boundaries of your coding adventures. Happy coding, and may the quirks be with you!

Exploring the New Visual Studio Feature: .http Files

JKC — Mon, 05 Jun 2023 15:16:04 +0000

Introduction:

Visual Studio, the popular integrated development environment (IDE) by Microsoft, continually evolves to enhance developers' productivity and streamline their workflows. In the latest release, a new feature has been introduced: .http files. These files provide a convenient way to interact with HTTP APIs directly within Visual Studio. In this blog post, we will delve into the details of .http files, explore code examples in C#, discuss the system dynamic variables available, and highlight their similarity to the Visual Studio Code extension, "REST Client."

Understanding .http Files:

.HTTP files in Visual Studio act as a lightweight HTTP client, allowing developers to write and execute HTTP requests directly in the IDE. These files are inspired by the Visual Studio Code extension called "REST Client" and provide a similar experience within Visual Studio itself. They are designed to simplify the process of testing and debugging HTTP APIs.

Creating an .http File:

To create an .http file in Visual Studio, follow these steps:

Right-click on your project or desired location in the Solution Explorer.
Choose "Add" and then "New Item."
Select "Text File" from the available templates and name it with the .http extension.

Writing HTTP Requests in C#:

Let's explore some code examples to demonstrate how to use .http files effectively in Visual Studio using C#. Assume we have an API endpoint at "https://api.example.com/users" that returns a list of users in JSON format.

Sending a GET Request:

GET https://api.example.com/users

HTTP/1.1
Host: api.example.com

Sending a POST Request:

POST https://api.example.com/users

Content-Type: application/json

{
  "name": "John Doe",
  "email": "john.doe@example.com"
}

System Dynamic Variables in .http Files:

Visual Studio's .http files provide a set of system dynamic variables that you can utilize to enhance your HTTP requests. These variables simplify the process of including dynamic values in your requests, such as environment-specific URLs or authentication tokens.

Here are the system dynamic variables available in .http files:

{{guid}}: Generates a new GUID for each request.
{{randomInt}}: Generates a random integer for each request.
{{timestamp}}: Represents the current timestamp.
{{date}}: Represents the current date.
{{time}}: Represents the current time.
{{utcDate}}: Represents the current UTC date.
{{utcTime}}: Represents the current UTC time.
{{month}}: Represents the current month.
{{year}}: Represents the current year.
{{host}}: Represents the current host URL.

Example using system dynamic variables:

POST https://api.example.com/users

Content-Type: application/json

{
  "id": "{{guid}}",
  "name": "John Doe",
  "email": "john.doe@example.com"
}

###

GET https://api.example.com/logs?timestamp={{timestamp}}

###

Conclusion:

With the introduction of .http files in Visual Studio, developers now have a convenient way to interact with HTTP APIs directly within their IDE. These files provide a familiar and intuitive syntax, making it easier to test and debug APIs without leaving the development environment. By utilizing system dynamic variables, developers can enhance their HTTP requests and streamline their workflows further. .http files in Visual Studio resemble the functionality of the "REST Client" extension in Visual Studio Code, providing a seamless experience across platforms.

Start leveraging this powerful feature today and experience the productivity boost it offers!

Happy coding with Visual Studio and .http files!

(Note: The code examples provided in this blog are for demonstration purposes only. Actual implementation may vary depending on the specific HTTP API and requirements.)

Pattern Matching Enhancements in C# 9: Exploring New Patterns

JKC — Wed, 10 May 2023 15:07:45 +0000

As a C# developer, you're probably familiar with pattern matching. This feature allows you to test whether an expression matches a certain pattern and execute different code based on the result. In C# 9, Microsoft introduced several enhancements to pattern matching, including new patterns that make your code more concise and readable. In this blog post, I'll explore some of these new patterns and show you how to use them in your code.

Logical Patterns

The logical patterns and, or, and not allow you to combine patterns into more complex expressions. For example, suppose you have a method that takes an object and performs different actions depending on its type and value. Using logical patterns, you can define a single switch statement that handles all cases:

void ProcessObject(object obj)
{
    switch (obj)
    {
        case string s and ({ Length: > 0 } or null):
            Console.WriteLine($"The string is '{s ?? "null"}'");
            break;
        case int i and >= 0:
            Console.WriteLine($"The integer is {i}");
            break;
        case bool b:
            Console.WriteLine($"The boolean is {b}");
            break;
        default:
            Console.WriteLine("Unknown object");
            break;
    }
}

In this example, the first case uses the logical pattern and to test whether the object is a non-empty string or null. It also uses the property pattern to check that the string has a length greater than zero. The second case uses the relational pattern >= to test whether the object is a non-negative integer. The third case uses a simple type pattern to test whether the object is a boolean. Finally, the default case handles all other cases.

Relational Patterns

Relational patterns allow you to test whether an expression matches a certain relationship with a value. C# 9 introduces several new relational patterns, including >, <, >=, and <=. For example, suppose you have a method that takes a list of integers and prints the first number that is greater than 10:

void PrintFirstGreaterThan10(List<int> list)
{
    foreach (var i in list)
    {
        if (i is > 10)
        {
            Console.WriteLine($"The first number greater than 10 is {i}");
            return;
        }
    }

    Console.WriteLine("There are no numbers greater than 10");
}

In this example, the is operator is used with the relational pattern >. This pattern tests whether the value of i is greater than 10. If so, it prints the number and returns from the method. Otherwise, it continues to the next number. If there are no numbers greater than 10, the method prints a message indicating that.

Type Patterns

Type patterns allow you to test whether an expression is of a certain type and optionally bind it to a new variable. In C# 9, you can use the or pattern to test whether an expression is of one type or another. For example, suppose you have a method that takes an object and prints its type:

void PrintType(object obj)
{
    switch (obj)
    {
        case string s or int i:
            Console.WriteLine($"The type of the object is {obj.GetType().Name}");
            break;
        default:
            Console.WriteLine("Unknown type");
            break;
    }
}

In this example, the switch statement uses the or pattern to check whether the object is either a string or an int. If the object is a string or an int, the method prints its type. Otherwise, it prints "Unknown type".

Conclusion

Pattern matching is a powerful feature in C# that allows developers to write concise and readable code. C# 9 introduces new patterns, such as logical patterns, relational patterns, and type patterns, which enable even more flexibility in handling different cases in code. By using these patterns, you can simplify your code and make it more expressive.

Introducing C# 9.0's Record Datatype: Safe, Efficient, and Easy to Use

JKC — Fri, 14 Apr 2023 10:55:27 +0000

C# 9.0 introduces a new datatype called record, which is an immutable type that provides value-based equality. Records are ideal for representing data that is primarily for storage and retrieval. In this blog post, we'll explore the features and benefits of records, how to create them, and how they can be used in C# code through code examples.

Features and Benefits

The record datatype in C# has several features and benefits, including:

Immutability: Records are immutable, which means their values cannot be changed once they're created. This feature ensures records are safer to use because they can't be modified after they're created.

Value-Based Equality: Records provide value-based equality, which means that two records are equal if their values are equal. This feature makes it easy to compare records and determine if they're the same.

Built-In Deconstruction: Records have built-in deconstruction, which allows you to easily extract their values and assign them to variables. This feature makes it easy to work with records and use their values in your code.

Concise Syntax: The syntax for creating records is concise, making it easy to create and use them in your code. This feature saves time when writing code and makes it easier to work with records.

Creating Records

To create a record in C#, you use the record keyword followed by the name of the record and its properties. Here's an example:

public record Person(string FirstName, string LastName, int Age);

In this example, the Person record has three properties: FirstName, LastName, and Age. These properties are used to store the person's first name, last name, and age.

Using Records

Records can be used in many ways in C# code. Here are some examples:

Creating a list of records:

List<Person> people = new List<Person>()
{
    new Person("John", "Doe", 30),
    new Person("Jane", "Doe", 25)
};

In this example, we've created a list of Person records and added two records to the list. We've also specified the values for each property when we created the records.

Using records as function return types:

public record Person(string FirstName, string LastName, int Age);

public Person GetPerson()
{
    return new Person("John", "Doe", 30);
}

var person = GetPerson();

In this example, we've created a function that returns a Person record. We've then assigned the returned record to a variable, which can be used later in the code.

Deconstructing records:

var person = new Person("John", "Doe", 30);
var (firstName, lastName, age) = person;

In this example, we've created a Person record and then deconstructed it to extract its values. The values are then assigned to variables, which can be used later in the code.

Conclusion

In conclusion, the new record datatype in C# 9.0 is a powerful tool that can be used to store and retrieve data in a safe and efficient way. Its features, such as immutability, value-based equality, built-in deconstruction, and concise syntax, make it easy to use and save time when writing code. Records can help streamline code and improve its readability and maintainability. Whether you're working on a small project or a large-scale application, records can be a useful addition to your C# toolbox.

Simplify Your Debugging Process with Visual Studio Group Breakpoints

JKC — Thu, 06 Apr 2023 14:10:50 +0000

Visual Studio is a powerful integrated development environment that provides many useful tools for developers. One such tool is the Group Breakpoints feature, which allows you to set breakpoints for multiple lines of code at once. This can be especially useful when debugging complex applications that have many different code paths, or when debugging code that is spread out over multiple files.

To use Group Breakpoints in Visual Studio, follow these steps:

Open the code file that you want to debug.
Select the lines of code that you want to group together.
Right-click on the selected lines of code and choose "Breakpoint" from the context menu.
In the Breakpoint menu, select "Insert Group Breakpoint."

Once you have set a Group Breakpoint, Visual Studio will display a blue rectangle in the left margin of the code editor to indicate the location of the breakpoint. When the code reaches this breakpoint, the debugger will stop and allow you to inspect the state of the application.

Group Breakpoints can be especially useful when debugging code that is spread out over multiple files. For example, if you have a complex function that is defined in multiple files, you can select all the lines of code that make up the function, right-click, and choose "Insert Group Breakpoint." This will create a single breakpoint that covers all the lines of code for the function, making it easier to debug the code and find any errors.

Group Breakpoints can also be useful when debugging code that has multiple methods. Rather than setting individual breakpoints for each method, you can select all the lines of code for each method, right-click, and choose "Insert Group Breakpoint." This will create a single breakpoint that covers all the lines of code for each method, making it easier to debug multiple methods at once.

To remove a Group Breakpoint, simply right-click on the blue rectangle in the left margin and choose "Delete Group Breakpoint" from the context menu.

In conclusion, Group Breakpoints are a powerful tool for debugging complex applications in Visual Studio. They can help you save time and effort by allowing you to set breakpoints for multiple lines of code at once, making it easier to debug your code and find any errors. By following the steps outlined above, you can easily use Group Breakpoints to debug your own applications and streamline your development workflow.

A Better Way to Develop and Debug Applications

JKC — Wed, 05 Apr 2023 15:42:44 +0000

New Dev Tunnels in Visual Studio

Visual Studio is a popular integrated development environment (IDE) used by many developers to write and debug code. It has a wide range of features that can help streamline the development process, including a new feature called Dev Tunnels.

What are Dev Tunnels?

Dev Tunnels is a new feature in Visual Studio that enables developers to access their local development environment from remote devices, such as smartphones, tablets, or other computers. It creates a secure tunnel between the local machine and the remote device, allowing developers to test their applications in real-time without the need for additional hardware or software. Dev Tunnels work by using the ngrok service, which provides secure introspected tunnels to localhost.

Dev Tunnels allow developers to easily expose a local development web server to the internet without deploying the code to a remote server. This can be useful for testing web applications or sharing a development site with others.

How do Dev Tunnels work?

Here's how you can use the new Dev Tunnels feature in Visual Studio:

Open Visual Studio and create a new web application project or open an existing one.

Start the web application project by clicking the "Run" button or pressing "F5" on your keyboard.

Once the web application is running, go to the "Debug" menu and select "Start New Dev Tunnel".

In the "Start New Dev Tunnel" dialog box, select the web application project you want to expose and choose a port number to use.

Click the "Start" button to create the tunnel.

The Dev Tunnel will now be active, and you can access the local development server from any device with an internet connection by using the provided URL.

For example, if you chose port 5000 and the provided URL is "https://random-word-12345.loca.lt", you can access your local development server by typing "https://random-word-12345.loca.lt:5000" into your web browser.

Using Dev Tunnels can save you time and hassle by allowing you to test and share your web application without deploying it to a remote server. Give it a try and see how it can help streamline your development process!

In conclusion, Dev Tunnels is a new feature in Visual Studio that can help developers expose a local development web server to the internet without deploying the code to a remote server. It can be useful for testing web applications or sharing a development site with others. By following the steps above, you can easily use this new feature and improve your development workflow.