Blog

I'm pleased to announce that DesiGen now includes templates for .NET 6, including those needed to generate code compatible with CSLA 6.0.

CSLA 6.0 is a pretty big change from CSLA 5.5, as it is now entirely dependent upon dependency injection. Rocky has done a huge amount of work to cope with the fact that Blazor server makes use of DI scopes for authentication, and that anything that works under Blazor Server must do the same. This is a huge change from previous authentication mechanisms in .NET, and it had a pretty profound effect on CSLA.

The good news is that by fully embracing DI, CSLA 6.0 finally silences the naysayers who criticised it for not being unit testable. World domination should now follow - it's now harder than ever for critics to find fault with the framework, and therefore find good reason not to use it. The slightly less good news is that the changes necessary to upgrade from version 5.5 to version 6.0 are not trivial. There are quite a few fairly significant changes to your code in order to be compatible with the new version, and getting your head around the changes isn't necessarily a comfortable process.

I'm hoping that, in its small way, DesiGen can help. Having the templates for CSLA 6.0 built into the application should allow people to create some code that works with the new version for themselves. This provides anyone who needs it some code that they can play with to understand more about the changes.

To accompany the release, I've also uploaded a few videos demonstrating the use of DesiGen to YouTube. Hopefully these will offer a way to learn how to use DesiGen in order to create a working CSLA application in about an hour.

Why not give it a go? If you like CSLA then I think you will also like DesiGen. I believe the mindset that encourages you to use the framework and the mindset necessary to appreciate the benefits of code generation are quite closely aligned.

New videos include -

An introduction to the application https://youtu.be/4XbxJNCgzyQ

An installation tutorial https://youtu.be/jKnp7vOCEbw

Using DesiGen to create a small part of ProjectTracker https://youtu.be/VRTzHOw7uxc

You can find out more about DesiGen, including the link to the docs site from which you can download it, by going to the website accompanying my agile software design video series, at getdesigning.dotnotstandard.com

My next step will be to upgrade DesiGen to run on .NET 6 - at the moment it's still using .NET Core 3.1. This upgrade is a bit delayed, partially because creating the templates for CSLA 6 seemed more important, but mainly because I was waiting on the release of .NET MAUI. As it happens, .NET MAUI might not be on the roadmap for the time being, as the use of WinUI 3 as a host for the MAUI on Windows would cause me a problem. Sadly, the installation story with WinUI 3 isn't all that convenient - with WinUI 3, code signing of an installation package becomes mandatory. That's an issue for me both because of the cost, but also because of the inconvenience of certificate expiry.

I could try to publish DesiGen via the Windows Store, which would both reduce the cost and offload the certificate expiry problem to the Store. However, I suspect that doing so might be a problem - DesiGen may fail the requirements for inclusion in the Store. DesiGen requires pointing at a database in order for testing to succeed, and that may mean that it fails to fulfil the criteria that it be easily testable for approval by the team who manage the Store.

There is one benefit to still running on .NET Core 3.1, however. The fact that it runs on this old version whilst generating code for .NET 6 might possibly bend people's heads - and in a way, that might be a good thing. It's important to realise that what DesiGen runs on and what it can generate are unrelated. Are you using JavaScript? No problem. Python? Easy. COBOL? Ah, I feel for you - but don't worry, you can use DesiGen to ease your pain. At the end of the day, code is just text - a specialised form of text, but text nevertheless. DesiGen generates text, so it can generate anything you can represent with text.

Anyway I digress. MAUI and code signing is a problem for another day. For now, let's revel in the new version, and its new 6iness.

Happy DesiGenning!

CSLA is a framework in the .NET ecosystem intended to reduce the cost of building and maintaining applications. The core ideas have been around for a long time - longer than the .NET ecosystem has existed - but the framework remains just as relevant today as it was when it was first introduced.

Today is a momentous day for the DotNotStandard team. I am proud and pleased to announce the public release of the fruits of our labours over the past year: DesiGen. DesiGen is a design and generation tool, intended to help agile software development teams build better, more secure software quickly.

In .NET, asynchrony is now everywhere. It's become ubiquitous. Async/await (more formally known as TAP - the Task-based Asynchronous Pattern) was added to C# as far back as version 5, released in 2012. Async/await is much easier to implement than the earlier asynchronous patterns available in .NET, making the addition of asynchrony to our applications a breeze - well, sort of - but more of that in a moment.

Shift left is a term that is often applied to testing in agile teams, but the concept is perhaps larger than that. Shifting left is a practice of bringing the determination of quality of a deliverable as early in the development process as possible. Consider the development process to be a pipeline running from left to right, with user stories or use cases being fed in at the left, and delivered, working software coming out of the pipe at the right. With this in mind, we could consider shift left to mean that we should test the software as soon as possible. However, I think we might benefit from deeper thinking on the subject.