One-Two Punch

#

For anyone needing a recap, Microsoft called it quits on Windows 10 last Oct. They announced they’re done with features, bug fixes, and even security updates… sort of. They gave us the option to pay $30 (or buy a OneDrive subscription or redeem 1,000 magic MS points) for one additional year of updates. Companies could get updates for a few years, but the cost increases each year. They really want us off it.

Why would anyone want to pay though, instead of just upgrading to Windows 11? Especially when it was a free upgrade for quite awhile? Because we had no choice.

Microsoft drew some lines in the sand when they released Windows 11, requiring certain minimum hardware. I started with Windows 95, and upgrading has always meant a little more free space on your drive, a little more RAM, etc. That’s normal for any software upgrade. But for the first time, they’ve set some unusually stringent hardware requirements.

To install Win 11, a device needs a 64-bit system, a minimum level of processor, and a TPM chip. In my case, the PC has a space for the TPM on the motherboard, so I could get a chip, but it wouldn’t matter anyway because the CPU isn’t on their list of supported processors.

And so a lot of people are stuck, unable to continue with Windows 10 but unable to upgrade to Windows 11. That’s what the email above is about.. giving us more time before the inevitable. Because unless they change something about the min reqs, it’ll come down to a choice of:

• upgrading devices (expensive, if they even can be),
• trashing devices, and replacing with something newer (more expensive, esp during the RAMpocolypse),
• installing and learning a different OS (not a trivial thing, and not always practical)

Extended Extension?

#

So why are they extending their own extension another year, just a few months before they could wash their hands of Windows 10, at least for individual consumers? Good question. Thanks for asking it. I have no idea.. maybe it’s just out of the kindness of their collective hearts?

Looking at the data from StatCounter though, over a quarter of all Windows users are still on Windows 10! That’s a lot, considering it’s been 9 months since they flagged it EOL.

Source: StatCounter Global Stats - Windows Version Market Share

I wonder if they’re worried about just how many of those users (millions? tens of millions?) will actually upgrade their computer (at a time when the AI craze has driven memory and disks prices wayyy up) and then buy a Windows 11 license on top of it? I bet more than a few will just stick with (or move to) a Chromebook, iPad or other tablet, etc.

Combine that with smaller businesses that can’t afford to upgrade/replace all their old computers just to upgrade to Win 11, and MS may stand to lose a lot of revenue (and good will), now and in the future.

Or maybe they’re concerned that if they pull the plug in Oct, a lot of people will just.. do nothing. Many of them will be fine for quite awhile, while some others will get hit with malware and everything else that comes from no more security updates. And when those users recover, they may just say screw it to Windows and go with something else.

Or maybe they’re worried about litigation, or major consumer pushback, or politicians getting involved come the October deadline? And keeping the pipeline open that pushes security updates is easier than facing something they see coming? Who knows.

As for me, I still don’t know what I’ll do. I need the PC because our family shares it for schoolwork, gaming, taxes, etc. It works for us, and it’s cheaper and more maintainable than having multiple machines. I can’t abandon it because the software we use runs on Windows and requires the power of a desktop. I’m hoping I can upgrade what needs upgrading, and keep the rest (the box, cooling system, graphics card, etc).

We’ll see.

What about you? If you’re in the same boat, what will you do?

I had some fun doing that, so I decided to check out a few more archived games to see what Copilot could make of them again. It did surprisingly well…

Battleship

#

First up, a battleship game courtesy of Jason Hotchkiss, who shared it on Dec 15, 1999. It works as-is in chromium-based browsers, which is kind of amazing. It wasn’t using anything that modern browsers prohibit, but there’s plenty that’s been deprecated.

Document.write

#

The biggest issue was the use of document.write to update the DOM, which almost all of these games did, and which MDN strongly discourages nowadays. Like using eval or unparameterized SQL queries, it’s a potential security hole. Imagine a commenting system that uses document.write, and then someone posts a comment containing javascript code that’s naively stored as-is and then loaded (unseen) for every future visitor to the page. 😬

The way the game used it was pretty harmless since it didn’t involve user input. It created an img for each cell in a 16x16 grid, made them clickable by nesting each in an a element, and then wrote them to the DOM. Copilot replaced it with calls to document.createElement and appendChild, and used addEventListener instead of hyperlinks.

Classes and modules

#

Copilot did some nice cleanup too, moving arrays of data representing ships, ship types, etc into constants. It also moved most of the code into a “Battleship” class, moving variable initialization into the constructor.

It’s nice to see things can be encapsulated this way, so every variable isn’t globally defined. Plus the layout looks a lot more familiar to this C# dev.

BR tag vs CSS grids

#

The legacy code created each “board” (for the player and computer) by document.writing 16 img elements, then writing a <BR> tag, rinse and repeat for 16 rows. Copilot refactored it to create and add 256 img elements to each grid, using CSS to wrap them into the correct shape. Nice.

grid-template-columns: repeat(16, 16px);
grid-auto-rows: 16px;

Check out the code here: LegacyJSBattleship · grantwinney/BlogCodeSamples

Breakout

#

Next on our tour of ancient JS games, we have Breakout, uploaded by Nick Young in April 2000. Breakout is a much simpler predecessor of Arkanoid that came out 50 years ago. No powerups or anything special here.. it’s just you, a ball, and 40 blocks. Ah, those were simpler times.

Unlike the Battleship one that worked well without any changes, this one didn’t work at all. After a little playing around, it’s because it used proprietary IE elements. Replacing all the .posTop and .posLeft properties with .top and .left gets things moving. Oddly, in some places he used the non-proprietary names as well. Ah, those were complicated times.

So let’s see what Copilot did with this one.

Canvas

#

The original script had 50 lines using document.write to position 40 separate tables all using position:absolute, along with some messages and buttons and various text fields. Yikes.

Copilot replaced it with the Canvas API, so it could loop through the same code 40 times to draw the rectangles, along with the ball, paddle, timer, and whatever else it needed. The canvas has a lot of flexibility, so Copilot moved everything inside it, eliminating the need for buttons and text fields that lived outside the playing area.

Elapsed Time

#

The original code used setTimeout to make the main loop of the program call itself every 100 ms, or 10x times a second. On each call, it incremented a timer variable, so that it also went up in value 10 per second. Then some other logic divided the timer value by 10 and displayed it. The end result was that the onscreen gameplay time looked like it was just a clock, increasing once per second, but it was a little more complicated and less reliable.

Copilot’s new code uses Canvas and calls requestAnimationFrame, which means the main loop is now executing 60x a second, the variable increments 60 a second, and the gameplay timer increases 6 every second. In other words, way too fast. To be fair, the original code had a “fast” mode that reduced the 100ms call to 10ms, and in that case the timer would increase 10 every second, so it wasn’t great either.

After some nudging, Copilot fixed it by using the timestamp that requestAnimationFrame sends to whatever function you pass it. It saved the first timestamp as the “game start” time, computing a delta for each subsequent call to the main loop, adding that delta to the original time and doing some quick math to get the number of seconds. Neat. And completely overengineered.

My solution was to store Date.now() when a new game starts, and then just compare it to the current time each time the canvas updates, replacing its 30 line suggestion with just 2 lines:

this.startTime = Date.now();

`Time: ${Math.floor((Date.now() - this.startTime) / 1000)}`

It’s a good reminder that although these LLM tools are good at finding a solution, it’s not always the best solution!

Check out the code here: LegacyJSBreakout · grantwinney/BlogCodeSamples

Concentration

#

Let’s check out one more, a simple matching game called Concentration, uploaded by Brian Gosselin in June 2000.

Nothing all that new from Copilot. It replaced all the document.write calls again, and replaced some of the same stuff as the other games, so I’ll focus on something else interesting I noticed.

Accessing elements directly by name??

#

The original code assigned a name to a few elements, like the form and button, which is still valid, but also to img elements it created, which is not valid. That’s not surprising, it’s old code right? I’m not great with today’s JS, let alone what passed for valid 25 years ago.

<form name="f">

document.write('<img src="image0.gif" name="img'+((6*r)+c)+'" border="0">');

<input type="button" value="         " name="b" onClick="init()">

But there’s also code that accesses the elements directly by their name, which I had no idea was ever possible. Interesting. Copilot replaced them with document.getElementById.

document.f.b.value = ""; // clearing the timer text from the button
document.f.b.value = min + ":" + sec; // setting the timer text on the button
document.f[('img' + i)].src = "image0.gif"; // accessing the images in the form

Trying to find info on the above code sent me down a rabbit hole, where I learned that you can actually still access elements directly by their ID. Um, what? All I’ve ever heard about is using document.getElementByID, but doing something like this totally works:

<div id ="myDiv">initial value</div>

someButton.addEventListener("click", () => { myDiv.innerHTML = 'new value'; });

According to this thread, it’s not only allowed but actually standards compliant. Yuck. It seems it’s only in there for backwards compatibility though, and generally discouraged.

Enough of that.. here’s code for the last one: LegacyJSConcentration · grantwinney/BlogCodeSamples

It looks straight out of the 90s (which it is), and it reminds me of what was fun about the web back then. Not singularly focused, not SEO optimized, not riddled with ads showing gross toenails.. just someone sharing their hobbies and interests with whoever happens by. Most sites like these were abandoned a long time ago, or were the victim of shuttered services, or were reworked and the old content deleted.

What’s so unique about this site is that it’s still actively being updated. Things from 30 years ago are still there, and then there’s new recipe posts from just a month ago. It looks like a labor of love if I ever saw one.

In an era when most roads now lead to the same few large sites (social media, forums, youtube), and nearly everyone’s feeding the google monster, this feels like a unicorn. It’s pleasant to find someone simply writing and sharing for the sake of writing and sharing. If you lived through the dawn of home internet right around the turn of the century (ugh I feel old), you know what I’m talking about. Don’t get me wrong, there was a lot of garbage that no one will miss, but there was a lot of good too.

The author has a page full of bookmarks, including one for an archived copy of a maze someone uploaded to a site called The JavaScript Source. The original author of this maze script was Jason Hotchkiss, who uploaded it back in 1999. Just a few weeks before Y2K hit and the world didn’t end. 😏

Although the script was guaranteed to work in IE5 and Netscape (never a given back then!), it doesn’t work in Chromium-based browsers. Not a shock. What is shocking is that it works as-is in Firefox.. gotta love Mozilla for their backward-compatibility! I thought it’d be fun to bring it back to life, although I wasn’t sure how bad it’d be. The fact that it’s working Firefox is promising.

