Solve real coding problems
Since VS2019, you can set multiple startup projects in the solution’s properties. This is useful when you have multiple projects in the same solution that you want to start at the same time (with or without debugging). Before this, you’d have to set a project as the startup project, start it, then repeat with all … Read more
When you have the Nullable Reference Types feature (Nullable for short) enabled, one of the warnings you’ll run into is the following: CS8618 Non-nullable property X must contain a non-null value when exiting constructor. This warning doesn’t make sense in a very common scenario: You can just ignore the warning when it applies to DTOs. … Read more
Warnings are easy to ignore and forget about, which isn’t good. They point out potential problems that you might want to fix. To make it easier to pay attention to warnings, you can treat them like errors. You can choose which warnings to treat like errors by using settings in the project file. There are … Read more
The main purpose of the Nullable Reference Types (NRT) feature is to help prevent NullReferenceExceptions by showing you compiler warnings. You can make a reference type nullable (ex: Movie? movie) or non-nullable (ex: Movie movie). This allows you to indicate how you plan on using these references. The compiler uses this info while analyzing actual … Read more
When you don’t want to create classes for JSON (de)serialization, one option is to use JsonNode. This allows you work with JSON as a mutable DOM that consists of JsonNode objects (JsonObject, JsonArray, JsonValue). You can use it to read, write, and modify JSON. Here’s an example. Let’s say you have the following JSON that … Read more
The simplest way to filter a dictionary is by using the Linq Where() + ToDictionary() methods. Here’s an example: Note: You can use the Dictionary constructor (new Dictionary<string, int>(filterList)) instead of ToDictionary() if you prefer. This produces a new dictionary with the filtered item: Where() produces a list (actually an IEnumerable) of KeyValuePair objects. Most … Read more
In .NET 5 and above, you can directly change a dictionary’s values in a foreach loop. Here’s an example: This outputs the following: You couldn’t do this before .NET 5, because it would invalidate the enumerator and throw an exception: InvalidOperationException: Collection was modified; enumeration operation my not execute. Instead, you’d have to make the … Read more
A time zone’s UTC offset can change based on the time of year due to daylight savings time. One problem with the TimeZoneInfo class is that TimeZoneInfo.DisplayName always shows the base UTC offset, even if the current date is in daylight savings time. This may be confusing to users (and this is the same thing … Read more
Time zones are complicated and their rules can change, so it makes sense to use a library when you’re dealing with them. One option in .NET is to use the built-in TimeZoneInfo class. Here’s an example of using TimeZoneInfo to get the local system’s time zone: This outputs: Note: The display name always show the … Read more
The simplest way to get the key with the max value in a dictionary is to use the Linq MaxBy() method (added in .NET 6). This returns the key/value pair with the max value. Here’s an example: This outputs the following: In this article, I’ll show examples of getting the max by key, min by … Read more
Here’s an example of how to get the current date/time: This outputs the current local date/time: Note: By default, it uses the current culture’s format (from the OS). This is showing the US date format – MM/dd/yyyy. DateTime.Now is the local date/time from the system where the code is executing. Keep that in mind if … Read more
When you loop through a dictionary, whether it’s with a foreach or with a Linq method, you’ll be dealing with KeyValuePair objects, which have Key and Value properties (same types as the dictionary). Here’s an example of how to loop through a dictionary with a foreach: Note: The loop variable (kvp) is a KeyValuePair<string, int> … Read more
Forms also have a collection of controls (Controls property) that you can loop through. This is useful for when you want to do something to multiple controls and don’t want to have to manually type out code to deal with individual controls. Here’s an example of looping through a form’s top-level controls: Note: In the … Read more
By default, when you load enum values into a ComboBox, it’ll show the enum names. If you want to show the enum descriptions (from the [Description] attribute) instead, and still be able to get the selected enum value, you can do the following: Generate a list of objects containing the enum value/description pairs. Set ComboBox.DataSource … Read more
When you’re using reflection to look at a type’s properties, you can use PropertyInfo.PropertyType.IsEnum to check if the property is an enum. This is helpful when you want to be able to safely call an Enum API method (such as Enum.Parse()) on the reflected type, thus preventing an exception – ArgumentException: Type provided must be … Read more
The CA2208 code analysis rule checks for common mistakes when constructing argument exceptions. There are three main argument exception classes: ArgumentException, ArgumentNullException, and ArgumentOutOfRangeException. Unfortunately, it’s easy to make a mistake when using these. I’ll explain the common mistakes that CA2208 checks for and how to fix them (and when to suppress the warning instead). … Read more
Mapping classes to UI controls manually is probably the most tedious thing you can do in coding. In order to minimize this coding effort, you can bind your controls to an object data source. In this article, I’ll show how to do this in a WinForms App (.NET Core) project. First, I’ll show step-by-step how … Read more
In this article, I’ll explain the Zig Zag Sequence algorithm problem on HackerRank. Problem statement: You’re given an integer array with an odd number of elements (ex: [5, 2, 3, 1, 4]). You need to re-arrange the elements so they’re in a zig zag sequence, which means: The first half of elements (first to middle) … Read more
When you want to share a file between multiple projects, instead of duplicating the file’s contents, you can add a link to the existing file. You can link any type of file, but it’s most commonly done with config / source files. Here’s an example of adding appsettings.json as a linked file: In the project … Read more
There are two ways to get request headers: When a request comes in, the framework loads request headers into the Request.Headers dictionary. You can use this just like any other dictionary. Here’s an example of using TryGetValue() to check if a request header exists and get its value: Note: To just check if a header … Read more
When you use the Implement Interface quick action in Visual Studio, it generates all members that throw exceptions, even the property getters and setters: This is fine for methods, but not for properties. You’d expect it to generate auto properties. Instead, it generates getters/setters that you then have to go clean up. Fortunately, this behavior … Read more
When you use HttpClient to make requests, you can directly get the status code from the HttpResponseMessage object, like this: The main reason for checking the status code is to determine if the request was successful and then reacting to error status codes (usually by throwing an exception). The HttpResponseMessage class has two helpers that … Read more
I came across this scenario recently where I needed to use reflection to get the properties declared in a subclass, and then get the properties declared in the base class. I had to handle these sets of properties differently. Here’s an example. Consider the following two classes. PersonBase is the base class. Driver is the … Read more
Problem details (RFC7807) is a standardized error response format that has a Content-Type of application/problem+json, an error response code (i.e. 400 – Bad Request), and has a response body that looks like this: This can be extended to include any number of properties. The example shown above comes from the default way ASP.NET Core returns … Read more
When you’re using XML documentation comments in your code, eventually the comments will get out of sync with the code. This is especially true for method parameters, which are documented by <param> tags. When you add, delete, or rename a parameter manually, it’s easy to forget to update the <param> tags. Fortunately, the compiler detects … Read more
