Imar.Spaanjaars.Com

Fixing the error "rzc rewritecss exited with code -2147450730."

(Imar Spaanjaaars) — Wed, 16 Feb 2022 13:01:37 GMT

While working on an existing .NET Core project I ran into a number of SSL issues (where suddenly certain ports on my localhost would no longer serve up a site with a valid SSL certificate). In order to rule out an issue with my existing project, I created a new .NET Core 6.0 web application. However, that failed to compile and presented me with this error message:

rzc rewritecss exited with code -2147450730.

I searched Google and found a few references to this error but they all seemed to deal with .NET Core 3.x and none of the answers worked for me.

Introducing a new article series: Building a NuGet packages architecture

(Imar Spaanjaaars) — Mon, 31 Jan 2022 16:30:41 GMT

I just finished writing a new article series on building a modern software architecture using NuGet packages and feeds. All six parts in the series have now been published.

Building a NuGet Packages Architecture Part 6 - Enhancing your packages

(Imar Spaanjaaars) — Thu, 21 Apr 2022 09:05:43 GMT

Welcome to the last episode in the article series on building a NuGet packages architecture for your own software development purposes. This is the last part in a series of 6 articles about building a software architecture based on NuGet packages and feeds. In this series you will see:

How to refactor your codebase to make it work with packages
How to build packages on your local machine
How to build packages using an Azure build pipeline and add the generated packages to a feed
How to consume your packages in your applications
Different ways to improve usage of your packages and types with service registration methods
Various tips and tricks to enhance your package and how to use them

You'll find all the articles in the series here:

