DEV Community: Jan Doubek

Inspiration is Everywhere: 5 Diverse Sources to Tap Into

Jan Doubek — Tue, 06 Jun 2023 15:20:35 +0000

One key reason I find myself drawn to social media is its power to inspire through the diverse perspectives of people.

People tweeting or blogging about stuff they do or like, youtube videos and podcasts on different topics, all of these embed little hints, which may trigger some form of positive response in your brain, causing it to reshape your perspective or spur you into action.

My aim with this post is to unveil my top five sources of inspiration. Perhaps they'll spark a little inspiration for you too, or who knows, they could even potentially change the course of your life. :)

Inspiration #1 - Lex Fridman Podcast

The diversity of guests on this podcast and also the depth to which some of the topics are discussed are what make this podcast truly inspiring. Each podcast provides profound insights which always teach me something new - both professionally (when the podcasts are technically oriented, such as discussing programming languages or AI) and personally (when guests are experts in relationships, parenting, etc.).

Find Lex's podcast on YouTube here: https://www.youtube.com/@lexfridman

Inspiration #2 - Scott Hanselman's Tweets

Among the many tech influencers these days, Scott Hanselman stands out as particularly engaging. He's an expert in a wide range of technical subjects, from software development and system architecture to productivity hacks and career advice.

What I appreciate the most about following him though is his ability to keep up to date with developments in both the technical and non-technical realms, and his eagerness to share these insights with his followers.

Follow Scott at https://twitter.com/shanselman

Inspiration #3 - Travis Eliot's Life Wisdom

Travis isn't just an excellent yoga instructor (you can get a taste of his yoga classes on his YouTube channel or his online yoga studio, Inner Dimension), but he also generates content around healthy living, mindfulness, and life wisdom. His podcast series, The Be Ultimate Podcast, features over 80 episodes packed with knowledge and tips for healthier living. I wholeheartedly recommend his content to anyone in the tech industry, as yoga, meditation and mindfulness are the perfect antidotes to the materialistically-focused world of tech.

https://www.youtube.com/@traviseliotyoga

https://www.innerdimensiontv.com/

Inspiration #4 - John Green's Books

John is an excellent writer and his books are always unconventional and entertaining. But they offer more than just leisure; through John's deep understanding of the teenage experience, I also gain invaluable insights into the world that my children navigate every day.

You can discover John Green's collection of books on platforms like Goodreads.

Inspiration #5 - Hashnode Blogs

Last, but certainly not least, my recently discovered passion - blogging.

Producing content and sharing thoughts through blogging in general is something I truly enjoy, though it can sometimes be a challenging task. Hence, I need both inspiration and a seamless and hassle-free blogging process.

That's exactly where Hashnode shines. It enables me to produce content without getting bogged down by worries about hosting, backups or struggling with the syntax of markup languages.

What's more, Hashnode has an incredible community of professionals who produce content regularly. This community provides a large initial audience for my writing. But perhaps even more important, I can always find new inspiration and motivation by reading what other Hashnode bloggers write about.

If you haven't already, go ahead and give Hashnode a try at https://hashnode.com/.

The Journey Continues...

Did you find inspiration in any of these resources? Great! Please share your thoughts in the comments below.

If however none of these resonated with you, I would recommend that you at least take a look through some of my previous posts on the My Dev Tricks website.

Python Made Easy: Your Step-by-Step Journey with ChatGPT

Jan Doubek — Tue, 28 Feb 2023 14:12:05 +0000

Whether you're a seasoned Microsoft tech stack developer or just starting out, this tutorial is the ideal place to begin your Python journey. And, to sweeten things up a little bit, you're going to use ChatGPT to help you get started!

Without further ado, let's dive into the tutorial and start learning Python!

Step #1 - Install Python

First, download the latest version of Python for Windows from the Python Downloads page.
Execute the downloaded installer package.
In the Python installer UI, take the quick path by clicking on the Install now button. Be sure to check the "Add python.exe to PATH" option, as this will at a later point make it possible to execute python and pip from the command line.

Once installed, proceed to the next step to get the development environment ready.

Step #2 - Install Visual Studio Code

We'll be using Visual Studio Code as our Python programming playground. VS Code is my go-to development environment for open-source development languages. Read more about it in my previous blog post 5 Awesome Visual Studio Code Features.

Download VS Code from code.visualstudio.com.
Run the installer, accepting default installation options.

Once the installation finishes, open Visual Studio Code to set up the necessary extensions.

Step #3 - Install Python Extensions

If you're new to Visual Studio Code, I recommend going through some basic usage tutorials first. The Getting Started section of the official VS Code documentation seems like a great place to start learning.

To get syntax highlighting, IntelliSense and debugging support for Python scripts, we'll need to install some Visual Studio Code extensions.

Open the Extensions panel
Search for "python"
The first extension found should be Python (by Microsoft).
Click Install to install the extension.

You're now set up to start writing your first python script!

Step #4 - Our Very First Python Script

Before we delve into writing Python code, let's create a very basic "project" for the code files. In Visual Studio Code, the easiest way how to do this is to open a folder on your local drive:

In VS Code, go File->Open Folder
Open a folder on your drive, for example, C:\Dev\PythonTest.
When prompted, click "Yes, I trust the authors".
In the File Explorer panel, click on the New File icon and specify test1.py as the name of the new python file.
Add the following content to the file and save:
```
print("Hello!")
```

We're now ready to run and debug our python script for the first time!

Step #5 - Debug and Run

As with most programming languages, there are two basic ways how to execute scripts written in Python: Debug and Run.

To Debug the Python script in Visual Studio Code, go Run->Start Debugging, or press F5.

The first time you do this, you will be asked to select a debug configuration. Pick the "Debug File - Debug the currently active Python file" configuration. This option is sufficient for our simple tests. For more complex debugging scenarios, check out the Python debugging in VS Code documentation.

To Run the Python script in Visual Studio Code, go Run->Run Without Debugging, or press Ctrl+F5.

In both cases, you should get the following Output written into the VS Code Terminal window:

Hello!

Voila, you just executed your very first Python script!

Step #6 - Get Your Code on with ChatGPT Code Snippets