As it turns out, it didn’t take much of anything. I plugged it into MS Copilot, which quickly identified why it was failing (mainly the use of Netscape’s document.layers object) and then rewrote it for me. Amazingly, I had to fix nothing, although I couldn’t resist adding in a couple things of my own.

Here it is, in all its ASCII glory. You can press the buttons (duh) or click on the maze to give it focus and then use WASD or the arrows to move around.

If you got this far, there’s not really any “point” to this post, but maybe that was the point. Here’s the code if you want to mess around with it.

It’s interesting to me, stumbling onto code that someone put time into making, only for it to be nearly lost to the shifting sands of the internet. And it happens all the time, every day.

When eBay went down the other day (it’s gone down a few times recently), the page periodically threw out errors like this one when I tried to visit it:

An error occurred while processing your request. Reference #97.ec4f4317.1777321399.42065ab https://errors.edgesuite.net/97.ec4f4317.1777321399.42065ab

Nothing else in the DOM, nothing in the console except that the server got a 504 gateway error. Strange to not just have a page saying “we’ll be back shortly” or “please stop DDOS’ing us thx” instead of whatever this cryptic error message is.

The only thing to go on was the link, which begged clicking, so one click later…

Hm, a little more to go on. Clearly a page only useful to whoever the customer is, not the tens of thousands of random people who saw it while trying to buy an item.

One quick visit to a whois site tells us exactly who owns this service, and I’m kinda not shocked this is the experience when something goes down. Some years back I discovered Akamai is the reason many sites request access to motion sensors, which is kind of a weird thing to see in your address bar on the desktop. I can’t speak to their effectiveness since I’ve never used them personally, but they don’t seem to bother with hiding their presence.

And if there’s any doubt, the Translate Error String mentioned in the error is documented on Akamai’s site. It just takes the cryptic id and returns the error message and logs. At least they don’t display the actual logs right on the page for everyone to see, but it’s still odd.

This seems to be part of their Web Application Firewall and fwiw they’re not the only provider that behaves (to me) unexpectedly. I’ve had a number of sites toss up weird Cloudflare “are you a human” pages that honestly make it look like the site got hacked. Rather ugly pages that don’t fit the site’s theme at all. I wonder why they don’t polish the experience a bit? Do the companies that use them not realize, or just not care?

I spent a few hours this weekend cleaning up, commenting, and bug-fixing a browser addon I created quite a few years ago. I rarely touch it more than once a year or so, which is good since uploading new versions is a multi-step process involving an “approval” that has questionable value. But I digress…

Better code reuse with ES modules

#

Keeping a codebase DRY is something every dev should strive for, as much as possible. If the same code is copied several times, then they all need to be updated every time there’s a change. At some point, they’ll start to diverge as one gets updated and the others don’t, until nothing’s quite the same anymore. No es bueno.

I had some duplicate code though, because I couldn’t figure out how to reference it from all the various parts of the addon, but I fixed that and learned a few things in the process.

Calling ES modules from a service worker

#

Background service workers can be specified as ES modules in the manifest.json file, which allows them to import code from other files, simply by adding a “type”:

"background": {
    "service_worker": "js/bg-service-worker.js",
    "type": "module"
},

After that, add export to the front of any “shared” functions:

export function log(message, isError = false) {
    if (isError) {
        console.error(`[${chrome.runtime.getManifest().name}]: ${message}`);
    } else {
        console.info(`[${chrome.runtime.getManifest().name}]: ${message}`);
    }
}

And import them into the service worker:

import * as utils from './shared-utils.js';

