2024-11 on Funky Si's Test

Getting started with .Net Aspire

funkysi1701@gmail.com (funkysi1701) — Mon, 25 Nov 2024 20:00:00 +0000

What is .Net Aspire?

.Net Aspire is a comprehensive set of tools, templates, and packages designed to simplify the development of cloud-native applications using .Net. It focuses on building observable, production-ready apps by providing a consistent and opinionated set of tools and patterns .

The key features of .Net Aspire:

Orchestration: Enhances the local development experience by simplifying the management of your app’s configuration and interconnections. It helps with app composition, service discovery, and connection string management.
Integrations: Offers NuGet packages for commonly used services like Redis and Postgres, ensuring they connect consistently and seamlessly with your app.
Tooling: Comes with project templates and tooling experiences for Visual Studio, Visual Studio Code, and the .Net CLI to help you create and interact with .Net Aspire projects.

Overall, .Net Aspire aims to improve the experience of building .Net cloud-native apps by providing a robust framework for developing distributed applications.

Getting started with .Net Aspire

I touched on .Net Aspire last week, when I talked about what was new in dotnet 9 , but let’s walk through an example.

Lets say you have a simple application. It has a Blazor web front end, it communicates with a .Net API and that API retrieves data from a SQL Server database. Before Aspire came along I would create a docker compose file and configure ports so the FE could call the API, and add connection strings so the API could access the database.

services:
 Api:
 image: ${DOCKER_REGISTRY-}api
 container_name: api
 ports:
 - 12345:80
 - 44338:443
 networks:
 - my-network
 build:
 context: .
 dockerfile: API/Dockerfile
 depends_on:
 - sqlserver

 Ui:
 image: ${DOCKER_REGISTRY-}ui
 container_name: ui
 ports:
 - 44330:443
 networks:
 - my-network
 build:
 context: .
 dockerfile: UI/Dockerfile
 environment:
 - APIPath=http://Api:80

 sqlserver:
 image: ${DOCKER_REGISTRY-}sql
 container_name: sql
 volumes:
 - sqlvol:/var/opt/mssql
 ports:
 - "5432:1433"
 networks:
 - my-network
 build:
 context: .
 dockerfile: Database/Dockerfile

As you can see from this docker compose file, there is a lot of specifying ports and other plumbing to get these three parts of my system to work together.

Now in Visual Studio, right-click on the API project and select add .Net Aspire Orchestrator Support this will add two new Visual Studio projects to the solution, AppHost and ServiceDefaults.

AppHost is where you configure what service depends on what, you can configure all sorts of different dependencies, like databases (sql server, mysql, postgres etc), rabbitmq, redis and many others.
ServiceDefaults is where you configure the defaults for your services, like how opentelemetry should be configured, or how logging should work.

Now right click on the Blazor project and select the same option to get that wired up as well.

var builder = DistributedApplication.CreateBuilder(args);

builder.AddProject<Projects.UI>("ui");

builder.AddProject<Projects.API>("api");

builder.Build().Run();

Your Program.cs file inside your AppHost project will look something like this now, with both your API and UI/Blazor projects referenced.

There is one more component we need to wire up, but we don’t have a project to right click on for the database. It is fairly straightforward to do, update it to look like the following:

var builder = DistributedApplication.CreateBuilder(args);

var sqldb = builder.AddSqlServer("sql")
 .WithDataVolume("sql-data")
 .AddDatabase("Context", "Project");

var api = builder.AddProject<Projects.API>("api")
 .WaitFor(sqldb)
 .WithReference(sqldb);

builder.AddProject<Projects.UI>("ui")
 .WaitFor(api)
 .WithReference(api);

await builder.Build().RunAsync();

You also need to install a couple of nuget packages. Aspire.Hosting.SqlServer and Aspire.Microsoft.EntityFrameworkCore.SqlServer the second one is because my project is using Entity Framework. Lets look at what we have, we are defining a SQL Server called sql, with a data volume called sql-data, and a database called Project, which we can refer to as Context. We then configure API to reference the sql server we have just configured, and wait for sql server to be ready before starting the API. Next the Blazor project depends on the API and will wait for that to be ready before starting. Pretty powerful stuff.