Being inspired by a recent post of a fellow blogger Jens Caasen and his article 12 ways to make ChatGPT your personal Junior Developer (with examples), I've decided to ask ChatGPT to help us come up with some fun introductory Python code snippets.

Utilizing ChatGPT to get you started with Python is a great choice for (at least) two reasons:

You can quickly get sample code for topics that interest you, for example: For loops, JSON, Rest API, etc.
You get to sharpen your ChatGPT usage skills. ChatGPT and AI in general are the future and the faster we adopt (and accept) it, the bigger competitive advantage we'll get!

Snippet #1: 99 Bottles of Beer on the Wall

For starters, we're going to ask for some very basic Python sample code:

Me: what would be a useful but fun snippet of Python code for someone who's very new to the Python language?

for i in range(99, 0, -1):
    print(f"{i} bottles of beer on the wall, {i} bottles of beer.")
    print(f"Take one down, pass it around, {i - 1} bottles of beer on the wall.")

ChatGPT: This code snippet uses a for loop and the range() function to count down from 99 to 1, and the print() function to print the lyrics of the song. It also makes use of string interpolation (f"{...}") to insert dynamic values into the string being printed. This code snippet is a simple example of how you can use Python to automate repetitive tasks and generate fun output!

(emphasis mine)

Snippet #2: How Tall Are You?

This time we ask for a sample illustrating a specific language construct:

Me: something illustrating the if/else condition?

height = float(input("Enter your height in meters: "))

if height >= 1.8:
    print("You are tall!")
else:
    print("You are not tall.")

ChatGPT: This code snippet uses an if statement and an else clause to determine if a person's height is greater than or equal to 1.8 meters. If the height is greater than or equal to 1.8, the code will print "You are tall!"; otherwise, it will print "You are not tall.". This simple code snippet demonstrates how you can use the if statement and the else clause in Python to make decisions based on conditions.

Snippet #3: List of European countries using REST and JSON

Now let's try something a little more complex:

Me: How about an example importing a library, reading a publicly available json file containing world countries and then listing all European countries?

import requests
import json

response = requests.get("https://restcountries.com/v3.1/all")
countries = json.loads(response.text)

european_countries = [country["name"]["common"] for country in countries if country["region"] == "Europe"]

print("European Countries:")
for country in european_countries:
    print("-", country)

ChatGPT: This code snippet first imports the requests library, which allows you to send HTTP requests, and the json library, which provides functions for encoding and decoding JSON data. It then uses the requests.get() function to send a GET request to the endpoint "https://restcountries.com/v3.1/all" to retrieve information about all countries in the world. The json.loads() function is then used to parse the JSON data returned in the response.

Next, the code uses a list comprehension to create a list of common names of countries located in the region "Europe". Finally, the code uses a for loop and the print() function to print the names of all European countries.

This code snippet demonstrates how you can use the requests and json libraries to retrieve information from a publicly available API and process the data in Python.

Good. However, with the default setup of Python and Visual Studio Code that we've established, this example does not work:

Let's ask ChatGPT to fix it:

Me: I'm getting an error saying: Import "requests" could not be resolved

ChatGPT: It seems like you don't have the requests library installed in your Python environment. You can install it using the following command:

pip install requests

Make sure you have the pip package manager installed, and run the command in your terminal or command prompt. After the installation is complete, you should be able to import the requests library in your Python code.

And indeed, as suggested, once we install the requests library using the pip package manager, the code works and outputs a list of European countries.

Great job, ChatGPT! 👏👏

That's a Wrap

I could be going on with the examples for hours, most likely learning something new with every new code snippet generated by ChatGPT.

However, let's leave some room for your own experimenting.

And don't forget to share any fun or interesting content that you and ChatGPT come up with in the comments!

Is PostgreSQL a worthy alternative to Microsoft SQL Server?

Jan Doubek — Tue, 07 Feb 2023 13:00:00 +0000

In line with the title of this blog, I'd like to start posting articles about languages, tools and technologies that I got a chance to use recently.

One of the technologies that I was lucky to learn is PostgreSQL.

I have always been an avid Microsoft technology stack advocate, so naturally most of the time my RDBMS system of choice was Microsoft SQL Server. Now, I'm still holding my opinion that Microsoft SQL Server is a great product, which scales wonderfully from small web applications to large enterprise solutions. The fact however is that for any non-trivial applications, i.e. once the database system requirements outgrow the potential of the free SQL Server Express edition, licensing costs may start to become an issue. And that is (at least for me) exactly the point at which PostgreSQL comes into play.

At a glance

PostgreSQL is a powerful, open-source relational database management system. Feature-wise PostgreSQL is comparable to Microsoft SQL Server, at least when it comes to RDBMS features. It scales well for large workloads and at the same time - you guessed it - it remains free.

My Favorites

There is a ton of introductory articles about PostgreSQL on the web. Rather than adding another one, let me just highlight some of the features that I like and enjoy about PostgreSQL:

PostgreSQL is easy to install

The quick and straightforward installation of PostgreSQL is a big contrast to the bulky and slow Microsoft SQL Server installer.

You may start your database adventures within minutes of downloading the software.

The PostgreSQL installation process typically involves downloading the software, running the installer, and specifying a few basic configuration settings. If you also opt to install the pgAdmin GUI tool (a PostgreSQL counterpart to SQL Server Management Studio), you may start your database adventures within minutes of downloading the software.

Good compatibility with Microsoft SQL Server

I was pleasantly surprised when testing the compatibility between the two systems. I mean, there certainly are areas in which the syntax differs, but overall it's not bad at all.

And for cases where you're porting existing solutions based on Microsoft SQL Server to PostgreSQL, you can take advantage of 3rd party tools that make it easier to perform an initial migration of your SQL server database schemas into PostgreSQL. After evaluating a few of these tools, my ultimate recommendation goes to MSSQL-to-PostgreSQL. This small and easy-to-use tool is fast and performs most of the type conversions automatically.

Query execution speed

Query execution speed constitutes one of the crucial factors of a good database system. In my mind, Microsoft SQL Server has always been a synonym for speed, especially when it comes to large enterprise-grade workloads. And honestly, it might've been concerns about query execution speed, which prevented me from even trying out alternative RDBMS solutions before.