chrome.runtime.onMessage.addListener(function (message, sender, sendResponse) {
    if (message.event !== 'comments_hidden' && message.event !== 'comments_shown') {
        utils.log(`background script not configured to run for message event: '${message.event}'`);
        return;
    }
    ...
    ...
}

I didn’t need to do this, but it’s a nice thing to learn about, that JS code can be organized and encapsulated in a way that seems similar to other languages. Reminds me of Python.

Calling ES modules from a content script

#

The context for a background service worker is outside of any individual tab, and the code above works for those. Annoyingly, content scripts, which run inside of individual tabs, don’t play nicely with ES modules. That was a big reason I had duplicate code.

But then I came across a post from 2018 where user otiai10 suggested using a dynamic import(). From the MDN page, this sounds like exactly what I needed to load an ES module from vanilla JS.

The import() syntax, commonly called dynamic import, is a function-like expression that allows loading an ECMAScript module asynchronously and dynamically into a potentially non-module environment.

To get it to work, I just had to take the entry point code in the content script that’s called whenever the content script loads:

chrome.runtime.onMessage.addListener(function (message, _sender, _sendResponse) {
    switch (message.event) {
        case 'update_tab':
            adjustCommentsVisibility();
            break;
        case 'toggle_tab':
            toggleCommentVisibility()
            break;
        default:
            log(`content script received unexpected event: ${message.event}`, true);
    }
});

insertStylesIntoPage();

And put it in an exported function (which I named “main”):

export function main() {
    chrome.runtime.onMessage.addListener(function (message, _sender, _sendResponse) {
        switch (message.event) {
            case 'update_tab':
                adjustCommentsVisibility();
                break;
            case 'toggle_tab':
                toggleCommentVisibility()
                break;
            default:
                utils.log(`content script received unexpected event: ${message.event}`, true);
        }
    });

    insertStylesIntoPage();

Then create a new content script, whose sole purpose is to call the exported main function in the file that was previously the content script:

(async () => {
  const src = chrome.runtime.getURL('js/content-main.js');
  const contentScript = await import(src);
  contentScript.main();
})();

And finally, declare the imported script in the “manifest.json” file as a web-accessible resource. I’m not sure I had to add “js/shared-utils.js” actually, but it doesn’t seem to hurt anything. Might not be necessary though.

"content_scripts": [
    {
        "matches": ["<all_urls>"],
        "js": ["js/content-script.js"],
        "run_at": "document_start"
    }
],
"web_accessible_resources": [{
    "matches": ["<all_urls>"],
    "resources": [
        "js/shared-utils.js",
        "js/content-main.js"
    ]
}],

Better file change detection with etag headers

#

When I started this addon, I created two separate JSON files that it checks on a regular basis. One has a list of all the CSS elements to block for each website, but the other had only a single value - a version number. Both are cached in storage.local and checked daily. Every time I modified the list of CSS elements, I also bumped the version number in the other file.

My thinking was that updates are fairly rare, and downloading a small JSON file with a version number in it, and then comparing that before downloading the larger file, was better. A tiny optimization, but why not. The caveat was that if I forgot to bump the version, then whatever changes I made to the other file would go unnoticed. The addon wouldn’t grab them if the version number didn’t change.

And then I read about the If-None-Match and If-Modified-Since headers, which is much better. My thinking was correct, but my approach reinvented the wheel. You can read more here, but if a server supports the etag header, then:

• Requesting data can also return a unique hash code representing that data, which can be cached.
• Subsequent requests using that cached value cause a 304 Not Modified response if the data hasn’t changed.
• If the data has changed, the request returns a 200 with the data, and a new hash code to cache.
• GitHub supports the etag header from api.github.com, and after a little testing, it supports it when requesting files from raw.githubusercontent.com too.

So a block of code like the one I use in the addon makes a request and passes the etag value. If the data hasn’t changed, it’ll get only a 304; otherwise, it receives a 200 and caches the updated CSS elements.

const eTagData = await chrome.storage.local.get('etag');
const eTag = eTagData.etag;
const response = await fetch(SITES_JSON, {
    headers: eTag  ? { 'If-None-Match': eTag  } : {}
});
if (response.status === 304) { /* Not modified since last check, so no need to update local definitions */
    await chrome.storage.local.set({ 'definition_version_last_check': getCurrentSeconds() });
    if (notUpdatedAction) {
        notUpdatedAction();
    }
} else if (response.status === 200) { /* Updated definitions retrieved successfully */
    await chrome.storage.local.set({ 'definition_version_last_check': getCurrentSeconds() });
    let newEtag = response.headers.get("ETag");
    if (newEtag) {
        await chrome.storage.local.set({ 'etag': newEtag });
        let data = await response.json();
        await chrome.storage.local.set({ 'global_definitions': JSON.stringify(data) });
        if (updatedAction) {
            updatedAction();
        }
    }
} else {
    log(`Unable to retrieve the latest definitions: (${response.status}) ${response.statusText}`, true);
}

That’s better than what I had before, since it only requires a single request no matter what. The server determines whether it sends the data back with a 200, or just sends a 304 response.

Better comments with JSDoc

#

I have a lot of comments in the addon, all using the // symbol. After reading up on JSDoc, I updated quite a few of them (but not nearly all yet) to use the JSDoc syntax. I’m not running any tool over the codebase to create documentation or anything.. what I really wanted was to get tooltips in VSCode to make life a little easier when I’m updating the code, and VSCode can use the JSDoc comments to do that.

As a bonus, it forces me to think about what each parameter does, and what the type is that the function expects.

/**
 * Check if the addon can run for a given URL based on its protocol.
 * 
 * @param {URL} tabUrl - The URL for which to check the protocol.
 * @returns {boolean} - True if the current URL is supported; otherwise false.
 */
export function isCurrentUrlSupported(tabUrl) {
    return !INVALID_PROTOCOLS.some(p => tabUrl.protocol.startsWith(p))
        && !INVALID_SITES.some(p => tabUrl.hostname.startsWith(p));
}

I’ll probably get around to updating the other comments too, at some point, and switching out all my .then promise types of calls to be async/await (there’s some heavily nested chunks of code that are kinda ugly), but right now the addon works well and after spending a weekend updating it I think I’m good to shelve it again for awhile!

My first thought was it’s a bug, but a Microsoft program manager confirmed it’s intentional:

The change in naming and shortcut launch behavior is intentional. Opening the “Visual Studio” shortcut will launch Visual Studio 2026, and that will be the primary way to start the IDE moving forward.

It’s part of a bigger redesign for Visual Studio, which will release a new version every year, each one replacing the previous one. That’s right.. replacing. When asked if new versions would be side-by-side (as they’ve always been) or an upgrade, another program manager confirmed it’s the latter:

[T]he next major version of VS (2027) will be an inline upgrade and not a side-by-side install.

The rest of this post is derived from official blog posts as well as release, support and other documentation for VS 2026. Check out these original posts for all the details:

• Visual Studio 2026 is here: faster, smarter, and a hit with early adopters
• Spend Less Time Upgrading, More Time Coding in Visual Studio 2026
• Visual Studio – Built for the Speed of Modern Development
• Visual Studio Channels and Release Rhythm | Microsoft Learn
• Visual Studio Product Lifecycle and Servicing | Microsoft Learn
• Decoupling the .NET SDK and Visual Studio · dotnet/sdk

What are they changing?

#

Starting with VS 2026:

• Every November means a new version of Visual Studio (2026, 2027, etc), which will overwrite the previous one. No side-by-side installs.
  • Community users must upgrade to continue getting updates.
  • Pro and Enterprise users can hold off for a bit, but eventually need to update too.
• Updates are monthly, instead of quarterly, as long as the latest release is installed.
• The shortcut won’t have a version/year number in it anymore.

Why are they changing it?

#

They want to be able to update Visual Studio faster, but the IDE (for writing code) has always been tightly coupled with other related tools, as evidenced by the .NET SDK, MSBuild, and Visual Studio versioning page. I can easily imagine how separate but related parts being bundled into a single app would slow down overall development. Any dev who’s worked with legacy WinForms apps knows what monolithic looks like.

If they update the build tools, but need the old tools to still work and be available, then they have to release a new Visual Studio version too, since everything’s bundled. If they also have major updates for Visual Studio, it’d make sense to wait until that new version is being released to include them, but that means delaying new features that we could’ve benefitted from sooner. Everything has to line up and play nice, and a delay in one area or from one team prevents everything from shipping.

Beyond that, it sounds like they want out of the business of supporting old versions for a decade, too. VS 2015 just went out of support a few months ago, 2017 is supported until next year, and 2019 and 2022 will be supported for years to come. That’s a lot to juggle.

How are they changing it?

#

They decoupled the Visual Studio IDE from the build tools, so they can be developed and released separately. I imagine that the IDE, being guaranteed to have access to certain tools that were bundled with the install, was probably a bit of a nightmare to disentangle from everything else.

Since the IDE won’t be bundled with a particular set of build tools anymore, it uses a new Setup Assistant tool that determines what an app needs and can retrieve missing dependencies. I haven’t used it yet, but I assume it looks at the sln/slnx and csproj files.

What’s not changing?

#

VS 2022 (and earlier) will continue to run side-by-side with 2026 (and later), although they’re claiming all projects and extensions that worked in 2022 will work as-is with nothing else needed in 2026.

They’re not changing the lifecycle for old versions, but each version going forward will only receive full support for the year it’s released, then it has to be upgraded.

Some concerns…

#

I hope it goes as great as they say it will, but I can imagine how it might not…

Discoverability

#

Right now, VS 2026 can’t be quickly found in the start menu. Typing “Visual Studio 2026” shows nothing, and typing “Visual Studio” shows every version of VS that’s installed (and VS Code). Maybe eventually as the older versions become unnecessary this won’t be an issue, but for now it’s annoying.

As Dave noted in the comments below, the context menu item in File Explorer has the same issue.

It shows up as 2026 in the Visual Studio Installer app and on the splash screen. Why not just show the shortcut and menu item like that too, and then replace them with “Visual Studio 2027” in November? Why make these parts generic and nothing else?

Ironically, this seems to fly in the face of what was said when VS 2022 was released:

From a basic wayfinding perspective, distinguishing updates to the look and feel and packaging of a new product make it easier for you to know when you’re using the new product versus other versions you may have running at the same time.

Legacy Apps

#

VS 2022 is a 64-bit app with a 64-bit WinForms designer. Because of that, older 32-bit WinForms apps can’t be designed in 2022. Microsoft’s suggestion is the obvious one - upgrade apps to 64-bit. But I’ve worked on decades-old apps with a hundred projects - upgrading is a large undertaking that’s tough for the devs and a tough sell to management. Not great, but that’s the way it is. They created an out of process designer that helped but had caveats, and I’m not sure how much further they can/will take it. The solution for most teams, I’m guessing, is to keep using VS 2019.

I don’t know what else might happen to Visual Studio that would have an impact like this, but what if it does? What’s the recourse for companies who paid for Visual Studio, developed an app, and can’t afford to overhaul it to appease a new Visual Studio version? I’d like to think there’d be a reasonable workaround, but Microsoft has shown us with Windows 11 that’s it’s not afraid to just leave us in the dust. Then again, they’re still supporting .NET Framework 4.6 for another year and haven’t even placed EOL dates on 4.7 and 4.8. Still, I wouldn’t be shocked if they told everyone to update their legacy apps or find a different way to keep developing them.

Usability

#

Microsoft has made poor design changes in the past, bad enough to make devs want to skip a version. Anyone here remember VS 2012? For reference, here’s VS 2005, 2010, and 2015, with a normal color palette, UI, and menus:

And here’s 2012, which tossed out those distracting colors, space-wasting borders, and sheepish menus. I WANT MENUS THAT SCREAM AT ME.

There was so much pushback, they added a regex key to revert the menus, and then reverted everything in 2015. I kept using 2010 for most things, but going forward that wouldn’t be an option. If some design guru decides VS 2027 (or 2028, or 2029) needs a UI overhaul, then we’re stuck with it.

Reading about the changes, and thinking about it all, it sounds like a really good thing. I’ll be cautiously optimistic, and hope that the team not having to support 4-5 separate versions of Visual Studio means we get more innovations faster.

Null Conditional (a review)

#

When we’re dealing with nested classes, like the one below for example, we usually have to be really defensive to avoid the dreaded NullReferenceException.

public class Company
{
    public string Name { get; set; }
    public IList<Department> Departments { get; set; }
}

public class Department
{
    public string Name { get; set; }
    public IList<Employee> Employees { get; set; } = new List<Employee>();
}

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

That means checking for null repeatedly when referencing, say, an employee’s name. And since collections are involved, we need to check to make sure they have valid values too. If we just wanted to get the first employee from the first department, we might do something like this:

// Getting employee name traditionally
if (company != null &&
    company.Departments != null && company.Departments.Count > 0 &&
    company.Departments[0].Employees != null &&
    company.Departments[0].Employees.Count > 0 &&
    company.Departments[0].Employees[0].Name != null)
{
    var employeeName = company.Departments[0].Employees[0].Name;
    Console.WriteLine($"Employee Name: {employeeName}");
}
else
{
    Console.WriteLine("Employee Name: N/A");
}

What the null conditional operators let us do is shorten the above to just this:

// Getting employee name using null-conditional operators
var employeeName = company?.Departments?[0]?.Employees?[0]?.Name ?? "N/A";
Console.WriteLine($"Employee Name: {employeeName}");

At every step along the way, it checks whether it can skip the rest (short-circuit), and just set employeeName == "N/A":

• If org == null, then it skips everything else and sets employee name to “N/A”.
• If org.Departments == null, it skips the rest and moves on.
• If org?.Departments[0] == null for some weird reason, it skips the rest.
• And on and on, with .Employees, then .Employees[0], etc.

Getting a nested value involves a lot less code, which is great.

Null Conditional Assignment

#

What the null conditional operator hasn’t helped us shorten in the past, though, is setting a value. If any part of the nested objects is null we’ll get an exception, so we have to be careful:

// Setting employee name traditionally
if (company != null &&
    company.Departments != null && company.Departments.Count > 0 &&
    company.Departments[0].Employees != null &&
    company.Departments[0].Employees.Count > 0 &&
    company.Departments[0].Employees[0].Name != null)
{
    company.Departments[0].Employees[0].Name = "John Doe";
}

However, with the update in C# 14 that allows using the null conditional operator when assigning a value, we can use the same short-circuiting code here too:

// Setting employee name using null-conditional operators
company?.Departments?[0]?.Employees?[0]?.Name = "John Doe";

Combined with a feature we got in C# 8, to use the null-coalescing operator ??= during assignment, we can also quickly make sure that existing values aren’t accidentally overwritten:

// Setting employee name using null-conditional and null-coalescing operators
company?.Departments?[0]?.Employees?[0]?.Name ??= "John Doe";

It could even be used with LINQ when searching through nested collections, to handle the case where whatever we’re searching for isn’t found:

private void ActivateEmployee(Company company, string dept, string name)
{
    // Activate employee, using null-conditional assignment operator
    company
        ?.Departments.SingleOrDefault(d => d.Name == "Sales")
        ?.Employees.SingleOrDefault(e => e.Name == "Greg Smith")
        ?.Active = true;
}

Thoughts

#

I like that the feature works on both sides of the assignment operator now, which is more consistent. I haven’t used it in a prod environment yet (since it’s brand new), but it definitely seems like it’ll make things more readable … once I’m used to reading it!

In some cases though, the (older) more verbose way could be more readable, and I think readability is really important, especially when multiple devs are working in an app. Heck, when I set an app down and pick it up a year later, I might as well be a different dev for all I remember about it, lol. All-in-all though, it’s a nice addition to the language!

Learn More

#

• Null-conditional operators - ?. and ?[]
• Null-coalescing operators - ?? and ??=
• Null-conditional assignment - What’s new in C# 14
• Null conditional assignment - C# feature specifications | Microsoft Learn

Extension Methods (a review)

#

For a long time, we’ve had the ability to extend a class with extension methods, making it seem like the original class has methods on it that it doesn’t. For example, here’s a class with three methods that act on strings:

public static class BlogStringHelpers
{
    // Truncate post for summary, as for use in social media.
    public static string ToExcerpt(this string str, int maxLength = 128) =>
        str.Length <= maxLength ? str : $"{str[..maxLength]}...";

    // Convert string to a slug to use as identifier for post.
    public static string ToSlug(this string str) =>
        Regex.Replace(str.Trim().ToLower(), @"\s+", "-");

    // Convert string to Title Case to use as title for post.
    public static string ToTitleCase(this string str)
    {
        var words = str.Split(' ', StringSplitOptions.RemoveEmptyEntries);
        for (int i = 0; i < words.Length; i++)
        {
            var w = words[i];
            words[i] = char.ToUpper(w[0]) + w.Substring(1, w.Length - 1);
        }
        return string.Join(' ', words);
    }
}

And here’s a few examples using the above methods:

var post = "Here we go again, with another .NET release.";
var excerpt = post.ToExcerpt(10);  // "Here we go..."

var str = "using new extension members";
var slug = str.ToSlug();           // "using-new-extension-members"
var title = str.ToTitleCase();     // "Using New Extension Members"

The first parameter to any extension method is an instance of whatever class is being “extended” (i.e. this string str above), so there’s no such thing as methods that extend a class without needing an instance. Until now…

Extension Members

#

Instance Methods

#

To convert the above to use the new extension members feature:

1. Remove this string str from each method,
2. Nest everything inside an extension block that defines str as the extension (aka receiver) parameter, and
3. Remove static from everything except the class definition.

The string str variable is then available to all of the (instance) methods defined inside the curly braces of the extension block:

public static class BlogStringHelpers
{
    extension(string str)
    {
        // Truncate post for summary, as for use in social media.
        public string ToExcerpt(int maxLength = 128) =>
            str.Length <= maxLength ? str : $"{str[..maxLength]}...";

        // Convert string to a slug to use as identifier for post.
        public string ToSlug() =>
            Regex.Replace(str.Trim().ToLower(), @"\s+", "-");

        // Convert string to Title Case to use as title for post.
        public string ToTitleCase()
        {
            var words = str.Split(' ', StringSplitOptions.RemoveEmptyEntries);
            for (int i = 0; i < words.Length; i++)
            {
                var w = words[i];
                words[i] = char.ToUpper(w[0]) + w.Substring(1, w.Length - 1);
            }
            return string.Join(' ', words);
        }
    }
}

The output of the above members is the same as the extension methods, but let’s take a look at what else we can do that we couldn’t do before.

Instance Properties

#

Aside from instance methods (like above), we can also define instance properties:

public static class BlogStringHelpers
{
    extension(string str)
    {
        public bool IsTitleTooLong => str.Length > 100;

        public bool IsTitleAlphanumeric =>
            str.All(c => char.IsLetterOrDigit(c) || char.IsWhiteSpace(c));
    }

Calling them is as straightforward as calling the methods:

var str = "Introducing C# 14"
var isTooLong = str.IsTitleTooLong;             // false
var isTitleAlphaNum = str.IsTitleAlphanumeric;  // false

This works because the instance of whatever type we’re extending is defined in the extension container and available to the properties. Let’s see what else we can do.

Static Methods and Properties

#

We can also define static methods and properties, to extend a type without requiring a particular instance of it. This is something we couldn’t do with extension methods, as the first parameter was always the instance itself.

All that’s needed in the extension block container is the type we’re extending, in this case the DateTime struct. It already has Today, of course, but what if I wrote an app that needed to use yesterday’s date in a bunch of places? Might be convenient to effectively add that to DateTime:

public static class DateTimeHelpers
{
    extension(DateTime)
    {
        public static DateTime Yesterday => DateTime.UtcNow.AddDays(-1);
        public static DateTime Tomorrow => DateTime.UtcNow.AddDays(1);

        public static string Weekday => DateTime.UtcNow.DayOfWeek.ToString();

        public static bool IsTodayTomorrow => false;

        public static string GetDailyHoroscope()
            => "Carp diem.. seize the fish! Or is it fish the day? 🐟";
    }
}

All of these static properties and methods can be called as if they’re part of DateTime and, unlike the older extension methods, we don’t need to have an instance of a date first.

Console.WriteLine(DateTime.Yesterday);            // 12/1/2025 4:22:06 PM
Console.WriteLine(DateTime.Tomorrow);             // 12/3/2025 4:22:06 PM
Console.WriteLine(DateTime.Weekday);              // Tuesday
Console.WriteLine(DateTime.IsTodayTomorrow);      // False
Console.WriteLine(DateTime.GetDailyHoroscope());  // Carp diem.. seize the fish! Or is it fish the day? 🐟

Operators

#

We can also define operators. For example, the DateTime struct already defines a few operators for manipulating dates, but what if we wanted to add a new one to add days to a given date?

public static DateTime operator +(DateTime d, TimeSpan t)
public static DateTime operator -(DateTime d, TimeSpan t)
public static TimeSpan operator -(DateTime d1, DateTime d2)

We could define a new operator that takes days instead of a TimeSpan, like this:

public static class DateTimeHelpers
{
    extension(DateTime)
    {
        public static DateTime operator +(DateTime dt, int days)
            => dt.AddDays(days);
    }
}

var added = DateTime.Now + 5;  // 12/7/2025 12:55:29 PM

Of course, I wouldn’t recommend using this exact code, since it’s not obvious whether 5 represents days, years, or something else, but the point is that you can do things like this if you have a use for them!

Everything All At Once

#

Finally, we can also define extension methods in the same class with extension members, as well as other things. Here’s a class that’s doing bits of everything we talked about above and more:

public static class DateTimeHelpers
{
    public static readonly DateTime Yesterday;

    // Static Constructor, because why not..
    static DateTimeHelpers()
    {
        Yesterday = DateTime.Yesterday;
    }

    // Simple Method
    public static string GetStats()
    {
        var i = typeof(DateTimeHelpers).GetMethods(
            BindingFlags.Static | BindingFlags.Public).Length;
        return $"{nameof(DateTimeHelpers)} has {i} properties.";
    }

    // Extension Method
    public static int GetPreviousLeapYear(this DateTime dt) =>
        Enumerable.Range(dt.Year - 4, 4).Single(DateTime.IsLeapYear);

    // Extension Members
    extension(DateTime dt)
    {
        // Static Method
        public static string GetDailyHoroscope()
            => "Carpe die.. seize the dice! 🎲🎲";

        // Static Properties
        public static DateTime Yesterday => DateTime.UtcNow.AddDays(-1);
        public static DateTime Tomorrow => DateTime.UtcNow.AddDays(1);

        // Instance Method
        public int GetNextLeapYear() =>
            Enumerable.Range(dt.Year + 1, 4).Single(DateTime.IsLeapYear);

        // Instance Properties
        public DateTime NextWeek => dt.AddDays(7);
        public bool IsFutureDate => dt > DateTime.UtcNow;
    }
}

Thoughts

#

Having not actually used them in a prod environment yet, outside of the post here, I like them so far. I like that it makes things a little more DRY by defining the variable once in the extension container, and I like having the ability to define extension properties now too. I also like that it makes a class a bit more organized by keeping the extension methods and properties grouped inside the extension block.

Will I use this a lot in the future? I’m not sure.. what do you think? Do you have any good uses for this in mind?

Learn More

#

• Extension member declarations - C# reference | Microsoft Learn
• Extension members - C# | Microsoft Learn

The developer I am now, though, is a result of all the places, environments, and people I’ve worked with over the years, good and bad, and today’s as good a day as any to reflect on the experiences and lessons I’m thankful for.

Agile / Scrum - It’s slightly different everywhere, but I like that it makes visible the invisible (through kanban boards) and promotes conversation (through standups) where someone might not otherwise speak up about a problem. I’m also grateful for a team lead who pushed it before I realized what it was or why anyone would want it, and I’m happy for the companies since then where upper management saw the value too.

Pair Programming - I’ve worked in environments with 100% pair programming and others where any amount of pair programming was seen as a waste of resources. It’s a useful tool - not all the time but definitely in certain circumstances like mentoring or getting a second set of eyes on a tough problem to carry it through to completion.

CI / Automated Testing - Whether in Jenkins, TeamCity, Azure DevOps, or some other tool (I’ve gotten to play around with quite a few), I’m grateful for the teams that saw the value in making builds an automated, repeatable process, and running tests as a part of it. I was once on a team that manually deployed whatever code was ready on Monday morning, with minimal testing, and I cannot stress enough how poor that experience was for everyone involved. Guaranteed way to make people lose faith in the IT department. 😓

Cross Functional Teams - Since working on a more traditional team, with devs and QAs and whoever else working in completely separate areas, and I’ve come to appreciate since then how well smaller teams with several members representing each concern can work. The last team I was on included some very knowledgeable people who had spent decades learning the system, and I got to work closely with them on multiple projects. It made for much quicker collaboration, rather than tossing something over the wall to a group of people you get to work with very little.

Engaged Managers - It’s been interesting (and sometimes frustrating) to see how different managers perform their jobs. I’m thankful for those managers who prioritize 1x1s and get to know their team. I once had a manager who mailed everyone on his team some goodies at home, along with a personal note, during a rough project that involved a lot of overtime and stress.

Some of the nicest people I’ve worked with have worked for a company for 20 or 30 years, and I certainly hope I’ve found that now. But for those who are still looking, who are unhappy with their current situation for whatever reason, I hope you believe in yourself and your ability to learn something new! It may take awhile, but it’ll happen!

Today marks a month of a new (old) beginning for me, of returning to where I started, and of moving out of my comfort zone to learn new things. I’m glad I pushed myself, but I’m especially thankful others saw something in me and gave me the chance!

That’s the way it is with writing code for large companies, where we don’t get to see the beginning or the end. Our changes build on top of other changes, layer on layer, and the bigger the change, the bigger the impact down the line. When one layer has mistakes though, everything around it is tainted too. Wouldn’t it be nice if we could check out each other’s code before it got added to the mix? Oh wait…

It took me a long time to see the value of pull requests (I used to be arrogant about my code - hey, it works on my machine), but now that I do, it’s frustrating when I reach out hoping for advice and feedback, only to be given a quick stamp of approval. If I touch a piece of code that Bob the dev worked on last month or a stored proc that Susan the DBA created, and I tag them on a PR, it’s not a formality. This process is for everyone’s benefit!

What I write today (good, bad, or ugly) is what they inherit and have to work with tomorrow, and vice-versa.

And so, I want their feedback, their constructive criticism, their optimizations. I want to know if I’m going wrong and where, and that they’re comfortable with what I’m about to merge in, because they may be the next person who has to deal with it… and who knows if I’ll be around to explain (or help fix) it when they do!

If you get tagged on one and you’re wondering what’s the point, remember their code will be yours to deal with tomorrow. So spend a little time, ask some questions, and provide that constructive feedback. You’ll be doing everyone a favor! 😉

It’s important to take a few minutes and understand the difference, so let’s take a look at a couple short examples, which you can also find here.

A Short Example

#

DateTime

#

Here’s a short example using three DateTime values. The first one is in the “local” time zone (but which one is that?), the second one is UTC, and the last one isn’t specified… could be either, who knows.

Console.WriteLine("=== DATETIME ===");

var dtLocal = new DateTime(2025, 9, 4, 12, 0, 0, DateTimeKind.Local);
var dtUTC = new DateTime(2025, 9, 4, 12, 0, 0, DateTimeKind.Utc);
var dtUnk = new DateTime(2025, 9, 4, 12, 0, 0);  // DateTimeKind.Unspecified

// Local vs UTC vs Unknown DateTime
Console.WriteLine($"Local: {dtLocal}");      // 9/4/2025 12:00:00 PM
Console.WriteLine($"UTC: {dtUTC}");          // 9/4/2025 12:00:00 PM
Console.WriteLine($"Unspecified: {dtUnk}");  // 9/4/2025 12:00:00 PM

// Convert between Local and UTC
Console.WriteLine($"Local to UTC: {dtLocal.ToUniversalTime()}");  // 9/4/2025 4:00:00 PM
Console.WriteLine($"UTC to Local: {dtUTC.ToLocalTime()}");        // 9/4/2025 8:00:00 AM

Console.WriteLine($"Unspecified to UTC: {dtUnk.ToUniversalTime()}");  // 9/4/2025 4:00:00 PM
Console.WriteLine($"Unspecified to Local: {dtUnk.ToLocalTime()}");    // 9/4/2025 8:00:00 AM

Printing them all out to the console (lines 8-10) says nothing about which time zone the DateTime was recorded in. Still, it’s tracking local vs UTC internally via the DateKind property, and converting the local one to UTC or vice-versa shows that it knows that at least (lines 13-14).

What is “local” though? Once the value is stored in the database in a DateTime column type, we can’t know. Not only do we not know which local time zone it originally represented, we don’t even know if it was local, or if it was UTC! That’s the catch. We’ve lost a critical bit of context.

As for the unspecified one (lines 16-17), it’s even less helpful. If you convert it to UTC, it assumes you started with local. If you convert it to local, it assumes you started with UTC. After all, we never told it.

DateTimeOffset

#

And here’s a short example using three DateTimeOffset values. The first one is in a specific “local” time zone (EDT in this case), the second one is UTC, and the last one isn’t specified… which defaults to the current “local” time zone, so it actually is still known. No ambiguity here.

Console.WriteLine("=== DATETIMEOFFSET ===");

var dtoLocal = new DateTimeOffset(2025, 9, 4, 12, 0, 0, TimeSpan.FromHours(-4));
var dtoUTC = new DateTimeOffset(2025, 9, 4, 12, 0, 0, TimeSpan.FromHours(0));
var dtoUnk = new DateTimeOffset(dtUnk);  // treated as current local time zone

// Local vs UTC vs Unknown DateTimeOffset
Console.WriteLine($"Local: {dtoLocal}");      // 9/4/2025 12:00:00 PM -04:00
Console.WriteLine($"UTC: {dtoUTC}");          // 9/4/2025 12:00:00 PM +00:00
Console.WriteLine($"Unspecified: {dtoUnk}");  // 9/4/2025 12:00:00 PM -04:00

// Convert between Local and UTC
Console.WriteLine($"Local to UTC: {dtoLocal.ToUniversalTime()}");  // 9/4/2025 4:00:00 PM +00:00
Console.WriteLine($"UTC to Local: {dtoUTC.ToLocalTime()}");        // 9/4/2025 8:00:00 AM -04:00

Console.WriteLine($"Unspecified to UTC: {dtoUnk.ToUniversalTime()}");  // 9/4/2025 4:00:00 PM +00:00
Console.WriteLine($"Unspecified to Local: {dtoUnk.ToLocalTime()}");    // 9/4/2025 12:00:00 PM -04:00

Now, printing local (or unspecified) uses the current local time zone at the time it was defined, and printing UTC uses UTC of course (lines 8-10). Converting between the two (lines 13-14) is consistent, and there’s no unspecified or unknown value (lines 16-17) anymore since it’s just treated as local too.

Storing these values in a DateTimeOffset column type retains the extra context. So we should use DateTimeOffset everywhere, right? Well, no…

Which one do we use?

#

Sometimes we need the extra context…

• Imagine User A and User B live in time zones 3 hours apart.
• User A uses an app to schedule a meeting for 8am (for User B it’s 11am), and it’s stored as a local DateTime value.
• User B uses the same app to reopen the schedule and the system, having no idea which local time zone it was created in, shows it at 8am instead of 11. Confused, he moves it to 11am, but now User A has it scheduled for 11am as well.

One solution is to convert all DateTime values to UTC before saving to the database, and then read them out assuming they’re UTC as well. Anyone who’s worked in a system that a hundred other people have touched over the course of a couple decades knows that’s a fool’s dream.

The better solution is to use DateTimeOffset which has time zone built in. You can’t not specify a time zone, so User A schedules for 8am PST, and when User B opens it later, the system can see they’re in EST and convert it to 11am for him.

But sometimes we don’t need that, like when we’re talking about a specific point in time that’s independent of time zone. If Acme Inc is a nationwide retail chain that always closes at 8pm, and their next inventory is at closing time on Fri Oct 3rd, then maybe there’s a NextInventoryDate column in the database somewhere that’s set to “8/3/2025 20:00:00” and that’s the same everywhere. No matter what time zone you’re in, your store closes at 8pm on Aug 3rd.

And so the answer, as usual, is “it depends”. (But it seems like DateTimeOffset is better, more often than not.)

References

#

• DateTime Struct (System) | Microsoft Learn (and DateTime.Kind)
• DateTimeOffset Struct (System) | Microsoft Learn
• Compare types related to date and time - .NET | Microsoft Learn

The code in this post is available on GitHub, for you to use, extend, or just follow along while you read… and hopefully discover something new along the way!

I spent a couple evenings playing around and barely scratched the surface. Here’s what I learned.

What is WebView2?

#

The WebView2 control is, in their own words, a wrapper around the WebView2 COM API, which in a more general sense “allows you to embed web technologies (HTML, CSS, and JavaScript) in your native apps [using] Microsoft Edge as the rendering engine to display the web content”. Since Edge is based on Chromium (as are most major browsers), it’s effectively a wrapper around Chromium.

Basically, we get a Chromium-based browser in our app, similar to other third-party tools like CefSharp, DotNetBrowser, etc.

Initializing WebView2

#

The WebView2 control is available on NuGet. Just fire up a WinForms app, install the package, and (in VS2022 at least) it appears in the “Toolbox” fairly quickly. From there, we can drag and drop it onto a Form and we’re off the races…

Adding WebView2 to a WinForms project

After that, the control should be initialized: (maybe, probably.. read on)

public Form1()
{
    InitializeComponent();

    InitializeWebView2();
}

async void InitializeWebView2()
{
    await webView2.EnsureCoreWebView2Async();
}

Nearly everything on the WebView2 control is accessed through a CoreWebView2 property. Per the docs, that property is null initially because creating it is an expensive operation, but in a little test app like this we want it right away. By calling EnsureCoreWebView2Async(), the CoreWebView2 property is guaranteed to be initialized, so that subsequent calls won’t throw a null reference exception.

Navigate to a Website

#

Navigating to a site is super easy - just call the Navigate() method. The only catch is it has to start with “https” or “http”:

// Load Microsoft
webView2.CoreWebView2.Navigate("https://microsoft.com");

Done! lol

Load Custom HTML

#

Alternatively, we can throw together some HTML on-the-fly (up to 2 MB) and pass that to the control instead, like this:

// Load HTML with inline JS/CSS
webView2.NavigateToString(
    """
    <html>
        <head>
            <style>p{color:green; font-weight:bold}</style>
        </head>
        <body>
            <p>Not much to see here.....</p>
            <button onClick="alert('Unbelievable...')">DON'T PRESS ME</button>
        </body>
    </html>
    """);

Or instead of including the CSS and JavaScript in the HTML, we can inject it separately with a call to AddScriptToExecuteOnDocumentCreatedAsync():

// Define some JS and CSS to add to the page after it loads
var scriptID = await webView2.CoreWebView2.AddScriptToExecuteOnDocumentCreatedAsync(
    """
    document.addEventListener('readystatechange', evt => {
        if (document.readyState === 'complete') {
            document.getElementById('btn')
                .addEventListener('click', function() {alert('Just.. why?')});
            document.head.insertAdjacentHTML('beforeend',
                '<style>p{color:red; font-style:italic}</style>');
        }
    });
    """);

// Load HTML sans JS/CSS
webView2.NavigateToString(
    """
    <p>Move along.. nothing to see here...</p>
    <button id='btn'>DON'T PRESS ME</button>
    """);

webView2.CoreWebView2.RemoveScriptToExecuteOnDocumentCreated(scriptID);

The “AddScript…” method runs before the HTML has actually been parsed, so I was getting javascript errors aplenty when I tried to access document.head, document.getElementById(), etc. Checking that the readyState for the document is “complete” seems to work. Probably a better way, who knows.

The last line of code is worth mentioning too, where I call RemoveScriptToExecuteOnDocumentCreated(). Once a script is added, it’ll stick around and run again anytime a new document is loaded. To see what I mean, we can add something like this to the InitializeWebView2() method:

// Scripts like this one run on every page load
// until you call RemoveScriptToExecuteOnDocumentCreated()
await webView2.CoreWebView2.AddScriptToExecuteOnDocumentCreatedAsync(
    """
    document.addEventListener('readystatechange', evt => {
        if (document.readyState === 'complete') {
            document.head.insertAdjacentHTML('beforeend',
                '<style>body,div {background: lightyellow !important}</style>');
        }
    });
    """);

Now the body and div on every page loaded has a light yellow background:

I remove the script so that it won’t load for the next page, but I have no clue what the best practices are around calling that. It seems to leave the scripts loaded as-is on the page just fine, but navigating back and forth breaks things, like the red text below that reverts back to black as I navigate around.

Like I said, barely scratching the surface here. 😄

Execute a Script

#

It’s super easy to execute a one-off script against the loaded document too:

// Execute a script in the top-level document
webView2.ExecuteScriptAsync("alert('Hi there, hello.')");

No matter what page is loaded, it works the same:

Send Messages Back and Forth

#

It’s also possible to communicate between the loaded website and the Form. We can subscribe to both events in the InitializeWebView2() method, one a WinForms event, and the other a JavaScript event listener:

async void InitializeWebView2()
{
    await webView2.EnsureCoreWebView2Async();

    // Handle messages from WinForms to the WebView2
    await webView2.CoreWebView2.AddScriptToExecuteOnDocumentCreatedAsync(
        "window.chrome.webview.addEventListener('message', evt => alert(evt.data));");

    // Handle messages from the WebView2 to WinForms
    webView2.WebMessageReceived += (s, e) =>
        MessageBox.Show(e.TryGetWebMessageAsString());
}

Now we can create some C# code that’ll send a message to our website…

// See the "InitializeWebView2()" method, where we tell the WebView2 control
// what to do with messages we send to it... display them in an alert box
webView2.CoreWebView2.PostWebMessageAsString(txtMsgToSendToHtml.Text);

… and some JS that’ll send messages back to our Form:

// Add a button that, upon clicking, sends a message to WinForms
webView2.NavigateToString(
    """
    <html>
        <head>
            <style>button {color:blue; font-weight:bold}</style>
        </head>
        <body>
            <p>Press the button to send a message to the Form, which will display it in a MessageBox.</p>
            <input type="text" id="user_msg" value="Type your message here...">
            <button onclick="window.chrome.webview.postMessage(document.getElementById('user_msg').value);">
                SEND MESSAGE
            </button>
        </body>
    </html>
    """
);

Now we can send messages back and forth:

Subscribe to Events

#

There’s all kinds of events we can subscribe to, like when navigation has started or completed, or the source in the control has changed (which is how I’m changing the text at the bottom of the Form in all the above images).

If you want the usual browser buttons, you can subscribe to those too:

btnGoBack.Click += (s, e) => webView2.CoreWebView2.GoBack();
btnGoFwd.Click += (s, e) => webView2.CoreWebView2.GoForward();
btnReload.Click += (s, e) => webView2.CoreWebView2.Reload();

I think that’s enough for now though!

Learn More

#

Microsoft has quite a bit of documentation to sift through, some of which I already linked to above. There’s tons of info on WebView2 in general, WebView2 in WinForms specifically, and a discussion forum on GitHub if you just need to vent.

If you found this content useful and would like to learn more, check out my Surviving WinForms repo, where you’ll find links to plenty more blog posts and practical examples!

In .NET 5, we got a new control called TaskDialog that allows for much more customization. Instead of one main text area, the UI supports a more complex interface for displaying larger messages. Instead of a few preset button combos, we can create our own.. and even define new buttons.

The code in this post is available on GitHub, for you to use, extend, or just follow along while you read… and hopefully discover something new along the way!

It’s great that the team behind WinForms has the bandwidth to add new features, not just bandaid old bugs. Let’s compare the two controls and take a look at what we can do with TaskDialog.

Replacing MessageBox

#

Without considering anything fancier, it’s super easy to replace a standard MessageBox. Here’s a simple message to warn the user when they’re about to delete some files:

The code for the above is pretty succinct. We want Yes/No buttons with No as the default:

var result = MessageBox.Show(
    caption: "Continue?",
    text: "You're about to delete the selected files! Continue?",
    icon: MessageBoxIcon.Warning,
    buttons: MessageBoxButtons.YesNo,
    defaultButton: MessageBoxDefaultButton.Button2);

if (result == DialogResult.Yes)
{
    // proceed to delete files...
}

And here’s the a prompt with the same behavior, recreated using TaskDialog:

The code is very similar. We set the properties on a TaskDialogPage object and pass that to the TaskDialog.ShowDialog method:

var result = TaskDialog.ShowDialog(new TaskDialogPage
{
    Caption = "Continue?",
    Text = "You're about to delete the selected files! Continue?",
    Icon = TaskDialogIcon.Warning,
    Buttons = { TaskDialogButton.Yes, TaskDialogButton.No },
    DefaultButton = TaskDialogButton.No,
    SizeToContent = true,
});

if (result == TaskDialogButton.Yes)
{
    // proceed to delete files...
}

There’s a couple interesting things to point out straightaway. Firstly, we’ve specified the buttons we wanted separately – we’re not constrained by specific combinations of buttons. Secondly, we specified the default button using the name of the button, not the generic Button1, Button2, etc.

What else can we do?

A Friendlier Error Message

#

For the sake of argument, let’s say we’re working on an app where the decision was made to display unhandled exceptions to the user, with the full stack trace. In the static void Main() method of the Program class, we can subscribe to the ThreadException event to catch all otherwise uncaught exceptions:

Application.ThreadException += Application_ThreadException;

And then the method itself, to just display everything in a MessageBox:

private static void Application_ThreadException(
    object sender, ThreadExceptionEventArgs e)
{
    MessageBox.Show(e.Exception.ToString(), "Application Exception");
}

Here’s what we get. Ouch.

With the new TaskDialog, we can do so much more:

var submitError = new TaskDialogButton("Submit Error");
submitError.Click += (s, e) => MessageBox.Show(
    "Thank you for notifying us. We're on it. Seriously.", "Submit Error");

TaskDialog.ShowDialog(new TaskDialogPage
{
    Caption = "Application Exception",
    Heading = "An exception has occurred!",
    Text = e.Exception.Message,
    Icon = TaskDialogIcon.Error,
    AllowCancel = true,
    Expander = new TaskDialogExpander
    {
        Text = e.Exception.StackTrace,
        CollapsedButtonText = "Stack Trace",
    },
    Buttons = { TaskDialogButton.OK, submitError },
    DefaultButton = TaskDialogButton.OK,
    SizeToContent = true,
});

We can hide the details in a collapsed section, so they’re out of the way initially. We can add our own buttons for additional actions, like submitting the error. The AllowCancel flag allows them to hit Esc to dismiss the message, and SizeToContent widens the box to support the contents better, so the stack trace text isn’t more awkwardly wrapped than necessary.

Accept Our EULA

#

Or maybe we need users to accept our completely uninvasive, non-creepy EULA before using our app?

var eulaSummary = "omitted for brevity";
var eulaDetail = "omitted for brevity";

var vcb = new TaskDialogVerificationCheckBox("Accept EULA");
var tdp = new TaskDialogPage
{
    Caption = "Accept EULA",
    Heading = "EULA",
    Text = eulaSummary,
    Footnote = $@"© <a href=""https://example.org/"">ShadyBiz LLC</a>, 2013 - {DateTime.Now.Year}",
    Icon = TaskDialogIcon.ShieldWarningYellowBar,
    AllowCancel = true,
    Expander = new TaskDialogExpander
    {
        Text = eulaDetail,
        CollapsedButtonText = "Nothing to see here...",
    },
    Buttons = { new TaskDialogButton("OK", false) },
    SizeToContent = true,
    EnableLinks = true,
    Verification = vcb,
};

vcb.CheckedChanged += (s, e) => tdp.Buttons[0].Enabled = vcb.Checked;
tdp.LinkClicked += (s, e) => Process.Start("explorer", e.LinkHref);

if (TaskDialog.ShowDialog(this, tdp) == TaskDialogButton.OK)
{
    // record the user's acceptance of the EULA
}

The Verification property lets us add a custom TaskDialogVerificationCheckBox, and by subscribing to its CheckedChanged event, we can force users to select it before hitting OK. There’s an icon option that adds a yellow bar to really grab attention when needed, and a flag that lets us include hyperlinks in the text.

Self destruct in…

#

Or maybe we want to notify the user that they only have 5 seconds to take some action!!! This doesn’t work very well, since once a dialog is displayed, the user must take some action to make it go away. But I want to show off another feature of the TaskDialog control and I’m running low on ideas. 😏

var pb = new TaskDialogProgressBar { Value = 5, Minimum = 0, Maximum = 5 };
var msg = "This message will self-destruct in {0} seconds...";

var tdp = new TaskDialogPage
{
    Caption = "Final Countdown",
    Text = string.Format(msg, 5),
    ProgressBar = pb,
    Icon = TaskDialogIcon.Information,
};

var tmr = new Timer() { Interval = 1000, Enabled = true };
tmr.Tick += (s, e) =>
{
    if (pb.Value > 0)
    {
        pb.Value -= 1;
        tdp.Text = string.Format(msg, pb.Value);
    }
    else
        tdp.Text = "Boom? ¯\\_(ツ)_/¯";
};

var tdResult = TaskDialog.ShowDialog(this, tdp);

if (tdResult == TaskDialogButton.OK && pb.Value == 0)
{
    // You were warned...
}

The ProgressBar property lets us add a custom TaskDialogProgressBar to show progress. Here, we’ve set it to 5 initially, and then we use a standard WinForms Timer to count down for 5 seconds. I love that we can add a ProgressBar, although a good use-case is escaping me at the moment. Maybe you have one you’d like to share?

If you found this content useful and would like to learn more, check out my Surviving WinForms repo, where you’ll find links to plenty more blog posts and practical examples!

The code in this post is available on GitHub, for you to use, extend, or just follow along while you read… and hopefully discover something new along the way!

The old FolderBrowserDialog (one at a time, please)

#

The FolderBrowserDialog control has always given us an easy way to select a single folder in an app. After confirming the user pressed OK, we just read in the SelectedPath property and move on with life:

if (fbd.ShowDialog() == DialogResult.OK)
    MessageBox.Show($"The path to process:\n\n{fbd.SelectedPath}");

There’s a lot of other available properties with this control too, but they didn’t change so I won’t bother with them. They’re there though. 😏

The new FolderBrowserDialog (the more, the merrier)

#

The only change we have to make with the updated control in .NET 9 is to set the Multiselect property to true, either in the designer or at runtime:

fbd.Multiselect = true;

Then we call it the same way but reference the new SelectedPaths property, which is an array of strings:

if (fbd.ShowDialog() == DialogResult.OK)
    MessageBox.Show($"The path(s) to process:\n\n{string.Join("\n", fbd.SelectedPaths)}");

That’s it! I can’t decide if it’s stranger that it never had this capability, or that someone decided to add it now after all these years. Did something else change that made this a priority? Or is someone who’s been with WinForms since the very beginning retiring, and this was on their bucket list? Either way, we could only choose one folder at a time before, and now we can choose as many as we’d like!

When I’ve wanted to add system icons to buttons, toolbars, etc in the past, it usually meant extracting them from shell32.dll, imageres.dll.mun, the Visual Studio Image Library, etc, and then copying them into the project. Then I’d add them to an ImageList and hook that up to various UI elements. So I’m wondering.. does this new method give us an easier way to use system icons?

The code in this post is available on GitHub, for you to use, extend, or just follow along while you read… and hopefully discover something new along the way!

Usage

#

The way it’s called is simple enough. We just pass a StockIconId enum value to tell it which icon to retrieve, and then do whatever we like with the icon:

Icon driveIcon = SystemIcons.GetStockIcon(StockIconId.DriveNet);

Once we have it, we could add it to an ImageList and then use that on a Button or other controls. We could also specify a size in the second parameter, like I did here with a PictureBox to display a larger icon that’s still sharp:

// Populate image list with default size, which should be 32 px
imageList1.Images.Add("Conn", SystemIcons.GetStockIcon(StockIconId.DriveNet));
imageList1.Images.Add("Disconn", SystemIcons.GetStockIcon(StockIconId.DriveNetDisabled));

button1.ImageKey = "Conn";
pictureBox1.Image = SystemIcons.GetStockIcon(StockIconId.DriveNet, 128).ToBitmap();

Or we could loop through all of them, adding each to an ImageList, and then use that to create the world’s busiest toolbar: 😏

foreach (StockIconId icon in Enum.GetValues(typeof(StockIconId)))
    imageList2.Images.Add(icon.ToString(), SystemIcons.GetStockIcon(icon, 64));

toolStrip1.Items.AddRange(imageList2.Images.Keys.Cast<string>().Select(x =>
    new ToolStripButton(imageList2.Images[x]) { ToolTipText = x }).ToArray());

Pros and Cons

#

The biggest limitation is only being able to call this at runtime. Of course, that’s just the nature of this being a method call, but one of the best things about WinForms is its drag-and-drop designer and this definitely works against that. I’m not sure how much usage this will get if it means having a designer with blank toolbars, incomplete buttons, etc. Maybe I’m missing an obvious use case?

A nice feature, though, is that this method “returns icons that are themed for the running version of Windows”. If we copy icons into the project, they are what they are, unchanged no matter what version of Windows someone happens to be running. But with this new call, when someone runs our app in a different version of Windows from the one we designed it in, they’ll see the icons that are normal for their OS.

Learning More

#

If you want to learn more, check out the GetStockIcon docs, the StockIconId enum that lists all the available images, and the StockIconOptions enum that lets us set a few options like adding a link overlay to the image. Since a couple of the options involve resizing the icon, we’re not allowed to specify a size and options, but that also means it’s not possible to request a larger image that has a link overlay.. seems like an odd choice.

Lastly, since the StockIconId page doesn’t include the actual images of the icons, here’s a list so you can see what they look like, at least in Windows 11:

Name	Value	Description	Image
DocumentNoAssociation	0	Document (blank page), no associated program.
DocumentWithAssociation	1	Document with an associated program.
Application	2	Generic application with no custom icon.
Folder	3	Closed folder.
FolderOpen	4	Open folder.
Drive525	5	5.25" floppy disk drive.
Drive35	6	3.5" floppy disk drive.
DriveRemovable	7	Removable drive.
DriveFixed	8	Fixed drive.
DriveNet	9	Network drive.
DriveNetDisabled	10	Disabled network drive.
DriveCD	11	CD drive.
DriveRam	12	RAM disk drive.
World	13	Entire network.
Server	15	A computer on the network.
Printer	16	Printer.
MyNetwork	17	My network places.
Find	22	Find.
Help	23	Help.
Share	28	Overlay for shared items.
Link	29	Overlay for shortcuts to items.
SlowFile	30	Overlay for slow items.
Recycler	31	Empty recycle bin.
RecyclerFull	32	Full recycle bin.
MediaCDAudio	40	Audio CD media.
Lock	47	Security lock.
AutoList	49	AutoList.
PrinterNet	50	Network printer.
ServerShare	51	Server share.
PrinterFax	52	Fax printer.
PrinterFaxNet	53	Networked fax printer.
PrinterFile	54	Print to file.
Stack	55	Stack.
MediaSVCD	56	SVCD media.
StuffedFolder	57	Folder containing other items.
DriveUnknown	58	Unknown drive.
DriveDVD	59	DVD drive.
MediaDVD	60	DVD media.
MediaDVDRAM	61	DVD-RAM media.
MediaDVDRW	62	DVD-RW media.
MediaDVDR	63	DVD-R media.
MediaDVDROM	64	DVD-ROM media.
MediaCDAudioPlus	65	CD+ (Enhanced CD) media.
MediaCDRW	66	CD-RW media.
MediaCDR	67	CD-R media.
MediaCDBurn	68	Burning CD.
MediaBlankCD	69	Blank CD media.
MediaCDROM	70	CD-ROM media.
AudioFiles	71	Audio files.
ImageFiles	72	Image files.
VideoFiles	73	Video files.
MixedFiles	74	Mixed files.
FolderBack	75	Folder back.
FolderFront	76	Folder front.
Shield	77	Security shield. Use for UAC prompts only.
Warning	78	Warning.
Info	79	Informational.
Error	80	Error.
Key	81	Key / secure.
Software	82	Software.
Rename	83	Rename.
Delete	84	Delete.
MediaAudioDVD	85	Audio DVD media.
MediaMovieDVD	86	Movied DVD media.
MediaEnhancedCD	87	Enhanced CD media.
MediaEnhancedDVD	88	Enhanced DVD media.
MediaHDDVD	89	HD-DVD media.
MediaBluRay	90	BluRay media.
MediaVCD	91	VCD media.
MediaDVDPlusR	92	DVD+R media.
MediaDVDPlusRW	93	DVD+RW media.
DesktopPC	94	Desktop computer.
MobilePC	95	Mobile computer.
Users	96	Users.
MediaSmartMedia	97	Smart media.
MediaCompactFlash	98	Compact Flash.
DeviceCellPhone	99	Cell phone.
DeviceCamera	100	Camera.
DeviceVideoCamera	101	Video camera.
DeviceAudioPlayer	102	Audio player.
NetworkConnect	103	Connect to network.
Internet	104	Internet.
ZipFile	105	ZIP file.
Settings	106	Settings.
DriveHDDVD	132	HD-DVD drive.
DriveBD	133	BluRay drive.
MediaHDDVDROM	134	HD-DVD-ROM media.
MediaHDDVDR	135	HD-DVD-R media.
MediaHDDVDRAM	136	HD-DVD-RAM media.
MediaBDROM	137	BluRay-ROM media.
MediaBDR	138	BluRay-R media.
MediaBDRE	139	BluRay-RE media.
ClusteredDrive	140	Clustered disk.

If you found this content useful, and would like to learn more about a variety of C# features, check out my CSharpDotNetFeatures repo, where you’ll find links to plenty more blog posts and practical examples!

Before we dig into them, let’s take a brief look at what we had before that, and then see what new things they bring to the table.

The code in this post is available on GitHub, for you to use, extend, or just follow along while you read… and hopefully discover something new along the way!

Quoted Strings

#

Here’s a normal, quoted string. They allow escaped sequences such as tabs, newlines, quotes, etc. If we want a quote in the string, it has to be escaped:

Console.WriteLine("Windows dir: \t\t \"C:\\Windows\"");

// Windows dir:             "C:\Windows"

Normal string allows escape sequences

Verbatim Strings

#

Adding the @ character to the left of a string causes escaped sequences to be ignored. If we want a quote in the string, it has to be doubled:

Console.WriteLine(@"Windows dir: \t\t ""C:\Windows""");

// Windows dir: \t\t "C:\Windows"

Verbatim strings ignore escape sequences

String Interpolation

#

I’ve written separately about string interpolation, but adding a $ to the left of a string allows us to specify variables inline. If we want a curly braces in the string, it has to be doubled. Otherwise it behaves like a normal quoted string.

Console.WriteLine($"Today's date is: \t\t \"{{{DateTime.Now}}}\"");

// Today's date is:                 "{12/13/2024 9:31:09 PM}"

String interpolation allows inline variables

Verbatim String Interpolation

#

I’m not sure whether to call this a verbatim interpolated string or an interpolated verbatim string. Or a stringy verbapolation (lol). Inline variables are allowed, and double curly braces are required to show a curly brace, but otherwise they behave like a verbatim string and ignore escaped sequences.

Console.WriteLine($@"Today's date is: \t\t ""{{{DateTime.Now}}}""");

// Today's date is: \t\t "{12/13/2024 9:31:09 PM}"

Verbapolated strings mix up the behaviors

Raw String Literals (single-line)

#

By using triple (or more) quotes at the start and end of a string, we’ve defined a raw string literal. It behaves mostly like a verbatim string, with some special rules for quotes:

• They’re allowed in the string, as long as they don’t occur in sequences longer than whatever we started or ended the string with
• They can’t butt right up to the quotes that start/end the string (hence the space at the end of the string below)

Console.WriteLine("""Today's date is: \t "{DateTime.Now}" """);
// Today's date is: "{DateTime.Now}"

Console.WriteLine(""""Today's date is: \t """{DateTime.Now}""" """");
// Today's date is: """{DateTime.Now}"""

By adding the $ string interpolation character, we can insert variables inline again. The main difference is that adding a literal curly brace to the string now requires increasing the number of $ at the start of the string. Any number of them less than that in the string is assumed to be a literal brace. I can’t figure out why that behavior changed, but I assume they had a reason. 🤷‍♂️

Console.WriteLine($"""Today's date is: \t "{DateTime.Now}" """);
// Today's date is: "12/13/2024 9:31:09 PM"

Console.WriteLine($$"""Today's date is: \t "{{{DateTime.Now}}}" """);
// Today's date is: "{12/13/2024 9:31:09 PM}"

Console.WriteLine($$$"""Today's {{date}} is: \t "{{{{{DateTime.Now}}}}}" """);
// Today's {{date}} is: "{{12/13/2024 9:31:09 PM}}"

Raw String Literals (multi-line)

#

Here’s where the behavior really changes, although as I alluded to at the beginning of this article, this doesn’t seem like a earth-shattering addition to me. Am I missing something?

A raw string literal can span multiple lines, and doesn’t require new lines in the string. In fact, they wouldn’t be interpreted anyway, since the behavior is largely like a verbatim string.

// Multi-line raw string literals follow the same rules as above;
// None of the lines may appear to the left of the closing set of quotes

Console.WriteLine("""
    Now this is interesting!
            Is this indented? \t "{DateTime.Now}"
    """);

// Now this is interesting!
//         Is this indented? \t "{DateTime.Now}"

Raw string literals behave largely like verbatim strings

If we add the $ to the start though, then we can add variables inline. And while escaped characters are ignored when placed directly in the string, we can store them in a separate variable and let interpolation do the work for us. That’s a rawverbapolated string, for those keeping track.

var tab = $"\t";
Console.WriteLine($"""
    Now this is interesting!\n\n\n
            Is this indented? {tab} "{DateTime.Now}"
    """);

// Now this is interesting!\n\n\n
//         Is this indented?        "12/13/2024 9:44:39 PM"

We can increase the number of quotes and dollar signs around the string too, just like before, when we have a need to display multiple quotes or literal curly braces inside the raw string literal:

Console.WriteLine($"""""
    Now this is interesting!
            Is this indented? {tab} """"{DateTime.Now}""""
    """"");

// Now this is interesting!
//         Is this indented?        """"12/13/2024 9:44:39 PM""""

Console.WriteLine($$"""
    Now this is interesting!
            Is this indented? {{tab}} "{{{DateTime.Now}}}"
    """);

// Now this is interesting!
//         Is this indented?        "{12/13/2024 9:44:39 PM}"

And finally, we can use raw string literals in a whole lot of cases other than just writing out lines to a console. I can imagine a few, one of them being a multi-line message box like this:

Learning More

#

Microsoft has a lot more to say about raw string literals, and strings in general, than what I can post here. They’ve spread info out over a few different docs, but if you’re interested then they’re definitely worth a looksie:

• What’s new in C# 11 | Raw string literals
• Strings - C# | Raw string literals
• Built-in reference types - C# reference | String literals
• $ - string interpolation | Interpolated raw string literals

If you found this content useful, and would like to learn more about a variety of C# features, check out my CSharpDotNetFeatures repo, where you’ll find links to plenty more blog posts and practical examples!

One of the features we got as part of C# 12 is called primary constructors, which gives us a different way to define classes and structs. Let’s take a closer look at what we can do with them and how they differ from traditional constructors.

The code in this post is available on GitHub, for you to use, extend, or just follow along while you read… and hopefully discover something new along the way!

Using Primary Constructors in Classes

#

Here’s a standard class, representing a satellite. There’s a constructor that sets some properties, only one of which (IsActive) can be changed after instantiation: (why? who knows, lol)

internal class Satellite
{
    public string Name { get; init; }
    public string Owner { get; init; }
    public DateOnly LaunchDate { get; init; }
    public bool IsActive { get; set; }

    public Satellite(string name, string owner, DateOnly launchDate, bool isActive)
    {
        Name = name;
        Owner = owner;
        LaunchDate = launchDate;
        IsActive = isActive;
    }
}

Writing the above code using a “primary constructor” instead (Visual Studio will helpfully do the conversion for us), we end up with something more compact, with the parameters relocated to the class signature line:

internal class Satellite(
    string name, string owner, DateOnly launchDate, bool isActive)
{
    public string Name { get; init; } = name;
    public string Owner { get; init; } = owner;
    public DateOnly LaunchDate { get; init; } = launchDate;
    public bool IsActive { get; set; } = isActive;
}

If we add the record modifier (something from a few versions before), then we can reduce the definition even more, since it causes read-only properties to be generated for us:

internal record class Satellite(
    string Name, string Owner, DateOnly LaunchDate, bool IsActive);

But since the original class allowed us to change the IsActive property, we’d actually have to override the default behavior by defining the property ourselves:

internal record class Satellite(
    string Name, string Owner, DateOnly LaunchDate, bool IsActive)
{
    public bool IsActive { get; set; } = IsActive;
}

Any of the above definitions allows us to intantiate the class like this, and then we can change the one property that allows it as needed:

var satellite =
    new Satellite("Navstar 82", "US", new DateOnly(2023, 1, 17), false);
satellite.IsActive = true;

Records are supposed to be immutable though, so allowing properties to be changed could confuse someone later on. I just felt like showing it off.

Using Primary Constructors in Structs

#

Structs are supposed to represent singular values, like primitive types or DateTime. Here’s a struct that defines a “satellite position” value, which consists of a few things like longitude, latitude, etc.

internal struct SatellitePosition
{
    public string Latitude { get; set; }
    public string Longitude { get; set; }
    public decimal Altitude { get; init; }
    public DateTimeOffset Time { get; set; }

    public SatellitePosition(string latitude, string longitude, decimal altitude, DateTimeOffset time)
    {
        Latitude = latitude;
        Longitude = longitude;
        Altitude = altitude;
        Time = time;
    }
}

All of the properties can be changed except for the altitude (again, who knows why.. we’ll just pretend it’s some crazy requirement).

As with classes, we can migrate it to a primary constructor easily enough:

internal struct SatellitePosition(string latitude, string longitude, decimal altitude, DateTimeOffset time)
{
    public string Latitude { get; set; } = latitude;
    public string Longitude { get; set; } = longitude;
    public decimal Altitude { get; init; } = altitude;
    public DateTimeOffset Time { get; set; } = time;
}

And, again similar to classes, we can reduce things even further by using a record, if that fits our use case:

internal record struct SatellitePosition(
    string Latitude, string Longitude, decimal Altitude, DateTimeOffset Time);

It’s worth mentioning there’s some different behavior here though, than what we saw in the class. Whereas a record class generates readonly properties for us, a record struct generates properties that can be changed.

If we want to prevent an individual property from being changed, we can define it ourselves like this (or add readonly to the signature to make everything readonly):

internal record struct SatellitePosition(string Latitude, string Longitude, decimal Altitude, DateTimeOffset Time)
{
    public decimal Altitude { get; init; } = Altitude;
}

Then we can instantiate it as usual:

var satpos =
    new SatellitePosition1("44.3°N", "25.3°W", 20186, DateTimeOffset.UtcNow);
satpos.Latitude = "44.3°S";

Other Concerns

#

If we need to do something else when a class or struct is instantiated, it is possible to add a normal constructor in addition to the primary constructor, as long as the constructor calls the primary constructor and passes some default values:

internal struct SatellitePosition(
    string latitude, string longitude, decimal altitude, DateTimeOffset time)
{
    public string Latitude { get; set; } = latitude;
    public string Longitude { get; set; } = longitude;
    public decimal Altitude { get; init; } = altitude;
    public DateTimeOffset Time { get; set; } = time;

    public SatellitePosition() : this("", "", 0, DateTimeOffset.MinValue)
    {
        // other important stuff to do on instantiation
    }
}

Unless the default values make sense though, then just sticking with a normal constructor is probably the better way to go.

Learning More

#

To learn more about primary constructors, explore the official docs. Or to learn more about records, see my other article here:

Records, Classes and Equality in C# 9 / .NET 5

If you found this content useful, and would like to learn more about a variety of C# features, check out my CSharpDotNetFeatures repo, where you’ll find links to plenty more blog posts and practical examples!

Among other useful things (like top-level statements and init setters), they added the record modifier for classes. In the release a year after, they made it possible to mark structs as a record too. Adding the new modifier does a couple cool things for us that have me looking for opportunities to use them, so let’s take a closer look.

The code in this post is available on GitHub, for you to use, extend, or just follow along while you read… and hopefully discover something new along the way!

Classes

#

We’ve all written classes, many of us hundreds or even thousands of times. They’re the primary way we group data together into a logical entity, along with methods to manipulate and transform the data, etc. Here’s a simple one:

public class Plane(string Make, string Model, int Year)
{
    public string Make { get; set; } = Make;
    public string Model { get; set; } = Model;
    public int Year { get; set; } = Year;
}

It’s no surprise that we need public properties to access the values passed in via the primary constructor. And it should be no surprise that two instances with all the same values will not be detected as “equal” to one another:

var plane1 = new Plane("Cessna", "680A", 2015);
var plane2 = new Plane("Cessna", "680A", 2015);

Console.WriteLine(plane1.Equals(plane2));  // false
Console.WriteLine(plane1 == plane2);       // false

We haven’t described what makes two Plane instances equal, so the references to each instance (which are always different) are used for the comparison by default.

Classes (with equality defined by us)

#

If we want to compare two objects for equality, there’s a multitude of ways to do it. Here’s two common ones – overriding equality operators and implementing the IEquatable<T> interface:

public class Train(string Make, string Model, int Year) : IEquatable<Train>
{
    public string Make { get; set; } = Make;
    public string Model { get; set; } = Model;
    public int Year { get; set; } = Year;

    public static bool operator ==(Train? x, Train? y)
    {
        if (x is null || y is null)
            return false;

        return x.Make == y.Make && x.Model == y.Model && x.Year == y.Year;
    }

    public static bool operator !=(Train? x, Train? y)
    {
        return !(x == y);
    }

    // IEquatable<T>
    public bool Equals(Train? other)
    {
        return this == other;
    }
}

I don’t know how everyone else likes to do it, but I tend to define equality in just one of the methods, and then have the other ones call it. It keeps the code more DRY, and more easily updated later on if needed.

Now if we create a couple of trains and test to see if they’re equal, they are:

var train1 = new Train("Odakyu", "3000", 1958);
var train2 = new Train("Odakyu", "3000", 1958);

Console.WriteLine(train1.Equals(train2));  // true
Console.WriteLine(train1 == train2);       // true

Records (with equality built-in)

#

What’s great about records is that a lot of these extra steps (aka ceremony) goes away.

Here’s roughly the same class as above, with a different name and marked as a record this time. We could include the keyword class in there too, since it is one, but it’s unnecessary and can be left out.

public record Automobile(string Make, string Model, int Year);

Nearly everything that was defined in the Train class is gone, automatically generated for us behind the scenes! The parameters we define in the primary constructor get matching properties automatically, without us having to manually define them.

These properties are init-only properties, since records are intended to represent “immutable data models”, so by default we can’t change values after a record is initialized. Instead, we’re meant to create a new instance using a with expression:

var kia = new Automobile("Kia", "Forte", 2016);
var newerKia = kia with { Year = 2021 };

Console.WriteLine(kia);
Console.WriteLine(newerKia);
Console.WriteLine(kia == newerKia);  // false