OK lets look at the API project, what do I need to configure in my connectionstrings? Not much, Aspire will fill all of this in for you.

 "ConnectionStrings": {
 "Context": ""
 }

In your API project, your Program.cs will need a nuget package Aspire.Microsoft.EntityFrameworkCore.SqlServer and the following line, and no need for any pulling config and passing in connection strings.

builder.AddSqlServerDbContext<Context>("Context");

One more clever thing we can do with Aspire is seed some data into my database before starting the project. Update the code that sets up your database in the AppHost project as follows.

var sqldb = builder.AddSqlServer("sql")
 .WithBindMount("./sqlserverconfig", "/usr/config")
 .WithBindMount("../API/data/sqlserver", "/docker-entrypoint-initdb.d")
 .WithEntrypoint("/usr/config/entrypoint.sh")
 .WithDataVolume("sql-data")
 .AddDatabase("Context", "Project")

Add a sqlserverconfig folder inside your AppHost project and add the following two files. I have found entrypoint.sh being a bit picky with its line endings (windows vs linux)

#!/bin/bash

# Adapted from: https://github.com/microsoft/mssql-docker/blob/80e2a51d0eb1693f2de014fb26d4a414f5a5add5/linux/preview/examples/mssql-customize/entrypoint.sh

# Start the script to create the DB and user
/usr/config/configure-db.sh &

# Start SQL Server
/opt/mssql/bin/sqlservr

#!/bin/bash

# set -x

# Adapted from: https://github.com/microsoft/mssql-docker/blob/80e2a51d0eb1693f2de014fb26d4a414f5a5add5/linux/preview/examples/mssql-customize/configure-db.sh

# Wait 60 seconds for SQL Server to start up by ensuring that
# calling SQLCMD does not return an error code, which will ensure that sqlcmd is accessible
# and that system and user databases return "0" which means all databases are in an "online" state
# https://docs.microsoft.com/en-us/sql/relational-databases/system-catalog-views/sys-databases-transact-sql?view=sql-server-2017

dbstatus=1
errcode=1
start_time=$SECONDS
end_by=$((start_time + 60))

echo "Starting check for SQL Server start-up at $start_time, will end at $end_by"

while [[ $SECONDS -lt $end_by && ( $errcode -ne 0 || ( -z "$dbstatus" || $dbstatus -ne 0 ) ) ]]; do
 dbstatus="$(/opt/mssql-tools18/bin/sqlcmd -h -1 -t 1 -U sa -P "$MSSQL_SA_PASSWORD" -C -Q "SET NOCOUNT ON; Select SUM(state) from sys.databases")"
 errcode=$?
 sleep 1
done

elapsed_time=$((SECONDS - start_time))
echo "Stopped checking for SQL Server start-up after $elapsed_time seconds (dbstatus=$dbstatus,errcode=$errcode,seconds=$SECONDS)"

if [[ $dbstatus -ne 0 ]] || [[ $errcode -ne 0 ]]; then
 echo "SQL Server took more than 60 seconds to start up or one or more databases are not in an ONLINE state"
 echo "dbstatus = $dbstatus"
 echo "errcode = $errcode"
 exit 1
fi