PostgreSQL's Query Optimizer does a very good job of consistently delivering efficient query execution plans, resulting in a solid performance.

Well, with PostgreSQL, I was pleasantly surprised. Query speeds are very good. I don't want to compare SQL Server and PostgreSQL execution speeds here, as I have not done any rigorous speed comparison, but given all the years of working with different versions of SQL Server, I must admit that PostgreSQL's Query Optimizer does a very good job of consistently delivering efficient query execution plans, resulting in a solid performance. I'm yet to test large workloads on PostgreSQL, but so far I'm optimistic that PostgreSQL will be able to handle all possible levels of workloads with ease.

Check out the following screenshot of the Explain feature of pgAdmin. This tool greatly helps with analyzing and troubleshooting PostgreSQL query performance.

Entity Framework Core provider

One of my concerns when considering supporting a non-Microsoft RDBMS system was how good and mature the implementation of its Entity Framework Core database provider would be. Entity Framework Core represents an important piece of the Microsoft technology stack puzzle. An incomplete or buggy Entity Framework provider could make supporting the PostgreSQL data storage a nightmare.

And yet again, I got pleasantly surprised. Npgsql - the recommended ADO.NET and Entity Framework (Core) provider - makes the adoption of PostgreSQL an almost seamless experience. Additionally, the Npgsql provider implements those PostgreSQL language elements, which are not present in the Microsoft SQL Server world. Let me mention here at least support for the ILIKE operator, as well as a range of functions related to the PostgreSQL's LTree data type.

Here's a short snippet of code that illustrates how easy it is to start using PostgreSQL in your Entity Framework Core application:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<TestContext>(options => 
        options.UseNpgsql(Configuration.GetConnectionString("TestContext")));
}

Wrapping up

From the paragraphs above, one could get the idea that everything is perfect with PostgreSQL and that the language and feature compatibility with Microsoft SQL Server is flawless. Well, no - not exactly. Over time I came across several compatibility and tooling issues (Aargh - those unexpected pgAdmin crashes!). But let me leave those to a future blog post.

Overall, I find PostgreSQL to be a great (and free!!) alternative to Microsoft SQL Server.

In the spirit of a book from my favorite author John Green - The Anthropocene Reviewed - I'm giving PostgreSQL ⭐⭐⭐⭐ (4) stars!

ToLookup or not ToLookup, that is the question!

Jan Doubek — Sun, 30 May 2021 08:23:00 +0000

Shakespeare will hopefully forgive me for abusing a line from his famous Hamlet. In my post, I won't be covering questions of life and death, but rather something much more prosaic - a lesser-known LINQ materialization method - ToLookup.

We all know the famous LINQ materialization methods trio - ToArray, ToList, ToDictionary. There's another such method, which, similarly to the other ones, can be quite useful. The other method is Enumerable.ToLookup().

Here's a description of ToLookup from the Microsoft Docs page:

The ToLookup method returns a Lookup, a one-to-many dictionary that maps keys to collections of values.

Ok, so ToLookup is similar to the ToDictionary method. There's one subtle, but important difference though. With Dictionary, which is basically a typed hash table, you are allowed to associate only a single value to each key, i.e. there's always a one-to-one mapping between keys and values. ToLookup on the other hand lets the user store a collection of values for each key, i.e. effectively creating a one-to-many mapping.

That's it for theory. Let's have a look at some examples.

ToLookup Examples

In the first example, we'll use ToLookup to split up a collection of numbers into two collections containing even and odd numbers.

var numbers = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };

// Using explicit types instead of 'var' for better explicability
ILookup<bool, int> evenNumbersLookup = numbers.ToLookup(num => (num % 2) == 0);
IEnumerable<int> evenNumbers = evenNumbersLookup[true];
IEnumerable<int> oddNumbers = evenNumbersLookup[false];

Console.WriteLine("EVEN: " + string.Join(',', evenNumbers));
Console.WriteLine("ODD:  " + string.Join(',', oddNumbers));

Output:

EVEN: 2,4,6,8
ODD:  1,3,5,7

The key of the lookup table here is a boolean determining whether the number is even or odd. The value is a collection of integers satisfying the even/odd condition.

Simple, yet effective.

The lookup key does not necessarily have to be a true/false value - it can be of any type. In the following example, we use ToLookup together with an indexed select to split an input set of numbers into groups of 3 elements.

(Check out one of my previous LINQ Gems articles for more info about indexed select.)

var numbers = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };

ILookup<int, int> groupedNumbersLookup = numbers
    .Select((num, seq) => (num, seq))
    .ToLookup(key => (key.seq / 3), val => val.num);

var i = 0;
while (groupedNumbersLookup.Contains(i))
{
    Console.WriteLine($"GROUP {i+1}: " + string.Join(',', groupedNumbersLookup[i]));
    i++;
}

The output will be:

GROUP 1: 1,2,3
GROUP 2: 4,5,6
GROUP 3: 7,8,9
GROUP 4: 10,11,12

And, naturally, the key of the lookup table is not restricted to numbers only. Here is a nice example of a lookup table having a string key:

var carsInStock = new[]
{
    new { Make = "Ford", Price = 10000 },
    new { Make = "Ford", Price = 15000 },
    new { Make = "Ford", Price = 20000 },
    new { Make = "Honda", Price = 15000 },
    new { Make = "Honda", Price = 25000 },
    new { Make = "Jeep", Price = 20000 },
};

var carValues = carsInStock.ToLookup(key => key.Make, val => val.Price);

int fordCarsValue = carValues["Ford"].Sum();
int hondaCarsValue = carValues["Honda"].Sum();

Console.WriteLine($"Total value of all Ford cars in stock: ${ fordCarsValue }");
Console.WriteLine($"Total value of all Honda cars in stock: ${ hondaCarsValue }");

Gives us the output that we'd expect:

Total value of all Ford cars in stock: $45000
Total value of all Honda cars in stock: $40000

Some Noteworthy Facts