Introduction
Building packages
Adding packages to a feed using a pipeline in Azure DevOps
Consuming packages and managing changes
Service Registration Methods
Enhancing your packages (you're reading it now)

In this article I'll wrap up the series by providing some additional tips and tricks to improve your packages, their usability and your development process using packages in general. In particular, I'll discuss:

How to add additional metadata and an icon to your package
How to add XML documentation for the types in your packages
How to add unit tests and run them as part of your build pipeline
How to debug the code in your packages

If you're interested in purchasing the entire article series now as a 60+ page PDF document, check out this post: Introducing a new article series: Building a NuGet packages architecture.

Building a NuGet Packages Architecture Part 5 – Service Registration Methods

(Imar Spaanjaaars) — Sun, 20 Mar 2022 14:38:35 GMT

This is part 5 in a series of 5 articles about building a software architecture based on NuGet packages and feeds. In this series you will see:

How to refactor your codebase to make it work with packages
How to build packages on your local machine
How to build packages using an Azure build pipeline and add the generated packages to a feed
How to consume your packages in your applications
Different ways to improve usage of your packages and types with service registration methods
Various tips and tricks to enhance your package and how to use them

You'll find all the articles in the series here:

Introduction
Building packages
Adding packages to a feed using a pipeline in Azure DevOps
Consuming packages and managing changes
Service Registration Methods (you're reading it now)
Enhancing your packages

In this part you see different ways to add service registration methods to your packages, making consuming and configuring your types simple and straightforward.

If you're interested in purchasing the entire article series now as a 60+ page PDF document, check out this post: Introducing a new article series: Building a NuGet packages architecture.

Building a NuGet Packages Architecture Part 4 - Consuming packages and managing changes

(Imar Spaanjaaars) — Wed, 02 Mar 2022 14:33:02 GMT

This is part 4 in a series of 6 articles about building a software architecture based on NuGet packages and feeds. In this series you will see:

How to refactor your codebase to make it work with packages
How to build packages on your local machine
How to build packages using an Azure build pipeline and add the generated packages to a feed
How to consume your packages in your applications
Different ways to improve usage of your packages and types with service registration methods
Various tips and tricks to enhance your package and how to use them

You'll find all the articles in the series here:

Introduction
Building packages
Adding packages to a feed using a pipeline in Azure DevOps
Consuming packages and managing changes (you're reading it now)
Service Registration Methods
Enhancing your packages

In this article I'll complete the process of migrating to a package-based architecture by updating the demo application. I'll remove all project references and replace them with a package reference instead.

If you're interested in purchasing the entire article series now as a 60+ page PDF document, check out this post: Introducing a new article series: Building a NuGet packages architecture.

Building a NuGet Packages Architecture Part 3 - Adding packages to a feed using a pipeline in Azure DevOps

(Imar Spaanjaaars) — Thu, 17 Feb 2022 10:02:01 GMT

This is part 3 in a series of 6 articles about building a software architecture based on NuGet packages and feeds. In this series you will see:

How to refactor your codebase to make it work with packages
How to build packages on your local machine
How to build packages using an Azure build pipeline and add the generated packages to a feed
How to consume your packages in your applications
Different ways to improve usage of your packages and types with service registration methods
Various tips and tricks to enhance your package and how to use them

You'll find all the articles in the series here:

Introduction
Building packages
Adding packages to a feed using a pipeline in Azure DevOps (you're reading it now)
Consuming packages and managing changes
Service Registration Methods
Enhancing your packages

In the previous article you saw how to create packages from your projects on your local machine. In this article I'll take these concepts a step further and set up a build pipeline in Azure DevOps to automatically build NuGet packages and publish them to a feed so they can be accessed by Visual Studio and other tools.

If you're interested in purchasing the entire article series now as a 60+ page PDF document, check out this post: Introducing a new article series: Building a NuGet packages architecture.

Building a NuGet Packages Architecture Part 2 - Building packages

(Imar Spaanjaaars) — Tue, 08 Feb 2022 14:49:38 GMT

This is part 2 in a series of 6 articles about building a software architecture based on NuGet packages and feeds. In this series you will see:

How to refactor your codebase to make it work with packages
How to build packages on your local machine
How to build packages using an Azure build pipeline and add the generated packages to a feed
How to consume your packages in your applications
Different ways to improve usage of your packages and types with service registration methods
Various tips and tricks to enhance your package and how to use them

You'll find all the articles in the series here:

Introduction
Building packages (you're reading it now)
Adding packages to a feed using a pipeline in Azure DevOps
Consuming packages and managing changes
Service Registration Methods
Enhancing your packages

In this second article, I'll take the application I refactored in part 1 and build packages locally from the projects I extracted out to a separate solution. I'll also show you how to test and use your packages locally. Part 3 then shows you how to automate this process with an Azure DevOps build pipeline.

If you're interested in purchasing the entire article series now as a 60+ page PDF document, check out this post: Introducing a new article series: Building a NuGet packages architecture.

Building a NuGet Packages Architecture Part 1 - Introduction

(Imar Spaanjaaars) — Mon, 31 Jan 2022 16:17:42 GMT

This is part 1 in a series of 6 articles about building a software architecture based on NuGet packages and feeds. In this series you will see:

How to refactor your codebase to make it work with custom NuGet packages
How to build packages on your local machine
How to build packages using an Azure build pipeline and add the generated packages to a feed
How to consume your packages in your applications
Different ways to improve usage of your packages and types with service registration methods
Various tips and tricks to enhance your package and how to use them

You'll find all the articles in the series here:

Introduction (you're reading it now)
Building packages
Adding packages to a feed using a pipeline in Azure DevOps
Consuming packages and managing changes
Service Registration Methods
Enhancing your packages

In this first article, I'll set the stage with an introduction to NuGet and the sample application I'll use throughout this article series. You'll see how I refactored my code so I can extract packages from it. In part 2 I'll then show you how to create packages from these refactored projects on your local machine. Later articles then show you how to build these packages automatically and add them to a feed using an automated Azure DevOps pipeline.

If you're interested in purchasing the entire article series now as a 60+ page PDF document, check out this post: Introducing a new article series: Building a NuGet packages architecture.

Improving your ASP.NET Core site's file handling capabilities – part 2 – Data migration

(Imar Spaanjaaars) — Sun, 31 Oct 2021 11:49:59 GMT

In part 1 of this article, I showed you how to hide file management in an ASP.NET Core application behind an interface and how to build concrete implementations of File Providers that target the local filesystem and Azure storage. With that setup, the application can work with files without knowing where they are stored. This in turn makes it easy to move away from files on the local filesystem to files in a remote location like Azure storage and also facilitates unit testing.

But how do you actually switch your data from one storage location to another? That's the topic of this article.

Improving your ASP.NET Core site's file handling capabilities – part 1 – Introduction

(Imar Spaanjaaars) — Wed, 20 Oct 2021 15:29:44 GMT

In a previous article I talked about hiding email capabilities behind an interface to make your code easier to unit test, to centralize configuration and to make it simple to switch to a completely different solution such as a cloud-based email handler like SendGrid, MailChimp or MailGun. Instead of newing up an SmtpClient directly, I created an interface called IMailSender and several concrete implementations that handle the sending of email differently (such as storing it on disk as .eml messages, sending it over SMTP or sending it with SendGrid).

In this article (and the next) I am going to talk about a similar improvement: handling files in a filesystem. I'll show you how to hide file handling - reading, writing and deleting files - behind an interface, similar to how I hid the emailing details behind IMailSender. I'll then create two concrete implementations: one using the local filesystem, the other using Azure storage. I'll then show you how to use dependency injection to inject one of the concrete classes at run-time to determine where your files are located and how to access them. With this setup, it's easy to write code to target yet another (remote) file storage solution like Box or OneDrive and plug that in without making any changes your application code.

Introducing a new article series: Building and auto-deploying an ASP.NET Core application with EF Core 5.0

(Imar Spaanjaaars) — Wed, 20 Jan 2021 17:21:22 GMT

Over the past couple of weeks I have been working on a new article series on building and auto-deploying an ASP.NET Core application using ASP.NET Core 5.0, Entity Framework Core 5.0, Git, GitHub and Azure DevOps. Just this week I wrapped up the last article and the series is now done! I've published the first article in the series today, and the remaining 6 parts will come online in the coming weeks.

Building and auto-deploying an ASP.NET Core application - Part 7 - Improving your build and release processes

(Imar Spaanjaaars) — Mon, 17 May 2021 20:34:48 GMT

This is the last part in a series of 7 articles showing you how to build a database-driven ASP.NET Core 5.0 app and deploy it to a remote web server using continuous integration and deployment with GitHub and Azure DevOps. In this final part I'll touch on two improvements you can make to the process you've seen in the earlier articles. In particular, I'll show you how to set up your own build agent to build your software on a custom server rather than on a standard Azure DevOps agent to speed up the build process. I'll also show you how you can minimize downtime when deploying your site to a Microsoft Azure App Service by using deployment slots. This article closes with a quick summary of all I've discussed in this series of articles.

If you haven't read the earlier parts in this series yet, you're encouraged to do that now. Here's the full list of the articles in the series:

Building and auto-deploying an ASP.NET Core application - Part 6 - Setting up a CD pipeline - Deploying to an Azure App Service

(Imar Spaanjaaars) — Mon, 19 Apr 2021 14:18:53 GMT

In the previous article you saw how to take your compiled application and deploy it to a web server running IIS. This is a convenient scenario when you own or manage the remote server completely as you need to install a release agent on it. You also saw how to use a SQL task in the release pipeline to automatically apply the EF migrations to your database on release.

In this article you see how to do the same, but with an Azure App Service and an Azure SQL database instead. An App Service is a fully managed web hosting service for running web sites, mobile back ends, and RESTful APIs. It allows you to run web sites on the Internet without the need to manage a complete server yourself. Azure SQL is Microsoft's cloud version of their popular database system SQL Server.

App services and SQL Azure are popular choices for running a data-driven web site in Microsoft's cloud solution. I use them a lot for many of my customers' solutions and therefore thought it made sense to demonstrate and discuss them here as well. In this article I'll show you how to create a release pipeline in Azure DevOps that deploys your application to an Azure App Service. In addition, you see how to create and configure an Azure SQL server and database and how to automatically update the database's schema during the release with changes coming from your EF migrations.

If you haven't read the previous parts in this series you're encouraged to do that now. Here's the full list of the articles in the series:

Building and auto-deploying an ASP.NET Core application - Part 5 - Setting up a CD pipeline - Deploying with web deploy to a VM

(Imar Spaanjaaars) — Thu, 01 Apr 2021 10:05:13 GMT

In the previous article you saw how to create a build pipeline in Azure DevOps to automatically build and test your software every time changes are submitted to your GitHub repository.

In this article and the next you see how to complement this process with an additional pipeline that automatically releases your software to a remote server so it can be accessed by your end users. In this article you see how to deploy your site site to a server running IIS, such as a virtual machine in the cloud or a (virtual or physical) machine in your own network. The next article then shows how to do the same but for an Azure App Service, an HTTP-based service for hosting web applications, REST APIs, and mobile back ends in the Microsoft Azure cloud.

Note: if you like to purchase the entire series now and not wait for the remaining parts to come online, check out this blog post that explains how you can purchase it for only $8.

If you haven't read the previous parts in this series you're encouraged to do that now. Here's the full list of the articles in the series:

Building and auto-deploying an ASP.NET Core application - Part 4 - Setting up a CI pipeline in Azure DevOps to build and test your code

(Imar Spaanjaaars) — Mon, 08 Mar 2021 09:25:13 GMT

In this article I finally get to showing you how to create pipelines in Azure DevOps. I've been mentioning this for a few articles now but there was some groundwork I had to take care of first. In this article, the 4th in a series of 7, I'll show you the following:

What YAML is and why you need it
How to build a pipeline in Azure DevOps to build your source code every time you do a check in on GitHub.
How to modify your build to save the results so they can be deployed to a remote server at a later stage
How to add a unit test project to your solution and configure the build to execute your tests
How to create EF Migration scripts which can be run against the database during the release

If you haven't read the previous parts in this series you're encouraged to do that now. Here's the full list of the articles in the series:

Note: if you like to purchase the entire series now and not wait for the remaining parts to come online, check out this blog post that explains how you can purchase it for only $8.

Building and auto-deploying an ASP.NET Core application - Part 3 - Dealing with change

(Imar Spaanjaaars) — Sun, 21 Feb 2021 15:13:12 GMT

In the previous article in this series I showed how to set up the initial web application and add Entity Framework as the database persistence framework. This provides a good starting point for the application. As you'll be expanding the application you need a good way to manage code and database schema changes. In this article you'll see how to leverage Git, GitHub and EF migrations to manage code changes. In the next article in the series I'll then finally show you how to set up a CI pipeline followed by a CD pipeline in a later article.

If you haven't read the previous parts in this series you're encouraged to do that now. Here's the full list of the articles in the series:

Note: if you like to purchase the entire series now and not wait for the remaining parts to come online, check out this blog post that explains how you can purchase it for only $8.

Building and auto-deploying an ASP.NET Core application - Part 2 - Creating the web application

(Imar Spaanjaaars) — Wed, 03 Feb 2021 22:05:12 GMT

This is part 2 in a series of 7 articles showing you how to build a database-driven ASP.NET Core 5.0 app and deploy it to a remote web server using continuous integration and deployment with GitHub and Azure DevOps. In this part I'll show you how to set up the basic application, add a model that uses Entity Framework Core 5.0 to persist data to the database and how to create to the initial database.

Note: if you like to purchase the entire series now and not wait for the remaining parts to come online, check out this blog post that explains how you can purchase it for only $8.

If you haven't read the first part of this series you're encouraged to do that now. Here's the full list of the articles in the series:

Building and auto-deploying an ASP.NET Core application - Part 1 - Introduction

(Imar Spaanjaaars) — Wed, 20 Jan 2021 17:23:22 GMT

I have been programming for many years and over those years, I have seen the development landscape change quite a lot. Things have become both simpler and more complex at the same time. For example, setting up a web server on Windows to run a Classic ASP site with COM+ components was pretty complicated back in the days. Setting up an Azure app service today to do more or less the same as that old web server did takes just a couple of clicks in the Azure portal. At the same time, things have become more complicated because possibilities, demands and requirements have changed. For example, when I started programming, distributed source control usually meant a shared network drive where everyone would write to and that was occasionally backed up ;-) But nowadays, we have powerful source control systems like Git that allow for more feature-rich management of your source code including history, branching and a lot more. And combined with powerful online platforms like Azure DevOps and GitHub, you have all the tools you need at your fingertips.

Unit Testing Authorization on your Controllers

(Imar Spaanjaaars) — Sun, 15 Nov 2020 14:26:12 GMT

In many of my ASP.NET web applications (mostly MVC or Web APIs) I have a mix of content with endpoints that either require authentication and authorization or that can be accessed anonymously. For example I have mostly public content (such as my own web site) with a protected management (admin) section. Or I have a Web API project with many endpoints protected by authorization but with a few of them publicly available. To ensure you protect your controllers well, you have many different options. In this article I'll show you a short unit test that you can use to ensure your controllers are properly configured when using a mixed authorization scenario.

Improving IntelliSense for the asp-page Tag Helper using T4 Templates

(Imar Spaanjaaars) — Wed, 11 Nov 2020 13:18:06 GMT

I find ASP.NET Tag Helpers super helpful. They provide powerful features and yet use clean markup. As an example, here's a tag helper that creates a link to an action method in some controller:

<a asp-controller="Contact" asp-action="Index">Get in Touch</a>

At run-time, ASP.NET then generates the correct URL for this action method and creates an href attribute on the anchor for it:

<a href="/contact">Get in Touch</a>

Improving your ASP.NET Core site's e-mailing capabilities

(Imar Spaanjaaars) — Tue, 24 Nov 2020 08:43:23 GMT

Many websites depend heavily on e-mail: they send account confirmation e-mails, password reset e-mails, order confirmations, back-in-stock notifications and much more. Despite its importance, I often see that sending e-mail is an overlooked area when writing well maintainable and stable code. It's also often overlooked when monitoring sites and lots of code I have seen just assumes the mail server is up and running. But problems will occur; mail servers will go down, passwords do expire or get changed without updating the web site and more.

In a preceding article you saw how to monitor your site's SMTP server using an ASP.NET Core health check. While it's great to be notified when your SMTP server is unavailable, it would be even better if your site has an alternative way to deliver the messages when the primary SMTP is not available.

In this article, I'll show you a couple of ways to improve the way you send e-mails from your ASP.NET Core applications. In particular, I'll discuss:

Hiding send functionality behind an interface
Providing multiple concrete implementations to send e-mails in different ways and configure the best one at runtime
Implementing a fallback solution for cases where your primary mail server is not available
How to use MailKit to replace the built-in SmtpClient which is now considered obsolete by Microsoft
How to use the SendGrid API to send e-mails from your application

You'll find the full code for the article as a download at the end of this article, as well as in the Github repository for this article.

Using Standard Health Checks and Building your Own in ASP.NET Core

(Imar Spaanjaaars) — Tue, 17 Nov 2020 13:16:56 GMT

Being able to monitor your ASP.NET Core web applications and APIs and detect any issues early on is crucial in ensuring your sites are up and running and in a healthy state. In previous articles I talked about creating a custom health check solution for ASP.NET Framework applications and implementing ASP.NET Core health checks with standard functionality. In this article I'll show you how to add and configure some existing, open-source health checks to monitor an SMTP server and the web server's disk space (these are just examples; there are many more health checks available that you can plug in to your own web site). And if the standard health checks aren't sufficient, you can build your own; something you'll see how to do in the second part of this article.

Implementing Health Checks in ASP.NET Core

(Imar Spaanjaaars) — Sun, 08 Nov 2020 13:39:44 GMT

Being able to monitor your ASP.NET Core web applications and APIs and detect any issues early on is crucial in ensuring your sites are up and running and in a healthy state. In a previous article I talked about creating a custom health check solution for ASP.NET Framework applications. In this article I'll show you how to leverage the built-in Health Check framework along with some third-party open-source add-ons available for ASP.NET Core applications. You may want to check out the previous article to better understand health checks and why they are useful. And seeing the custom solution for the .NET Framework may have you appreciate the built-in ASP.NET Core functionality even more. And in this article I'll dive a little deeper into some existing third-party health checks that make monitoring your sites and services super easy and show you how to build your own health checks and plug them into the system.

Implementing Health Checks in ASP.NET Framework Applications

(Imar Spaanjaaars) — Sun, 01 Nov 2020 21:18:15 GMT

Being able to monitor your ASP.NET web applications and APIs and detect any issues early on is crucial in ensuring your sites are up and running and in a healthy state. With ASP.NET Core 2.2 and later this now comes in the box (as I'll show you in later articles) but for .NET Framework apps you'll have to use to kind of custom solution. To implement simple monitoring in ASP.NET Framework apps (i.e. non-Core applications), I usually add some custom code to my projects to provide health information from an endpoint and then use external tools to monitor that endpoint. In this article I'll show you how you can implement health checks using custom code targeting the .NET Framework (although it should also work on .NET Core). In future articles I'll then show you how you can set up similar checks in an ASP.NET Core app with standard functionality and how to extend the base system using existing third-party health checks like an SMTP server monitor, to make your health checks even more powerful.

I'm back!

(Imar Spaanjaaars) — Sun, 01 Nov 2020 21:17:23 GMT

I can't believe it's been almost 7 years since I last posted something here! Wow, time flies. Here's what happened.

Prefixing ID columns with the table name in Entity Framework

(Imar Spaanjaaars) — Wed, 08 Jan 2014 10:22:48 GMT

I recently got a question about the database configuration part of my article series on N-Layer design in ASP.NET. In my model, all classes inherit DomainEntity<T> that defines a primary key called Id. This in turn means all primary key columns in the database are called Id as well. The reader wanted to know if it was possible to prefix that column with the entity / table name. So, the Id column in the People table would be called PersonId, the Id in EmailAddress would be called EmailAddressId and so on. This has always been possible (and easy to do) for separate entities, but EF 6's custom conventions makes it a lot easier to do it for the entire model.

New Article Series on ASP.NET 4.5 N-Layered Design Now Available for Purchase

(Imar Spaanjaaars) — Fri, 28 Jun 2013 16:45:40 GMT

I am glad to announce the immediate availability of my new article series on N-Layered Design in ASP.NET 4.5!

Book Review: Instant jQuery 2.0 Table Manipulation How-to by Charlie Griefer

(Imar Spaanjaaars) — Sun, 26 May 2013 22:34:11 GMT

Talks about the book Instant jQuery 2.0 Table Manipulation How-to by Charlie Griefer

I recently got the opportunity to review the book Instant jQuery 2.0 Table Manipulation How-to by Charlie Griefer. Being a fan and heavy user of jQuery, I happily accepted the offer.

Looking for Reviewers for my new Series on N-Layer Design with ASP.NET 4.5 and Entity Framework 5 Code First

(Imar Spaanjaaars) — Tue, 23 Apr 2013 22:03:57 GMT

During the past couple of months, I've been hard at work writing a follow up of my article series on N-Layer design for ASP.NET. This was long overdue, as I completed the previous series in early 2009, more than four years ago!

ASP.NET N-Layered Applications - Extensions, Tools and Wrapping Up (Part 10)

(Imar Spaanjaaars) — Wed, 18 Dec 2013 17:02:31 GMT

Note: this is part ten in a series of ten. If you rather read this entire series off-line, you can buy the full series as a convenient PDF document that comes with the full source. Besides the convenience, buying the PDF will also make you feel good as it shows your appreciation for the articles and helps me pay the bills for my server and hosting so I can keep running imar.spaanjaars.com and continue to provide you with great content. For more details, check out this post that shows you how you can buy the entire series right now.

This is Part 10 in a series of 10 that show you how to build N-Layered applications using ASP.NET 4.5 and Entity Framework 5 Code First. In this part I’ll discuss a few miscellaneous topics that I haven’t touched in previous articles in the series.