# Loop through the .sql files in the /docker-entrypoint-initdb.d and execute them with sqlcmd
for f in /docker-entrypoint-initdb.d/*.sql
do
 echo "Processing $f file..."
 /opt/mssql-tools18/bin/sqlcmd -S localhost -U sa -P "$MSSQL_SA_PASSWORD" -C -d master -i "$f"
done

The second BindMount line mounts a folder inside your API project, so add a data folder with a subfolder called sqlserver. Inside that add a sql script called init.sql. Put all your CREATE DATABASE and CREATE TABLES sql commands inside this. And if everything works you will have a seeded DB ready to test your application with.

Conclusion

This is just a few things I have done with Aspire. Go check out the docs on MS learn or the some of the sessions from dotnet conf .

Version 9 of .Net is here

funkysi1701@gmail.com (funkysi1701) — Mon, 18 Nov 2024 20:00:00 +0000

Every November it is like Christmas for .NET developers, as Microsoft releases the next version of .NET. This year is no different, and we have version 9 of .NET to play with. This release is packed with new features and improvements across the board.

If you haven’t already head on over to the dotnet website and download the latest version.

Also we get a brand new version of Visual Studio, which is always a good thing, so head on over to the Visual Studio website and download the latest version (or the Preview version if you want to test what is coming out next).

Back when .Net 7 came out I wrote a post about what you needed to fix to get the latest version working with your existing code. However this time around the upgrade is really smooth.

NuGet Audit

Back in .Net 8 NuGet Audit was introduced which told you if any of your packages had security vulnerabilities. This has been improved in .Net 9, and now defaults to tell you about transitive dependencies. This is a great feature, but if you would prefer to keep .Net 8’s functionality you can add the following to your project (*.csproj) file.

 <NuGetAuditMode>direct</NuGetAuditMode>

.Net Aspire

Released just after .Net 8 .Net Aspire is a suite of tools to help develop microservices. Gone are the days of specifying ports and connection strings for your services, Aspire can handle this all programmatically.

Aspire adds two new projects to your solution. AppHost and ServiceDefaults.

AppHost is where you configure what service depends on what, you can configure all sorts of different dependencies, like databases (sql server, mysql, postgres etc), rabbitmq, redis and many others. It is open source so the community are busy adding everything you could possibly need.
ServiceDefaults is where you configure the defaults for your services, like how opentelemetry should be configured, or how logging should work. Microsoft have thought hard about this and come up with some opinionated defaults, but you can change these to suit your needs.

Starting the AppHost project will start up the Aspire Dashboard where you can start/stop containers, view logs and see the health of your services. This is primarily a devlopment tool, but there are some deployment tools, however I have not explored these much yet. More details about Aspire can be found here

Blazor

I have been using Blazor since the first previews in the .Net 3.1 days. It has come a long way since then, and now with .Net 9 it is even better.

There has been some optimization of the delivery of static assets. To take advantage of this improvement, replace the following line in your Program.cs file.

 app.MapStaticAssets(); //Add this line
 app.UseStaticFiles(); //Remove this line

.Net 9 will then cache your static assets ang give them a unique filename. This will allow the browser to cache the files for longer, and only download them when they have changed. This will speed up your site and reduce the amount of data transferred.

In your razor pages use code similar to this:

<link rel="stylesheet" href="@Assets["bootstrap/bootstrap.min.css"]" />
<link rel="stylesheet" href="@Assets["app.css"]" />
<link rel="stylesheet" href="@Assets["BlazorSample.styles.css"]" />

AI

It will have not escaped your notice that AI is everywhere, and it is no different with .Net. I saw some very impressive demos at the .Net Conf online conference. I encourage you to check our the videos. But to summarize Microsoft have added a bunch of abstractions to make it easier to write code to talk to the different AI models, I haven’t played about with AI much yet, but I am tempted to give it a go.

SQL Management Studio

I have not used SQL Management Studio for a while as I have trying out Azure Data Studio. However a new Preview of SQL Server Management Studio is now avaliable . This version is 64bit and is based on Visual Studio engine, it even shares the same installer.

Conclusion

This is only a small taste of the new features in .Net 9. Go check out .Net Conf to learn more or check out some of the links I have shared above.

Strategy Design Pattern

funkysi1701@gmail.com (funkysi1701) — Mon, 11 Nov 2024 20:00:00 +0000

Understanding the Strategy Design Pattern.

In the world of software development, design patterns are essential tools that help developers solve common problems in a standardized way. One such pattern is the Strategy Design Pattern. This pattern is particularly useful when you need to define a family of algorithms, encapsulate each one, and make them interchangeable. Let’s dive into what the Strategy Design Pattern is, why it’s useful, and how you can implement it in your projects.

What is the Strategy Design Pattern?

The Strategy Design Pattern falls under the category of behavioural design patterns. It enables an algorithm’s behaviour to be selected at runtime. Instead of implementing a single algorithm directly, code receives run-time instructions as to which in a family of algorithms to use.

Why Use the Strategy Design Pattern?

The primary benefits of using the Strategy Design Pattern include:

Flexibility: It allows you to change the algorithm or strategy being used without altering the code that uses the algorithm.
Reusability: By encapsulating algorithms separately, you can reuse them across different parts of your application.
Maintainability: It promotes cleaner code by adhering to the Single Responsibility Principle, making your code easier to maintain and extend.

How to Implement the Strategy Design Pattern

Let’s break down the implementation of the Strategy Design Pattern with a simple example. Suppose we are developing a flight simulator that supports multiple flying methods (e.g., Flapping like a bird, Jet Engine powered, and Warp Speed).

Step 1: Define the Strategy Interface

First, we define an interface that all payment strategies will implement.

public interface IFlyingStrategy
{
 void Fly();
}

Step 2: Implement Concrete Strategies

Next, we create concrete classes that implement the IPaymentStrategy interface.

public class Bird : IFlyingStrategy
{
 public void Fly()
 {
 Console.WriteLine("Flying like a bird");
 }
}

public class Plane : IFlyingStrategy
{
 public void Fly()
 {
 Console.WriteLine("Flying using 21st century aviation fuel");
 }
}

public class StarShip : IFlyingStrategy
{
 public void Fly()
 {
 Console.WriteLine("Flying using warp engines");
 }
}

Step 3: Create the Context Class

The context class uses a IFlyingStrategy to perform the payment.

public class FlyContext
{
 private IFlyingStrategy _flyingStrategy;

 public void SetPaymentStrategy(IFlyingStrategy flyingStrategy)
 {
 _flyingStrategy = flyingStrategy;
 }

 public void Fly()
 {
 _flyingStrategy.Fly();
 }
}

Step 4: Use the Strategy Pattern

Finally, we use the FlyContext to fly with different strategies.

class Program
{
 static void Main(string[] args)
 {
 FlyContext context = new FlyContext();

 context.SetPaymentStrategy(new StarShip());
 context.Fly();

 context.SetPaymentStrategy(new Plane());
 context.Fly();

 context.SetPaymentStrategy(new Bird());
 context.Fly();
 }
}

Conclusion

The Strategy Design Pattern is a powerful tool that promotes flexibility, reusability, and maintainability in your code. By encapsulating algorithms and making them interchangeable, you can easily extend and modify your application without disrupting existing functionality. Whether you’re dealing with payment processing, flying machines, sorting algorithms, or any other scenario requiring dynamic behaviour, the Strategy Design Pattern can help you write cleaner and more efficient code.

How to start a code club for kids

funkysi1701@gmail.com (funkysi1701) — Sat, 02 Nov 2024 18:00:45 +0000

Code Clubs are free, welcoming spaces designed to introduce young people to the exciting world of programming and digital skills. Today, I had the pleasure of taking my son—an absolute coding enthusiast—to one of these sessions, held at Leeds Central Library.

The club was hosted in a cozy room on the top floor of the library. Walking in, I expected rows of computers set up for traditional coding exercises. Instead, we found mysterious white lines taped onto the floor. Curious to find out what they were for, we soon learned they were meant to guide robots that the children would be programming. The instructor handed out iPads and small spherical robots known as Spheros, and the children were tasked with programming the robots to follow the lines.

The iPads were preloaded with easy-to-use software that felt familiar to those who’ve used Scratch, a popular block-based coding language. By simply dragging and dropping blocks of code, the kids controlled the robots’ movements. Each “move” block had three variables—direction, speed, and duration—that the children could adjust to guide the robot along the lines.

It was a great hands-on learning experience. My son and I faced a bit of trial and error to figure out which way the robot saw as “forward,” but soon enough, our Sphero was gliding smoothly along the first line. As we went along, we added “pause” blocks between movements, which made the robot stop before changing direction, adding a nice rhythm to its journey along the lines.

Once the main task was completed, there was time for the kids to explore other features. We experimented with different commands, making a smile or frown appear on the robot’s LED display, while others programmed their Spheros to zip around the room, flashing lights and making playful noises.

The club meets every two weeks, and both my son and I left feeling thrilled with the experience. We’re already looking forward to the next session!

If you’re interested in finding a Code Club near you check out https://codeclub.org/en/find , alternatively, https://codeclub.org has lots of resources to explain what code clubs are all about.