Similarly to all the other ToXXX() methods, ToLookup as well uses immediate execution to populate the returned Lookup table. Any changes to the original sequence (after the method has returned) won’t change the elements stored in the lookup.
The ILookup<TKey,TElement> interface returned by the ToLookup call is read-only. It is therefore not possible to append or otherwise modify the lookup table. This is in contrast with IDictionary<TKey, TValue> returned by ToDictionary, which constitutes a fully mutable collection of key/value pairs.
If you request a sequence for a key, which is not present inside of the lookup table, you'll get an empty sequence. Again, compare this behavior to Dictionary, which will throw a KeyNotFoundException for non-existing keys.
There is another extension method available, which is almost identical in behavior to what ToLookup does. That method is GroupBy. Really the only difference between these two methods is that GroupBy uses deferred execution, while ToLookup's execution is immediate.

Additional Resources

For a thorough deconstruction of the ToLookup method, see John Skeet's great article Reimplementing LINQ to Objects Part 18 – ToLookup.

Conclusion

As you can see, the usage of ToLookup is quite versatile. My favorite use case (by far) is the ability to split up a sequence of values into 2 sequences using a single line of code (described in the first example above).

Have you ever used ToLookup in your code? If yes, what was the use case? Share your thoughts in the comments!

If you find this post interesting, be sure to check out other posts on my blog mydevtricks.com.

5 Awesome Visual Studio Code Features

Jan Doubek — Fri, 14 May 2021 12:54:23 +0000

TL;DR: Visual Studio Code is great and I highly recommend it to every developer (not only for Visual Studio classic users). If you're interested in why I actually think it's great, read on!

I'm a long-term user of Visual Studio. In fact, I've been extensively using it in my jobs since the Visual Studio 6.0 release. A really long time. And I must admit that I'm more than aware of its shortcomings - slow startup times, slow project load times, occasional crashes, to name a few.

Just recently I got introduced to Visual Studio Code. Not for my day-to-day job, but mostly for side projects. And I must say I fell in love with it. Its simplicity yet great extensibility and power make it perfect for quickly setting up and developing sample projects, tutorials, and, naturally, production applications too.

Visual Studio Code is perfect for quickly setting up and developing sample projects, tutorials, and, naturally, production applications too.

Let me share with you 5 features of Visual Studio Code, which I enjoy the most and which I honestly hope were present in the classic Visual Studio too.

1. Visual Studio Code is blazing fast

Speed is by far the greatest quality of Visual Studio Code. The speed of almost anything that you can do with it, such as:

Application startup
Opening a workspace/folder
Creating new files
Using the code editor
Installing and updating extensions
GIT operations

And the list could go on.

The startup speed and folder opening speed are definitely the most important for me, as I'm mostly using Visual Studio Code for smaller projects, which I need to bring up (and close) quickly. Quick code/build/debug process turnaround is also a crucial factor in my daily activities.

2. No cumbersome projects, just Folders

What? There are no projects in Visual Studio code? At first, I felt a little bit lost. As a long-term user of Visual Studio, I've been dealing with a myriad of different types and versions of projects.

But then I got it - Visual Studio Code is primarily a code editor! What that means is that you just need a way of opening files and organizing them somehow. And since that organization is most of the time already present in the form of OS folders, the actual projects are redundant. As simple as that!

Visual Studio Code is primarily a code editor.

Well, to be fair, Visual Studio classic projects are used for more than just organizing files (in fact, in the latest Visual Studio versions, some project types do not store file lists anymore). Project files also store additional configuration data, task definitions and build info. So where does all this extra configuration exist in Visual Studio Code? The answer is simple - in JSON files:

Debug/Run configuration is stored inside of launch.json
Tasks are configured in tasks.json
Project settings are configured via settings.json

I think it's a neat solution, especially since some of them (like settings.json) you can create at multiple levels (user, workspace).

3. Powerful Extensions ecosystem

In Visual Studio Code, extensions are an integral part of the code editor. What does that mean?

Searching for extensions and displaying extension info is fast
An extension of your choice gets installed very quickly and without the need to restart the editor/IDE!
You get smart suggestions for extensions that might be suitable for you and your workflow
There are just a few core extensions included out-of-the-box, which means that the initial installation of Visual Studio Code is quick and does not take up unnecessary disk space

The number of available extensions and the languages/debuggers/tools that these extensions cover is astonishing. Just take a look at the list of eight of the most popular language extensions (screenshot taken on the Visual Studio Code docs Programming Languages page):

And if a suitable extension is not available yet? Just write your own using the Extension API.

4. Integrated Terminal

I've always been a "UI for everything" kind of guy. No wonder - with Visual Studio, you get extensive Tooling, which lets you use a fancy UI/wizard for almost anything, starting with the creation of a file or project and ending with complex build and publishing wizards.

Visual Studio Code takes a different approach. A significant portion of the functionality it offers relies on command line tools. And in order to ensure that the command line tools can be executed in a quick and efficient way, Visual Studio code includes an integrated Terminal.

You can easily bring up a new Terminal using the Ctrl+ ` key combination. You can open multiple terminal windows and easily navigate between them. Visual Studio Code also lets you pick the default shell for your integrated Terminal - PowerShell, bash, etc.

Overall, once you start using the Terminal to execute some common tasks and actions, you quickly realize that it is a much faster and flexible alternative to the static and often outdated UIs and wizards.

5. Snippets

I've discovered Snippets in Visual Studio Code just recently, but I see great value in learning how to use and customize them.

A great example of when Snippets come in handy is with the Django page templates. And, naturally, Snippets can be defined at both global (language) and project levels. Using project-level Snippets lets you create different templates with styles tailored to the needs of each project separately.

If you're interested in discovering more about Snippets, check out the official Snippets in Visual Studio Code page.

Conclusion

Are you a Visual Studio (2019) user and have you not tried Visual Studio Code yet? I highly recommend checking it out. It's worth learning - you can use it for side projects, tutorials, or maybe as a markdown editor for writing blog posts.

What is your favorite Visual Studio Code feature? Share your experience in the comments below!

If you find this post interesting, be sure to check out other posts on my blog mydevtricks.com.

3 Easy Steps to Set Up Certificate Authentication in ASP.NET Core

Jan Doubek — Tue, 13 Apr 2021 04:27:17 +0000

Ever wondered how to configure a simple yet secure authentication method in ASP.NET Core? Read on!

This article aims to give you a minimum set of steps necessary to configure certificate-based authentication in ASP.NET Core.

At the end of the article, I'll give you a list of more detailed resources, including a link to my test GitHub repo.

Who is certificate authentication for?

Here are a few typical scenarios that will benefit from certificate-based authentication:

Authenticating users in a corporate (intranet) environment
Communication between applications or APIs
Identifying IoT devices for server resources access

Configuration steps

Here are the 3 steps:

Configure the server (IIS)
Create and install a self-signed certificate
Set up the ASP.NET Core app for certificate authentication

Step #1: Configuring IIS

The actual validation and verification of a client certificate take place inside of IIS. We therefore need to configure IIS correctly to recognize and accept certificates.

Open the IIS Manager. Find the web application which you want to configure. In the Features View open SSL Settings.

Inside of the SSL Settings, check the checkbox next to "Require SSL" and select the "Client certificates: Require" option.

This will instruct IIS to accept (and require) client certificates and verify them before allowing the request to be passed over to our ASP.NET Core application.

Note: My test setup uses IIS as the host for the website. If you're using Kestrel to host your app, please, refer to the Kestrel configuration code in my example repo, or check out the official Microsoft documentation.

Step #2: Installing a client certificate

Next, we need to prepare the client certificates. The easiest option would be using certificates issued by a browser-trusted CA (GoDaddy, Comodo, etc.). In the case of an intranet application however, we can just safely go with self-signed certificates.

We'll accomplish the self-signed certificate installation in 2 steps. In the first step, we'll issue a new self-signed client certificate. The second step will then make the certificate trusted on the webserver.

Here is a PowerShell script to generate a new self-signed client certificate (valid for two years) and store it in the user's personal certificates store:

New-SelfSignedCertificate -certstorelocation cert:\CurrentUser\my `
    -Subject "Test User" -FriendlyName "Test client certificate" `
    -NotAfter (Get-Date).AddYears(2) -KeyUsageProperty Sign `
    -KeyUsage CertSign, CRLSign, DigitalSignature

In the User Certificates control panel you can now observe that a new certificate has been created inside of the Personal certificates store:

From here you can export the public key of the client certificate into a .cer file.

On the webserver, where IIS is installed, you have to install the certificate stored in the CER file, placing it into the Computer Certificates' Trusted roots store.

Great! We have prepared the client certificate, making it ready to be used on both client and server sides.

Step #3: ASP.NET Core authentication setup

Lastly, we are going to set up certificate authentication in our ASP.NET Core application.

The support for certificate authentication resides in a separate NuGet package. Therefore, let's first add the Microsoft.AspNetCore.Authentication.Certificate package to our app.

Now that we have support for certificates added, the only step remaining is correctly configuring our authentication pipeline. We do that by including the following code in our Startup.ConfigureServices method:

services
    .AddAuthentication(CertificateAuthenticationDefaults.AuthenticationScheme)
    .AddCertificate(options =>
    {
        options.AllowedCertificateTypes = CertificateTypes.All;
    });

There are several options that allow fine-tuning the behavior of the certificate authentication handler. In our case, we only changed the AllowedCertificateTypes option, to accept both chained and self-signed certificates (by default, only chained certificates are accepted).

Note that the Microsoft.AspNetCore.Authentication.Certificate package has been introduced in ASP.NET Core v3.0. If you're using a version of ASP.NET Core older than 3.0, you have to resort to a compatibility package created by Barry Dorrans named idunno.Authentication.Certificate.

Also, don't forget to actually add the authentication middleware to your ASP.NET Core request processing pipeline. Do this inside of the Startup.Configure method implementation:

app.UseAuthentication();

Seeing it in action

When the Web API is called from a browser (e.g. Chrome), you are asked to provide a client certificate:

The webserver will then validate the certificate and if OK, the request will be sent to your ASP.NET Core Web API. The example response will look something like this:

Test API call successful! Certificate Subject Name: Test User

If on the other hand you do not specify a certificate, or you select an invalid/untrusted certificate, you'll receive an error response:

HTTP Error 403

ERR_BAD_SSL_CLIENT_AUTH_CERT

Check out the full sample in my GitHub repo:

jd-cz / AspNetCertTest

AspNetCertTest

This is a sample repo for my blog post 3 Easy Steps to Set Up Certificate Authentication in ASP.NET Core. The example uses Kestrel as a server host for the ASP.NET Core application.

Check out the article on my blog My Dev Tricks for details.

View on GitHub

Other resources

Microsoft Docs article describing Certificate Authentication:

Configure certificate authentication in ASP.NET Core

A neat article explaining the general benefits of using certificate-based authentication:

What Is Certificate-Based Authentication and Why Should I Use It?

Conclusion

Use these 3 easy steps and you'll secure access to your ASP.NET Core controllers by letting only the clients holding the client certificate invoke the controller functionality.

Pro Tip: For an even more secure setup, you can play with the various options available to the AddCertificate() call, for example implementing custom validation based on a certificate property.

Do you find authentication using client certificates useful? Let me know in the comments. Also, if you enjoyed this article, please, share it with your friends and colleagues!

If you find this post interesting, be sure to check out other posts on my blog mydevtricks.com.

LINQ gems: Troubles with Out Parameters

Jan Doubek — Fri, 26 Mar 2021 05:14:45 +0000

How do you deal with out parameters inside of LINQ queries?

Almost every time I come across the need to invoke a method inside of a LINQ query, which uses an out argument, I need to stop for a moment and think about what the correct solution is. And unfortunately, there does not seem to be a solution, which is the obviously right one.

One of the typical examples of consuming an out variable is when accessing the elements of a Dictionary using the TryGetValue method. In the sample code I'll be using below, we have a dictionary of common English words together with their usage counts (perhaps extracted from a piece of text somewhere). We then declare an array of test words, for which we want to obtain their usage count (and eventually sort by it).

Using a local variable

Using a local variable is probably the first thing that a developer will try:

Dictionary<string, int> wordUsage = new Dictionary<string, int>
{
    { "hello", 100 },
    { "world", 20  },
    { "use", 75 },
    { "case", 10 }
};

var testWords = new[] { "hello", "world", "use", "case" };

int usageVar = 0;
var query = 
  from word in testWords
  let wordFound = wordUsage.TryGetValue(word, out usageVar)
  select (word, usageVar);

foreach (var (word, usage) in query)
{
    Console.WriteLine($"Word: '{word}' is repeated {usage} time(s).");
}

So far, everything works as expected:

Word: 'hello' is repeated 100 time(s).
Word: 'world' is repeated 20 time(s).
Word: 'use' is repeated 75 time(s).
Word: 'case' is repeated 10 time(s).

If we now however add a request to sort the output by the usage count:

var query = 
  from word in testWords
  let wordFound = wordUsage.TryGetValue(word, out usageVar)
  orderby usageVar
  select (word, usageVar);

Things start to break apart:

Word: 'hello' is repeated 10 time(s).
Word: 'world' is repeated 10 time(s).
Word: 'use' is repeated 10 time(s).
Word: 'case' is repeated 10 time(s).

Why? Because OrderBy requires the whole sequence to be processed, before it can perform a sort on the elements of the sequence. What it means is that the let projection will execute on all elements in our sample set and the very last processed element in the set (the word 'hello') will assign a value of '10' to the local variable usageVar. This value is then passed four times into the orderby statement. Which is obviously wrong.

So, using a local variable is clearly not the way to go. What are the alternatives then?

Local function

Local functions are a concept introduced in C# 7.0. They let you declare a method inside the body of another method. What we can therefore do is create a simple helper method, which establishes a local scope for the out variable needed by the TryParse method, thus making the usage of the local variable safe.

public static void OutTestUsingLocalFunction()
{
    Dictionary<string, int> wordUsage = new Dictionary<string, int>
    {
        { "hello", 100 },
        { "world", 20  },
        { "use", 75 },
        { "case", 10 }
    };

    var testWords = new[] { "hello", "world", "use", "case" };

    var query = 
      from word in testWords
      let usage = GetWordUsageCount(wordUsage, word)
      orderby usage
      select (word, usage);

    foreach (var (word, usage) in query)
    {
        Console.WriteLine($"Word: '{word}' is repeated {usage} time(s).");
    }

    int GetWordUsageCount(Dictionary<string, int> wordUsageDic, string word)
        => wordUsageDic.TryGetValue(word, out var val) ? val : 0;
}

Finally, we get the expected (sorted) output!

Word: 'case' is repeated 10 time(s).
Word: 'world' is repeated 20 time(s).
Word: 'use' is repeated 75 time(s).
Word: 'hello' is repeated 100 time(s).

Note that in case you're still on an earlier version of C#, you could use a normal (most likely private) class method instead of a local method. If local functions are available though, I personally prefer them, since they help prevent classes from getting polluted with too many single-purpose helper methods.

Value Tuple

Just recently I came across a neat solution, which involves creating a value tuple as a container for the local out variable. Note though that this code is also C# 7.0+ only, as it requires declaring the out variable in the argument list of a method.

var query =
    from word in testWords
    let usage = (result: wordUsage.TryGetValue(word, out var localIntVar), count: localIntVar)
    orderby usage.count
    select (word, usage.count);

This solution will also scale nicely when the invoked method declares multiple out variables.

As a side note - using a value tuple inside of a query would be even easier when combined with tuple deconstruction. Something like this:

let (result, usage) = (wordUsage.TryGetValue(word, out var localIntVar), localIntVar)

Unfortunately, tuple deconstruction in LINQ queries is not supported at the moment:

error CS1001: Identifier expected
error CS1003: Syntax error, '=' expected

Maybe we'll get that supported in one of the future C# versions (more info in this discussion on GitHub).

Future

If you're interested in some of the latest development around local parameters in LINQ queries, check out the following postings in the csharplang GitHub repository:

Proposal: Support out/pattern variables in LINQ with query-scoping #159
Extend Out Variable support to LINQ #15619

Conclusion

To sum it up, if you have a need to consume an out variable inside of a LINQ query, use one of these options:

A single-purpose local function (or a private class method)
A helper value tuple

Do NOT use:

A local variable (unless you really know what you're doing), as it may produce incorrect results
An out variable declared inside of the argument list of a method call, as that is currently not supported inside of LINQ queries
A deconstructed value tuple - tuple deconstruction is currently not supported in LINQ queries

What is your experience with out variables in LINQ queries?

If you find this post interesting, be sure to check out other posts on my blog mydevtricks.com.

What it takes to be a Software Engineer

Jan Doubek — Tue, 16 Mar 2021 12:41:19 +0000

People often wonder (and argue) what is the exact role of a Software Engineer and maybe even more what is the difference in responsibilities between a Software Engineer vs. Software Developer. This is a broadly discussed topic and people often have highly differing opinions.

With this post, I'm not making an attempt to compile a comprehensive list of all materials available on the topic. I'm merely giving my own, entirely subjective view, based on my past experiences.

OK, let's dive right into it...

The core quality of a Software Engineer is that he/she is capable of fulfilling other roles in the product development life cycle, other than just developing code.

Here is my compilation of the additional roles:

Requirements and Planning

Participates in creating or refining requirements.

Meets with the Product Owner and helps him/her understand technical aspects of the developed solution.

Helps with creating both LOE and detailed estimates.

Software Design and Architecture

Creates models, diagrams and if necessary, defines APIs.

Has a good overview of available technologies and design principles, in order to be able to come up with technology proposals which are best suited for each part of the developed product.

Research

Does research on various types and levels of tasks, starting with simple development impediments (solvable by a stack overflow search), ending with a thorough analysis of a technology, API or library to be used for a new product or feature.

Software Development

A software engineer's knowledge is not limited by one application "tier" (client, server, database), programming language or technology stack. The grasp should be broad, giving him or her the ability to tackle or at least understand all the tasks and challenges which may arise during the application development lifecycle.

Debugging and Troubleshooting

Understands how to use different debugging, profiling and troubleshooting tools and techniques.

DBA

Maintains development and testing environments (e.g. SQL Server instances).

Troubleshoots performance of queries and stored procedures.

Understands database schemas, knowing how to generate database change scripts and scripts for shuffling data around.

DevOps

Sets up and manages builds and deployments.

Sets up and manages development, test and staging environments.

Recognizes the benefits of continuous delivery and knows how to implement it.

QA and Testing

Helps QA with spotting and identifying bugs.

Writes bug descriptions, including sensible steps to reproduce.

Quickly creates sample and test projects to help others with troubleshooting.

Effectively communicates with the QA team (leaving unnecessary emotions aside).

Documentation

Understands the importance of documentation, starting with code comments and ending with comprehensive user guides.

Has solid writing skills, able to express development-level knowledge of a certain topic in a user-friendly way.

Uses tools for auto-generating API documentation.

Mentoring

Helps other software developers with solving their issues.

Participates in onboarding newly hired colleagues.

Prepares technically oriented "lunch and learn" (or similar) sessions.

Hiring process

Carries out resume-based and phone screening of candidates.

Participates in the interview process, evaluating the candidate's attitude, aptitude and technical abilities.

Gives valuable feedback to the manager to help him/her decide on whether to hire or not.

3rd level support

Has solid communication skills to be able to effectively communicate with the tech support staff, or sometimes directly with the customer/end-user.

Reproduces and troubleshoots issues from (sometimes) partial or unclear descriptions.

IT

Has a solid understanding of the hardware and software that he/she is using and can maintain and troubleshoot it (to a certain level).

Has enough knowledge about basic security principles and ways how to mitigate security risks and vulnerabilities.

Is able to effectively fix most hardware and software errors by "turning it off and on again". 😉

Wrapping up

Again, the list above is highly subjective and by no means comprehensive. To me though, each of these skills represents something that requires a software engineer to go a step further from what is traditionally requested from the software developer role.

What is your experience? Would you add something? Please, comment!

If you find this post interesting, be sure to check out other posts on my blog mydevtricks.com.

LINQ gems: Left Outer Join

Jan Doubek — Thu, 12 Nov 2020 12:50:16 +0000

Doing a left outer join in T-SQL is as straightforward as adding a single keyword to the JOIN statement. I remember that when I first tried to perform a left outer join in a LINQ query, I was honestly surprised about how confusing the syntax was. Even now, after years of using it, I sometimes hesitate while trying to remember the exact syntax.

In LINQ, the left outer join is accomplished in 2 phases:

Performing a group join between the first and second collection
Running the Enumerable.DefaultIfEmpty extension method on the expanded group join results

A true left outer join "experience" can only be accomplished by executing both steps. The group join by itself however produces very similar results and sometimes it may even be a better option than doing the actual left outer join.

Let's first have a look at just the group join.

Group Join

One easy way of how to accomplish a behavior similar to a left outer join is using the group join. The group join simply pairs elements from the first (left) collection with a set of matching elements from the second (right) collection, producing a correlated subset of right elements for each member of the left collection. If there are no correlated elements found for a member of the left collection, the sequence of correlated elements is empty.

Even though this is not a true left outer join (as known from the SQL syntax), the group join is often quite useful and, to be honest, many times I'd wish that this type of join was (in some form) available in T-SQL as well.

Consider this example where a collection of days in a week is joined to another collection containing delivery times for a particular day. We're interested in outputting all of the days, regardless of whether a delivery exists for that day or not. For that reason, we're using a group join here:

// Test data
var days = new[] { "Mon", "Tue", "Wed", "Thu", "Fri" };
var deliveries = new[]
{
    (day: "Mon", time: "8AM"),
    (day: "Thu", time: "10AM"),
    (day: "Thu", time: "2PM")
};

// Group Join
var query = 
    from day in days
    join delv in deliveries on day equals delv.day into dayDelvs
    select new { day, deliveries = dayDelvs.Select(dd => dd.time) };

// Output
query.ToList().ForEach(dd => 
    Console.WriteLine($"{dd.day} deliveries: { string.Join(", ", dd.deliveries) }"));

Produces the following output:

Mon deliveries: 8AM
Tue deliveries:
Wed deliveries:
Thu deliveries: 10AM, 2PM
Fri deliveries:

As you can see in the output, the days without any deliveries are preserved, so the concept of left outer join is maintained. In addition, we get a linked sub-collection containing the matching delivery times, which can then be easily processed, in our case using string.Join().

Left Outer Join

To accomplish the full behavior of a left outer join, we still start with a group join. In addition though we need to expand the results of the group join and process it further using the DefaultIfEmpty method. DefaultIfEmpty ensures that each item in the left collection is included in the result set even when that element has no matches in the right collection.

Following is a modification of the first example, this time with a call to DefaultIfEmpty included in order to produce an actual left outer join:

// Test data
var days = new[] { "Mon", "Tue", "Wed", "Thu", "Fri" };
var deliveries = new[]
{
    (day: "Mon", time: "8AM"),
    (day: "Thu", time: "10AM"),
    (day: "Thu", time: "2PM")
};

// Left Outer Join
var q = from day in days
        join delv in deliveries on day equals delv.day into dayDelvs
        from dayDelivery in dayDelvs.DefaultIfEmpty()
        select (day, dayDelivery.time);

// Output
q.ToList().ForEach(dd => 
    Console.WriteLine($"{dd.day} delivery: {dd.time}"));

Outputs:

Mon delivery: 8AM
Tue delivery:
Wed delivery:
Thu delivery: 10AM
Thu delivery: 2PM
Fri delivery:

Unlike with the group join, with left outer join we get duplicate rows for Thursday, as there are multiple deliveries scheduled for Thursday. This is the main difference, which needs to be considered when making the choice between a group join and left outer join.

Adding Indexed Select

Looking at the output of the previous example, I think it would be nice if multiple deliveries for the same day would be ranked. Which is a perfect usage scenario for the Indexed Select presented in my previous post.

// Test data
var days = new[] { "Mon", "Tue", "Wed", "Thu", "Fri" };
var deliveries = new[]
{
    (day: "Mon", time: "8AM"),
    (day: "Thu", time: "10AM"),
    (day: "Thu", time: "2PM")
};

// Left Outer Join + Indexed Select
var q = from day in days
        join delv in deliveries on day equals delv.day into dayDelvs
        let numDayDelvs = dayDelvs.Select((dd, num) => new { dd.day, dd.time, num })
        from deliveredDay in numDayDelvs.DefaultIfEmpty()
        select (day, deliveredDay?.time, deliveredDay?.num);

// Output
q.ToList().ForEach(dd =>
{
    if (dd.time != null)
        Console.WriteLine($"{dd.day} delivery #{dd.num + 1}: {dd.time}");
    else
        Console.WriteLine($"{dd.day} delivery:");
});

Gives us a ranked output:

Mon delivery #1: 8AM
Tue delivery:
Wed delivery:
Thu delivery #1: 10AM
Thu delivery #2: 2PM
Fri delivery:

We could of course further enhance the example by only showing the rank for days, which have more than one delivery assigned. I'll leave that as an exercise for the reader.

Alternative syntax

There is an alternative syntax for the left outer join. It also uses the DefaultIfEmpty method, but the syntax is a bit more readable.

Let's take the previous example and rewrite it a little bit:

// Test data
var days = new[] { "Mon", "Tue", "Wed", "Thu", "Fri" };
var deliveries = new[]
{
    (day: "Mon", time: "8AM"),
    (day: "Thu", time: "10AM"),
    (day: "Thu", time: "2PM")
};

// Left Outer Join using alternative syntax
var q = from day in days
        from dayDelivery in deliveries.Where(dd => dd.day == day).DefaultIfEmpty()
        select (day, dayDelivery.time);

// Output
q.ToList().ForEach(dd =>
    Console.WriteLine($"{dd.day} delivery: {dd.time}"));

We get exactly the same output that we got when using the standard left outer join syntax:

Mon delivery: 8AM
Tue delivery:
Wed delivery:
Thu delivery: 10AM
Thu delivery: 2PM
Fri delivery:

Now you may wonder why this alternative syntax is not the recommended way of doing a left outer join in LINQ? Well, the answer is fairly simple - for performance reasons. If you run the alternative query in a pure LINQ-To-Objects scenario (such as the scenario I use in my examples), you won't get any caching of data; the second collection will be scanned (iterated through entirely) several times. This is fine for small data sets, but for large collections, it could easily become an unnecessary performance hog.

For database-driven LINQ providers though, this approach represents an equally effective syntax for writing a left outer join. Simply because the DB provider is usually capable of recognizing the alternative syntax and translating it into a standard left outer join SQL statement. For example, when using the Entity Framework Core SQL Server Provider, the generated SQL query is the same for both the standard and alternative left outer join LINQ syntaxes.

If you find this post interesting, be sure to check out other posts on my blog mydevtricks.com.

LINQ gems: Indexed Select

Jan Doubek — Wed, 28 Oct 2020 09:39:58 +0000

Here's another LINQ gem, which is very useful if you plan to base your projection or filtering logic on the element's index in a sequence.

From the MSDN page for Enumerable.Select():

Projects each element of a sequence into a new form by incorporating the element's index.

What the "incorporating the element's index" part means is that you get an extra parameter inside of the Select method's selector, which gets incremented with each processed element. As is common in C#, the index is zero-based.

Example

Let's have a look at a simple example, which outputs the sequence numbers of days in a week (apologies to all readers, for whom Monday is not the first day of the week 😊).

var days = new[] { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
var daysOutput = days.Select((day, index) => 
    $"{day} is day number: {(index + 1)}").ToList();
daysOutput.ForEach(output => Console.WriteLine(output));

When executed, the output will be the following:

Mon is day number: 1
Tue is day number: 2
Wed is day number: 3
Thu is day number: 4
Fri is day number: 5
Sat is day number: 6
Sun is day number: 7

or...

Let's just simply generate a sequence number for an array of values and project it into an array for whatever usage may be appropriate.

var days = new[] { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
var indexedDays = days.Select((day, index) => 
    new { Day = day, Index = index }).ToArray();

How about query expression syntax?

There is no query expression syntax for this overload of the Select method. However, one can simply embed the indexed Select overload inside of the query expression:

var days = new[] { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
var weekendDays = 
    from day in days.Select((day, index) => new { day, num = index + 1 })
    where day.num >= 6
    select day.day;

Enumerable.Where()

There is an indexed overload available for the Enumerable.Where() extension method too. Using Where instead of Select, the previous example can be further simplified:

var days = new[] { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
var weekendDays = days.Where((day, index) => index >= 5); // (index+1) >= 6

Other useful applications

Selecting each N-th element in a sequence
Ordering based on element position
Coordination across multiple sequences

If you find this post interesting, be sure to check out other posts on my blog mydevtricks.com.

LINQ gems: Zip

Jan Doubek — Tue, 20 Oct 2020 13:30:34 +0000

I'm always fascinated by how simple yet helpful LINQ queries are.

Take for example the Enumerable.Zip() method. It's simple, yet very useful in case you need to combine two sequences of data.

Here's a partial example where Zip() is used to combine a sequence of original text resources with their translations (produced for example by the Google Cloud Translation API):

public IEnumerable<(ResourceText text, string translation)> 
    TranslateResourceTexts(IEnumerable<ResourceText> resourceTexts)
{
    // Grab just the strings to translate
    IEnumerable<string> strings = resourceTexts.Select(t => t.Text);

    // Translate the strings (call Google Translate V3 API)
    IEnumerable<string> translatedStrings = TranslateStrings(strings);

    // Combine the two sequences, producing an enumerable of tuples 
    // containing both the original resource text and its translation
    return resourceTexts.Zip(translatedStrings, (text, translation) 
                             => (text, translation));
}

Simple and easily readable.

As with most of the LINQ functions, I could of course accomplish the same with a for or for each loop and a few extra lines of code. However, in most cases, I consider the use of LINQ syntax a cleaner alternative.

Final notes:

The Zip() method can only be called using the LINQ method syntax, there's no query syntax option for it.
It is available starting with .NET Framework 4.0.

If you find this post interesting, be sure to check out other posts on my blog mydevtricks.com.