CodeClimber

How to uninstall old versions of .NET Core

Thu, 12 Mar 2020 22:00:26 Z

Uninstalling old versions of .NET Core used to be a tedious process, so much that I had 1.0 and previews of 2.0 still installed.

But now it's super easy thanks to the newly released .NET Core Uninstall Tool.

TL;DR:

Just install the tool, and launch the following command to remove all that is not needed.

sudo ./dotnet-core-uninstall remove --runtime --all
sudo ./dotnet-core-uninstall remove --sdk --all

But if you want to understand more, please keep on reading.

See which version you have installed

If you run the following command on your terminal you can see all the runtimes and SDKs installed on your machine:

dotnet --list-sdks
dotnet --list-runtimes

On my Mac I have 10 SDKs

and 8 versions of the ASP.NET Core runtime and 13 versions of the NETCore runtime.

If you wanted to get rid of the old version, you had to go and manually delete the content of the folders on Mac and via the "Add or Remove Programs" on Windows.

But now you can have a tool to do it for you, the .NET Core Uninstall Tool.

The .NET Core Uninstall Tool

After you installed it, there are a few commands you can run:

list
dry-run (or whatif)
remove

The list command

The list command shows all the SDKs and runtimes you have installed. You can use the options --sdk or --runtime to just show either the SDKs or the runtimes. Or --x64 or --x86 to filter based on the architecture.

As you can see, some runtimes and on SDK are marked as not safe to remove.

The dry-run command

If you have multiple version installed, you probably don't want to delete them individually. The uninstall tool has a series of options to do a bulk delete. But before you delete everything by mistake, you might want to see what each option does. And here comes the dry-run command, which lists the versions that would be deleted by the remove command when called with the same options. Here some examples:

--all will delete everything

--all-below <version>, deletes all versions below the one specified

--all-but <versions>, deletes everything but the specified versions
--all-lower-patches, deletes all versions for which there is a higher patch

--all-previews, deletes all preview versions

--all-previews-but-latest, just keeps the more recent preview (useful when testing pre-releases)
--major-minor <major.minor>, deletes all the version of the specified major.minor

Notice that in none of the examples, the versions listed as "not safe" are not appearing. This because if you remove them you might break some functionality. To include them, add the --force option. But don't worry, you'll get a nice red message to warn you.

The Remove command

Once you've found the parameters to delete the right versions, you can use them with the remove command, to actually delete the versions. The only difference is that you need to run the tool with elevated rights (as Administrator on Windows or via sudo on Mac), and that there is a --yes option to skip the confirmation.

Normally, unless you want to start a new application in an older version, you can delete everything except the latest SDK and runtimes. If you want to be sure you don't cause any problem, the safest commands are:

./dotnet-core-uninstall remove --runtime --all
./dotnet-core-uninstall remove --sdk --all

These will uninstall everything that is not needed by Visual Studio.

If you know you are not going to build new projects with older runtimes, you can also just run remove --runtime --all-but 3.1.1 --force to just keep the latest version.

7 easy steps to install MiniProfiler on an ASP.NET MVC website

Mon, 15 Jul 2019 17:01:40 Z

Today I wanted to add MiniProfiler to an ASP.NET MVC web application (not .NET Core), but unfortunately the NuGet package doesn't set up things correctly, the documentation is a bit lacking, and their sample project doesn't work. What was supposedly a simple task, took almost a full day of research to make it work.

In this post, I'm going to explain in 7 easy steps how to install MiniProfiler on an empty ASP.NET MVC web application.

Step 1 - Create an ASP.NET MVC application

To keep things easy, let's start with creating a new ASP.NET MVC application.

Step 2 - Install the MiniProfiler.MVC5 Nuget package

The correct NuGet package to install is MiniProfiler.MVC5, which supplies the core MiniProfiler package and provides the correct integration with ASP.NET MVC.

Install-Package MiniProfiler.Mvc5

Step 3 - Add the minimum MiniProfiler configuration

The configuration happens in the Application_Start, Application_BeginRequest and Application_EndRequest inside the Global.asax.cs file.

Inside the Application_Start you have to add the following line, to set up the default options.

MiniProfiler.Configure(new MiniProfilerOptions());

Moreover, then add the Application_BeginRequest and Application_EndRequest methods to start and stop the tracking at each request.

protected void Application_BeginRequest()
{
    MiniProfiler profiler = null;
    if (Request.IsLocal)
    {
        profiler = MiniProfiler.StartNew();
    }
}

protected void Application_EndRequest()
{
    MiniProfiler.Current?.Stop();
}

Step 4 - Include the scripts in the view

You now need to include the scripts in the views. The easiest way is to add them in Shared/_Layout.cshtml master view.

At the top, add the namespace using declaration @using StackExchange.Profiling; and at the bottom, just before the </body>

    @MiniProfiler.Current.RenderIncludes()
</body>

Step 5 - Configure the site to route all requests as managed code

If you run the site now, nothing happens. The reason is that MiniProfiler relies on a JavaScript library rendered at the moment, and it is requested as .js, so usually it wouldn't be executed as .NET request. So, you have to add the following line in the web.config.

<system.webServer>
   <modules runAllManagedModulesForAllRequests="true" />
 </system.webServer>

Running now the website you get the MiniProfiler UI in the top left corner of the site, and by clicking you get the execution timings of the page.

Step 6 - Configure to track MVC Controller

The current view is not very useful, as it shows nothing, apart from overall execution. In an ASP.NET MVC application, you can start tracking a bit more information on the execution time of each action, by adding a new filter into the pipeline. Open the FilterConfig.cs file (if you are following along with the basic template) and add this line to the RegisterGlobalFilters method

filters.Add(new ProfilingActionFilter());

Now, rerun the same site, and you'll also see the execution time of the controller.

Step 7 - Start using it

There is no real step 7... but it's cool to have 7 steps.

Jokes aside, now that the basic configuration is working, you can head to the official documentation to see how to start profiling portions of your code in a way that matters, usually done via the Step and CustomTiming methods.

Here some sample code you could add to your actions to experiment a bit.

public ActionResult Index()
{
    var profiler = MiniProfiler.Current;
    using (profiler.Step("Set page title"))
    {
        ViewBag.Title = "Home Page";
    }

    using (profiler.Step("Doing complex stuff"))
    {
        using (profiler.Step("Step A"))
        {
            // simulate fetching a url
            using (profiler.CustomTiming("http", "GET http://google.com"))
            {
                Thread.Sleep(10);
            }
        }
        using (profiler.Step("Step B"))
        {
            // simulate fetching a url
            using (profiler.CustomTiming("http", "GET http://stackoverflow.com"))
            {
                Thread.Sleep(20);
            }

            using (profiler.CustomTiming("redis", "SET \"mykey\" 10"))
            {
                Thread.Sleep(5);
            }
        }
    }

    // now something that loops
    for (int i = 0; i < 15; i++)
    {
        using (profiler.CustomTiming("redis", "SET \"mykey\" 10"))
        {
            Thread.Sleep(i);
        }
    }

    return View();
}

This code generates the trace shown in the following picture.

You can notice some interesting information detected by MiniProfiler. It detected that the code is calling the same 15 times (the loop at the bottom of the action method) and how much of the time is spent in different categories of operations (in the example, http and redis).

An additional feature to add would be tracking SQL statements with the EF6 integration.

A word of caution

Miniprofiler might affect negatively the performances of you application, so it's recommended that you run the profiling code only when Request.IsLocal and in debug mode.

Additionally, when the project is deployed in a production environment, you need to remove the line in the web.config that sets runAllManagedModulesForAllRequests to true. This line forces all requests to be treated by the .NET framework, even static files. And this will affect the performances of the site.

If you don't want to deal with web.config transformations, you can also set the handler specifically for the path used by MiniProfiler (as Paul recommended in the comment below):

<handlers>
   <add name="MiniProfiler" path="mini-profiler-resources/*" verb="*" type="System.Web.Routing.UrlRoutingModule" resourcetype="Unspecified" precondition="integratedMode"/>
</handlers>

How to run micro-benchmarking with BenchmarkDotNet - Bonus post from The Ray Tracer Challenge series

Mon, 24 Jun 2019 07:32:08 Z

In the context of my Ray Tracer Challenge, I wanted to run some performance analysis on my basic operations and data structures. For this installed and used BenchmarkDotNet, an OSS benchmarking tool used by Microsoft for performance testing the .NET Core runtime and class library.

In this post, I'm going to share what I learned about this powerful tool.

How to install BenchmarkDotNet

BenchmarkDotNet is not an application you have to install. It is a .NET library. To install it, create a console application and install the NuGet package.

dotnet new console
dotnet add package BenchmarkDotNet

As simple as that.

Writing benchmarks

Now that you have the project, you need to create a class with the benchmarks you want to run, and finally, add one line to the Main of the Program to start the execution of the benchmarks.

Here a simple example that shows how to test the "performances" of the Sleep method.

using System;
using System.Threading;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

namespace MyBench
{
    public class Sleeps
    {
        [Benchmark]
        public void Time50() => Thread.Sleep(50);

        [Benchmark(Baseline = true)]
        public void Time100() => Thread.Sleep(100);

        [Benchmark]
        public void Time150() => Thread.Sleep(150);
    }

    class Program
    {
        static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<Sleeps>();
        }
    }
}

Notice that every method has the [Benchmark] attribute.

Running benchmarks

Now it's time to run the benchmarks. To do it, just run the console application: dotnet run.

Unfortunately here you encountered the first problem, indicated by a red line in the terminal: you cannot run a benchmark in debug mode.

Assembly MyBench which defines benchmarks is non-optimized Benchmark was built without optimization enabled (most probably a DEBUG configuration). Please, build it in RELEASE. If you want to debug the benchmarks, please see https://benchmarkdotnet.org/articles/guides/troubleshooting.html#debugging-benchmarks.

Unless you want to run the benchmark in debug mode, you have to run it in release mode: dotnet run -c Release.

At this point, you see either one or two more red messages in the terminal, but the execution goes on and complete successfully.

The first complains that there is no solution file. Since you only created a project, this is normal. So skip over it.

The second, which might not appear depending on the OS and permission of the users you logged in with, is also not affecting the success of the execution but might affect the results.

Failed to set up high priority. Make sure you have the right permissions. Message: Permission denied

This message means that the benchmark runner was not able to set the execution to high CPU priority, so the benchmark will run slower, especially if other applications are running at the same time.

If you encounter this problem, either run the command as Administrator on Windows or sudo it if running on Mac or Linux.

Having solved the two issues, the correct way of starting the benchmark is sudo dotnet run -c Release.

Analysing the results

After a while (the example of this post took 45 seconds to complete), you get a summary with the mean execution time of all your benchmarks. By default, you get:

Markdown (Github dialect)
HTML report
CSV you can import in Excel for additional analysis

As example this is what I got from my machine:

Method	Mean	Error	StdDev	Ratio
Time50	52.28 ms	0.4682 ms	0.4380 ms	0.51
Time100	101.99 ms	0.9778 ms	0.9146 ms	1.00
Time150	151.74 ms	0.9426 ms	0.8817 ms	1.49

Usually, you'd get only the Mean, Error and StdDev columns, but since one of the benchmarks was marked as baseline (using the attribute [Benchmark(Baseline = true)]), there is also the Ratio column, which tells you the relative difference in performances.

BenchmarkDotNet can also generate plots with a summary of the results and with a detailed analysis of each execution. It relies on R (a statistical analysis framework) for the execution, so you'd need to install it. On Mac, it's as easy as brew install r.

Additional features of BenchmarkDotNet

We just scratched the surface of BenchmarkDotNet. It has many more features that allow you to run benchmarks under different conditions.

Environments

You can, for example, ask to run the same benchmark on different frameworks, like .NET Core, Mono, x86 or x64 and then compare the results. This is configured via attributes, [CoreJob, ClrJob, MonoJob], or by providing a configuration object.

Parameters

Another interesting feature is the possibility of executing the same benchmarks with different parameters, for example, to see if a particular operation degrades when the number of iterations increases. This is also done with an attribute, [Params].

For example, the same Sleep test could have been done using parameters instead of creating three different benchmarks.

public class Sleeps
{
    [Params(50, 100, 150)]
    public int T { get; set; }

    [Benchmark]
    public void Sleep() => Thread.Sleep(T);
}

The result is slightly different:

Method	T	Mean	Error	StdDev
Sleep	50	52.09 ms	0.7825 ms	0.7319 ms
Sleep	100	102.21 ms	1.2101 ms	1.1319 ms
Sleep	150	152.25 ms	1.3064 ms	1.2220 ms

This approach makes it also more comfortable to compare the results using the default plots generated with R, as some of the charts become more useful.

Running benchmarks

You have already seen the most straightforward way of running the benchmark by merely running the project.

Unfortunately, this method is very limited.

Specifying console arguments

A better method is to change the Main to use BenchmarkSwitcher.

static void Main(string[] args)
            => BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);

This allows a lot of parameters to be passed to the benchmark execution. You can filter which benchmarks to run, change the runtimes on which to run, and specify other configurations parameters that otherwise had to be specified in code or with attributes directly in the benchmark.

Using the global dotnet tool

A final way of running benchmarks is via the global dotnet tool.

You can install it via dotnet tool install -g BenchmarkDotNet.Tool.

Once installed you can run a benchmark by specifying the name of the dll (dotnet benchmark MyBench.dll), and then the same console arguments as with the BenchmarkSwitcher.

Conclusions

I hope I gave you a good overview of this fantastic tool. You can read more information on the official web site https://benchmarkdotnet.org.

While exploring this tool, I tried testing the performance of various ways of concatenating strings. Is StringBuilder faster or slower than String.Join? Subscribe to my RSS feed or follow me on Twitter to get notified when my analysis on this gets published.

Free eBook on ASP.Net Core 2.2 is available for download

Fri, 21 Jun 2019 13:53:33 Z

The eBook on ASP.NET Core 2 I wrote together with Ugo Lattanzi is available for download for free from the Free Ebooks section of Syncfusion Tech Portal.

In April 2017, Ugo Lattanzi and I published ASP.NET Core Succinctly, and it became one of the most downloaded ebook for 2017 and was also 2017 Succinctly Readers Awards Silver Winner, among all the 33 books released by Succinctly in 2017.

This year we published an update to the book. All code and explanation have been adapted and updated to cover version 2.2 of ASP.NET Core, and also we added features that were not available before like:

Health Checks
SPA templates
Razor Pages

So, if you haven't already, go download the book and let us know what you think of it.

The Ray Tracer Challenge - Drawing to a canvas and saving the image to a file

Mon, 10 Jun 2019 16:51:24 Z

In the previous post, I've shown how I implemented chapter 1 of the Ray Tracing Challenge book, coding the basic primitives and their operations. And also implemented a ballistic trajectory calculator. In chapter 2, the goal is to be able to draw an image on a canvas and then saving it to a file.

If you didn't, I recommend you read my introductory post which explains what I'm trying to achieve and why.

Challenges encountered

This was a more straightforward exercise than the one in the previous chapter, but still, not everything was simple.

Modeling the Color class

The concept behind drawing images is very simple. An image is a matrix of pixels, and the value of each pixel is a color. And a color is a "tuple" of three values (the Red, Green, Blue components).

For this reason, the author suggests refactoring the implementation of the Tuple so that there is no need to reimplement the basic operations (add, subtract and multiplication by a scalar). I thought of creating a TupleBase class, which extends Array and implements those 3 operations on the array. Unfortunately, in C#, the Array is a sealed class, and cannot be used as base class. I thought of using a List, but it would probably with a very high-performance cost. I finally decided to just duplicate the code for the 3 operations, and come back to it after this chapter is done.

public class Color
{
    public static readonly Color Black = new Color(0, 0, 0);

    public Color(double r, double g, double b)
    {
        Red = r;
        Green = g;
        Blue = b;
    }

    public double Red { get; set; }
    public double Green { get; set; }
    public double Blue { get; set; }

    //All operations
}

On my GitHub repository, you see the implementation till this point going the tag Chapter 2.1.

Modeling the Canvas class

The Canvas class was pretty straightforward to implement. I used a bi-dimensional array to store the values and implemented an index accessor for setting and reading the values.

public class Canvas
{
    private Color[,] canvas;

    public Canvas(int width, int height) : this(width, height, Color.Black)
    {

    }
    public Canvas(int width, int height, Color background)
    {
        Width = width;
        Height = height;
        canvas = new Color[width, height];
        Initialize(background);
    }

    public int Width { get; set; }
    public int Height { get; set; }

    public Color this[int x, int y]
    {
        get
        {
            return canvas[x, y];
        }

        set
        {
            canvas[x, y] = value;
        }
    }
}

This indexer works fine, but intellisense doesn't show the name of the variables, and while writing the exercise I wish I wrote an explicit method to set the color of a pixel, like Canvas.SetPixelAt(int x, int y, Color color).

On my GitHub repository, you see the implementation of the canvas on the tag Chapter 2.2.

Finally, while writing this post I realized I could have used the same approach also for the base tuple class. I guess now I know how to refactor the implementation.

Implementing the PPM writer

The PPM file format is the most basic file format existing. Each pixel is represented with a string with the three components. If a pixel is white, it will be represented as 255 255 255, 12 bytes per pixel. While a black pixel will be 6 bytes. This makes it probably the most inefficient image format existing. I guess in my "refactoring sprint", I'll try to implement a more efficient format.

Each row of pixels is represented as a series of lines, of max 70 chars, so the code for rendering must also take care of this limit.

public string GetPPMContent()
{
    var builder = new StringBuilder();
    builder.AppendLine("P3");
    builder.AppendLine($"{Width} {Height}");
    builder.AppendLine("255");
    for (int y = 0; y < Height; y++)
    {
        int lineLength = 0;
        for (int x = 0; x < Width; x++)
        {
            string[] colorA = canvas[x, y].ToRGBA();
            foreach (var color in colorA)
            {
                if (lineLength + 1 + color.Length > 70)
                {
                    builder.AppendLine();
                    lineLength = 0;
                }
                if(lineLength!=0)
                {
                    builder.Append(" ");
                    lineLength++;
                }
                builder.Append(color);
                lineLength += color.Length;
            }
        }
        builder.AppendLine();
    }
    return builder.ToString();
}

This algorithm works but doesn't feel right. Probably there is a more elegant way of doing it. More food for my refactoring sprint.

Putting it all together

With those basic image drawing methods implemented, the exercise for chapter 2 was drawing the trajectory implemented in the previous chapter. This was a pretty simple exercise. Only needed to make sure the trajectory felt inside the canvas.

Here is the code for the method that plots the position of the projectile on the canvas, in red.

private static void Draw(Canvas canvas, Tuple position)
{
    var x = (int)sys.Math.Round(position.X);
    var y = canvas.Height - (int)sys.Math.Round(position.Y) - 1;
    //sys.Console.WriteLine($" {x},{y} - {position}");
    if (x >= 0 && x <= canvas.Width - 1 && y >= 0 && y <= canvas.Height - 1)
    {
        canvas[x, y] = new Color(1, 0, 0);
    }
}

The complex part of the exercise was finding some initial values that would produce something visible. The values used in chapter 1 would have fit in a 10 by 10 image.

var p = new Projectile(Tuple.Point(0, 0, 0), Tuple.Vector(1, 1, 0).Normalize());
var e = new Environment(Tuple.Vector(0, -0.1, 0), Tuple.Vector(-0.01, 0, 0));
var c = new Canvas(10, 10);

To generate something more visible I had to increase the velocity of the projectile by 11 (while keeping gravity and wind the same) and launched it at a steeper angle. And with these values, the chart fits into an image which is 900 per 550.

var p = new Projectile(Tuple.Point(0, 1, 0), Tuple.Vector(1, 1.8, 0).Normalize().Multiply(11.3));
var e = new Environment(Tuple.Vector(0, -0.1, 0), Tuple.Vector(-0.01, 0, 0));
var c = new Canvas(900, 550);

On my GitHub repository, you can have a look at the code of the exercise, and the output, both images, the 10x10 and 900x550 sizes.

Conclusions

This chapter was easier to implement than the previous one, but there is still something I'd love to improve. Specifically, I'd like to refactor the Color implementation as child class of a TupleBase shared with the other Tuple class for point and vectors. Also, see if I can make the PPM serialization code a bit nicer and find a more storage efficient file format.

Together with these tasks, I also want to go back to the basic primitives and implement math as operations overloads and do some performance testing to find the most performing data storage solution.

If you like this series of posts and don't want to miss my next episode, please consider subscribing.

The Ray Tracer Challenge - Implementing primitives and vector algebra operations

Wed, 05 Jun 2019 11:46:11 Z

After setting up the project, in this post I start implementing the code for the first chapter of the Ray tracing challenge book, which focuses mostly on defining primitives (Point and Vectors), and vector algebra operations like addition, subtraction and also dot and cross products. And a simple ballistic problem to put all the operations in practice.

If you want to know more, you can read the motivations about this "challenge" in my introductory post.

Challenges encountered

At first, it looked a simple task: how hard could it be to write some methods to perform simple addition, subtractions, and some other basic formulas?

But it was not.

"Re-learning" vector algebra

The first main challenge was "re-learning" vector algebra, and the meaning of the various operations. The book explained well enough for the purpose of the implementation, but I wanted to understand a bit more, and Wikipedia helped a lot. Here some of the links I found:

Modeling the primitives

The main primitive in the 3D space is a Tuple (of 4 elements), with the 3 coordinates (x, y, z) and a value (w) to identify if it is either a vector (w=0) or a point (w=1). I don't know if this is a standard approach or just something the author of the book came up with. Additionally, in chapter 1 the reasoning is not explained but refers to a later chapter to better understand the meaning of this abstraction.

In order to simplify the creation points and vectors, as tuples with the correct value for w, it suggests creating factory methods.

But the book uses pseudocode so that the ray tracer can be implemented in any language, both procedural and object-oriented. For this reason, no additional advice is given on how to actually implement it.

I tried a few approaches.

Inheritance

Instead of creating factory methods, since C# is an object-oriented language, I implemented the primitives as a Tuple base class, that implements all common operations, and two subclasses, Point and Vector, whose constructor sets the correct value for the w parameter.

public class Tuple
{
    public Tuple(double x, double y, double z, double w)
    {
        X = x;
        Y = y;
        Z = z;
        W = w;
    }

    public double X { get; set; }
    public double Y { get; set; }
    public double Z { get; set; }
    public double W { get; set; }

    public Tuple Add(Tuple other)
    {
        return new Tuple(
            X + other.X,
            Y + other.Y,
            Z + other.Z,
            W + other.W
        );
    }

    // All other operations
    ...
}

public class Point : Tuple
{
    public Point(double x, double y, double z) : base(x, y, z, 1.0f) { }
}

public class Vector : Tuple
{
    public Vector(double x, double y, double z) : base(x, y, z, 0) { }
}

It all went fine in the implementation of the library, but things started to fail in the first exercise. The reason is that adding a Point to a Vector should produce a Point. But with this inheritance scheme, that addition will create a Tuple that cannot be cast to a Point. It took me a while to understand that there is no way around this problem (it's actually how inheritance works).

A Projectile (the exercise is a simple ballistic trajectory calculator) is defined as:

public Projectile(Point position, Vector velocity)
{
    Position = position;
    Velocity = velocity;
}

When updating the position of the projectile after one tick you have to add the current position to the current velocity. The result is logically another point (the new w is 1+0=1), but the Add method returns a new Tuple, and this cannot be cast to a Point later on.

public static Projectile Update(Projectile p, Environment e)
{
    return new Projectile(
        p.Position.Add(p.Velocity),
        p.Velocity.Add(e.Gravity).Add(e.Wind)
    );
}

You can see far I went before getting stuck, on my repo, on branch Chapter 1.2.

It's a pity this doesn't work because that would have allowed the most code re-use and keeping point and vector as two separate entities.

Inner value

I then started looking for another solution, to be able to keep the two separate objects, and I implemented them using the "inner value" approach (not sure it's the right name): both Point and Vector have an "innerValue" object of type Tuple on which all operations are done.

public class Tuple
{
    public Tuple(double x, double y, double z, double w)
    {
        X = x;
        Y = y;
        Z = z;
        W = w;
    }

    public double X { get; set; }
    public double Y { get; set; }
    public double Z { get; set; }
    public double W { get; set; }

    public Tuple Add(Tuple other)
    {
        return new Tuple(
            X + other.X,
            Y + other.Y,
            Z + other.Z,
            W + other.W
        );
    }

    // All other operations
    ...
}

public class Point
{
    private Tuple _innerValue;

    public Tuple InnerValue { get => _innerValue; set => _innerValue = value; }

    public Point(double x, double y, double z)
    {
        InnerValue = new Tuple(x, y, z, 1);
    }

    public Point(Tuple tuple)
    {
        InnerValue = tuple;
    }

    public double X { get => _innerValue.X; set => _innerValue.X = value; }
    public double Y { get => _innerValue.Y; set => _innerValue.Y = value; }
    public double Z { get => _innerValue.Z; set => _innerValue.Z = value; }

    public Point Add(Vector other)
    {
        return new Point(InnerValue.Add(other.InnerValue));
    }
    // All other operations
}

public class Vector
{
    private Tuple _innerValue;

    public Tuple InnerValue { get => _innerValue; set => _innerValue = value; }

    public Vector(double x, double y, double z) 
    {
        InnerValue = new Tuple(x, y, z, 0);
    }

    public Vector(Tuple tuple)
    {
        InnerValue = tuple;
    }

    public double X { get => _innerValue.X; set => _innerValue.X = value; }
    public double Y { get => _innerValue.Y; set => _innerValue.Y = value; }
    public double Z { get => _innerValue.Z; set => _innerValue.Z = value; }

    public Vector Add(Vector other)
    {
        return new Vector(InnerValue.Add(other.InnerValue));
    }

    public Vector Add(Point other)
    {
        return new Vector(InnerValue.Add(other.InnerValue));
    }

    //All other operations

}

This approach works, but, unlike the previous approach, I had to reimplement all methods, with the logic of the operation, was delegated to the Tuple. The advantage of this approach is that it is possible to limit the operations (for example, you cannot add 2 points, or subtract a point from a vector) and specify the correct return type (the sum of two vectors is a vector, but the sum of a point and a vector is a point).

This approach works, but it doesn't feel right. Too much code duplication.

You can see how this was implemented on the branch inner-element.

Using factory methods

Finally, I tried using to the suggestion of the author, and I deleted the two classes, only keeping the Tuple, to which I added the 2 static factory methods to set the w parameter for points (w=1) and vectors (w=0). The disadvantage is that I lose the possibility of limiting some operations to either point or vectors and that I cannot easily understand if a tuple is a point or a vector just by reading the code.

public class Tuple
{
    public static Tuple Point(double x, double y, double z)
    {
        return new Tuple(x, y, z, 1);
    }

    public static Tuple Vector(double x, double y, double z)
    {
        return new Tuple(x, y, z, 0);
    }

    public Tuple(double x, double y, double z, double w)
    {
        X = x;
        Y = y;
        Z = z;
        W = w;
    }

    public double X { get; set; }
    public double Y { get; set; }
    public double Z { get; set; }
    public double W { get; set; }

    public bool IsPoint { get => W == 1; }
    public bool IsVector { get => W == 0; }

    public Tuple Add(Tuple other)
    {
        return new Tuple(
            X + other.X,
            Y + other.Y,
            Z + other.Z,
            W + other.W
        );
    }

//All other operations

}

This book adopts a TDD approach, so a data structure that works now might need some refactoring to support new features. For this reason, I finally decided to use the approach suggested by the author, of using factory methods. I will possibly come back on this decision later in the book when concepts become more clear.

You can see how this was implemented on the branch factory-methods.

Which data type to use

The book suggests using a "native" floating point data type since these values will be used a lot. I decided to use a double, even if probably a float would be enough, to avoid lots of casting given that all the System.Math methods work with Double types. And also I'm lazy and I don't want to add f every time I want to specify a value as literal (just 1.7 vs 1.7f).

Performances

I already see some performance issues in this code: creating a new object every time an operation is done will create zillions of objects, and memory will increase.

Also using fields instead of properties, or using struct instead of classes might bring some performance improvement.

Putting it all together

As already mentioned above, the final exercise was about the "Hello World" exercise of vector and physics: the trajectory of a bullet shot with an initial velocity and subject to gravity and wind.

using codeclimber.raytracer;
public class Environment
{
    public Environment(Tuple gravity, Tuple wind)
    {
        Gravity = gravity;
        Wind = wind;
    }

    public Tuple Gravity { get; set; }
    public Tuple Wind { get; set; }
}

public class Projectile
{
    public Projectile(Tuple position, Tuple velocity)
    {
        Position = position;
        Velocity = velocity;
    }

    public Tuple Position { get; set; }
    public Tuple Velocity { get; set; }

    public override string ToString()
    {
        return $"{Position} (v={Velocity})";
    }
}

class Program
{
    static void Main(string[] args)
    {
        var p = new Projectile(Tuple.Point(0, 1, 0), Tuple.Vector(1, 1, 0).Normalize());
        var e = new Environment(Tuple.Vector(0, -0.1, 0), Tuple.Vector(-0.01, 0, 0));
        int i = 0;
        while (p.Position.Y >= 0)
        {
            i++;
            sys.Console.WriteLine($"{i} - {p}");
            p = Update(p, e);
        }
    }

    public static Projectile Update(Projectile p, Environment e)
    {
        return new Projectile(
            p.Position.Add(p.Velocity),
            p.Velocity.Add(e.Gravity).Add(e.Wind)
        );
    }
}

The code is that simple that it just prints out the list of coordinates.

To see I got it right, I imported the result in excel and drawn a chart.

On my GitHub repository you can have a look at the code of the exercise, and the output, both text and Excel.

Conclusions

The basic operations are now implemented. The next chapter in the book is about implementing the code to write images on disk, in PPM format (I suppose the easiest format to implement).

What do you think? Do you think there is a more elegant way to deal with Point and Vector other than using the two static factory methods? Anything else?

I've posted the code already yesterday on my Github repo and I've received already two comments (as issues on my Github repo).

One spotted a mistake I did and the other one posted some great suggestions. He suggested that I could use the new System.MathF class introduced in .NET Core 2.1, to use floats instead of the double (but I'd still have to type the f in literals). He also suggested I use operator overload instead of the methods Add, Subtract, and so on.

I'll switch to operators overload and I'll do a bit of performance optimization before starting with calling these simple operation zillion times.

The Ray Tracer Challenge - Setting up the project with the dotnet CLI

Thu, 30 May 2019 21:49:41 Z

Here it comes, the first post of my journey developing a Ray Tracer using .NET Core on a Mac, using only VS Code. If you didn't, I recommend you read my introductory post which explains what I'm trying to achieve and why.

In this first post I'll talk about the libraries and tools I decided to use, and how I setup the project structure using the dotnet CLI.

Tools used

The only two tools I'm using are VS Code and the dotnet CLI. Let's see how I configured the two.

VS Code

As I mentioned in the introduction to this series of posts, I'm using VS Code, with the basic C#/Omnisharp extension that comes when you download VS Code. In addition, I'm using two other extensions:

the C# Extensions, which adds some nice contextual menu and some additional refactoring;
the .NET Core Test Explorer, which adds a tree-view UI for all the tests in the workspace.

dotnet CLI

The other tool I use, which comes with .NET Core, is the dotnet CLI. One thing I learned while going through the documentation is that it supports TAB completion, but, in order to have it, it must be configured. You can follow the steps on the page "How to enable TAB completion for .NET Core CLI" in .NET Core doc site.

But, in short, add the following code to the ~/.bashrc file.

# bash parameter completion for the dotnet CLI

_dotnet_bash_complete()
{
  local word=${COMP_WORDS[COMP_CWORD]}

  local completions
  completions="$(dotnet complete --position "${COMP_POINT}" "${COMP_LINE}")"

  COMPREPLY=( $(compgen -W "$completions" -- "$word") )
}

complete -f -F _dotnet_bash_complete dotnet

Normally Linux-based systems run this script every time the terminal is opened. But the default MacOS Terminal app runs another file, the ~/.bash_profile (which is normally executed only at login). Other terminals might behave differently, so it's better to add the script in both places. You can either copy the same code in the other file or just include the following lines in the .bash_profile file, so that it automatically calls .bashrc.

if [ -f ~/.bashrc ]; then
   source ~/.bashrc
fi

Libraries used: xUnit

I'm pretty sure some NuGet packages already exist to compute vector and matrix computations, and for saving images. But that would defeat the point of the whole exercise. The only external library I'm referencing is the testing framework.

The book already provides the full test suite in Gherkin format to be used with Cucumber, so the obvious choice, to save time, would be to use the .NET counterpart of Cucumber: SpecFlow.

But despite supporting .NET Core, it seems that SpecFlow relies heavily on its Visual Studio plugin in order to parse the feature files and generate the executable tests. I found some posts explaining how to do it without, but I'd rather start coding instead of spending time working around limitations of one specific testing framework.

So I'll just start with xUnit, and after the first few chapters are completed, go back, try to make SpecFlow work on .NET Core without Visual Studio, and re-implement the tests.

Creating the project structure using the dotnet CLI

The project is simple: two projects (one .NET Standard class lib and one test project) and a solution to link them together.

And here comes the first bit I learned in this process: the dotnet CLI is awesome! You can create solution files, projects and also adding projects to solutions and adding references from one project to another.

All without any manual editing of the files.

dotnet new sln -o src -n ray-tracer-challenge
cd src
dotnet new classlib -o raytracer -n codeclimber.raytracer
dotnet new xunit -o xUnit -n codeclimber.raytracer.xUnit
dotnet sln add **/*.csproj
cd xUnit/
dotnet add reference ../raytracer/codeclimber.raytracer.csproj 
cd ..
dotnet build
dotnet test

This list of commands creates a solution inside a folder called src and 2 projects in their own sub-folders. Then it adds them to the solution, adds a reference from the testing project to the class library, and finally, build and run the tests.

You can see the code at this point in time by going on the Github repo of this project and switching to the two branches:

Chapter 0.1 - Just a script that uses the dotnet CLI to create the project structure and makes sure everything is working fine.
Chapter 0.2 - The basic projects (lib and xUnit test lib) with simple code to make sure testing works fine.

Conclusion

Now that the environment is setup correctly, in the next post I'll start implementing the exercises of the first chapter of the book The Ray Tracer Challenge - A Test-Driven Guide to Your First 3D Renderer.

You can see the full list of posts in the introduction to the series.

Codegarden 19 and how I found a new family

Wed, 29 May 2019 18:46:18 Z

It's now a few days after Codegarden, and after resting a bit, I can sit down, look back and draw some conclusions.

Codegarden 19

This was my 7th Codegarden, but in a sense, it was my toughest. I was in a very bad mood when I arrived. It was due to many reasons, work-related, personal and even related to the community. It was so bad that the day before leaving I was even considering not going at all. When I arrived I was grumpy, easily irritable, but then everything changed, even just after the pre-party. The people there were so friendly, everyone understood how I was feeling and the mood started rocketing. At the end of the 4th day, I was totally reborn. Such an amazing experience.

Why new "family"?

In the title, I say new family. I might wonder why I say that. When I was in Italy, and the first years I was in Belgium, I was a very active member of the Italian ALT.NET community. I was part of the organizers. We organized a lot of successful conferences and all the members were really like family to me. But eventually the ALT.NET moment had no reason to exist anymore, and we closed the community. Then I came to Belgium, tried being part of the local community, but soon the local Microsoft developer evangelism group closed, and the community was Dutch-based and being the only non-Dutch speaker felt weird. And some individuals aside, I never really bonded with the people either.

I attended lots of Codegardens and many other Umbraco conferences, I even contributed to the Core with some (accepted) PRs, but I never felt an active part of the community. There are so many bright and much more committed individuals that I didn't feel like I was bringing anything.

Then came Codegarden 19, and all the amazing support received, the great discussions and inspiring talks, and I think I've now found a community I can call family. Or maybe it has always been, but I never realized it.

Way forward

This year I now want to contribute more, so I'd like to follow up on some of the ideas and inspirational talks from this year. And this year there is so much to do that I feel like a list is due:

Migrate my blogs (this and my test-bed blog) to v8
Build a simple v8 content app/package
Migrate my NuTranslation (better translation manager) to v8
experiment more with Computer Vision API, Machine Learning
experiment with building a chatbot backed by Umbraco

But before I start any of these, I want to finish (or at least go a bit further) with my Raytracer challenge.

The Ray Tracer Challenge... in .NET Core

Wed, 22 May 2019 18:57:14 Z

I just bought the book The Ray Tracer Challenge - A Test-Driven Guide to Your First 3D Renderer and in the upcoming months, I'll be developing my own ray tracer, in .NET Core.

I will also document my learning experience on the blog, for me, to keep track of my progress, and maybe discuss some implementation decisions with you, my readers, but also to share what I learn in the process.

Why am I doing it

Nowadays I spend most of my time building CMS-based projects, using APIs provided by vendors, and aggregating results coming from Cloud-based services. And I stopped enjoying development.

I needed a change, I needed to find back my love for developing, and I needed to challenge myself to learn something new. The book teaches the theory of a ray tracing, and, using a TDD approach, makes you implement, from scratch, all the pieces needed: starting from basic vector and matrix computations, to image processing and storing, and finally going into the real-deal of rendering 3D scenes from scratch.

Rebuilding all the basic primitives might sound silly at first, in the current development world were developers reuse code and packages even for simple tasks as adding padding to strings. But the goal of the book is to help you rediscover the fun of developing from scratch, doing things yourself, without relying on stuff done by others.

Technologies used

The project will be implemented with .NET Core 2.2, with no external libraries, to adhere the most to the concept of the book, which is to build everything from scratch, even features that might exist already as part of .NET Standard or in other packages, like Color, Point, image rendering and serializing.

My objective is also to build everything using a Mac, the dotnet CLI and VS Code, to prove (mostly to myself) that this is a feasible approach, and that you can do everything you need without the full-blown Visual Studio.

I'll also try to use the latest features of the C# language, whenever makes sense.

The book recommends the usage of Cucumber for the testing and even provides the full set of features in Gherkin. SpecFlow is the only Gherkin implementation for .NET, but it seems like the support for .NET Core is not very advanced, and still relies on their Visual Studio plugin for generating the test files. So I'll start with plain old unit testing with xUnit, and will move to SpecFlow later.

What I'll be learning

Such a project will involve a lot of learning: I will learn new things, improve the knowledge I have and since there is a lot of math involved, I will re-learn things I've learned at the university.

Specifically, things I hope to learn better are:

Obviously, how raytracing works;
Math, Algebra, Matrix, Vectors, and similar stuff;
usage of the dotnet CLI;
a more advanced use of VS Code (now I mostly use it "just" as text editor);
New features of C# (with new I mean from v6 onwards);
xUnit;
BDD with Gherkin and SpecFlow;
Performance testing once everything is done.

Show me the code

All code is hosted on Github: https://github.com/simonech/ray-tracer-challenge-netcore.

The repository will also include the posts of the series. To familiarize yourself with the structure of the repository, please have a look at the README file.

Table of Content

I'll try to write a post at least once per chapter of the book, and document how things are going, the challenges I faced and what I learned. I will update this table of content with every post published

The Ray Tracer Challenge... in .NET Core - Introduction (this post)
The Ray Tracer Challenge - Setting up the project with the dotnet CLI
The Ray Tracer Challenge - Implementing primitives and vector algebra operations
How to run micro-benchmarking with BenchmarkDotNet - Bonus post from The Ray Tracer Challenge series

I hope you will subscribe to my blog (if you don't have already) and will learn together with my how implementing ray tracing in .NET Core.

Moving from product development to technology expert

Thu, 09 May 2019 09:15:38 Z

It's a while I'm not writing on my blog, but I feel the time has come to post a small "career" update, and given the new position I'll hopefully continue posting on a more regular basis.

A bit more than 9 years ago I joined the Council of European Union as Lead Architect in the team working on the public web sites of the Council.

And these have been 9 amazing years.

We've launched the revamped version of the public website based on Umbraco (actually we also launched another version, based on another CMS, but that's another story), and all the customizations needed also made more involved into the Umbraco community, and started getting me into translation technologies, like XLIFF. I discussed all of these topics in a talk at Codegarden 17, titled Fast and furious(ly) multilingual: Publishing of EU politics in 24 languages with Umbraco.

We've also launched another Umbraco based website, the video portal of the Council: TvNewsroom. This is also 100% running on Azure, making use of various cloud-native components, including Computer Vision for automatic some part of the publishing workflow.

What started as small technological island in our team, has now spread across the whole IT department: Umbraco has become the product of choice for building CMS-based projects (and we already have 3 additional projects running in production, even on the "headless" flavour, and more are coming in the future), Azure is starting to be adopted more and more, and XML-based export of translation is going to be implemented not only for translating the pages of the website but also for the "real deal", which is official legislative documents.

So, starting from last month (exactly 9 years after my start at the Council), I've joined the Development Architecture team, reporting directly to the Head of Unit of the Design and Development Unit. Here I'll oversee all Umbraco projects (avoiding other teams implement it "wrong"), will experiment with Umbraco v8 and how to migrate to the new version, I will make sure all teams know what Azure has to offer, and use it properly, and I will contribute to adoption of XLIFF across all document production.

There will be less (or no) product development, which sometimes gets a bit boring now that we entered a more stable phase of the project, but there will be more experimentation of new features and technologies, and services. And the new position will force me to stay more up to date with what is happening.

So, fun times ahead.

Codegarden 2018: talking about git, CI/CD and Xliff

Tue, 22 May 2018 22:09:44 Z

During the next three days I'll be attending at Umbraco Codegarden 2018, and together with a colleague we are going to share some insights on how we make sure our team of 10+ developers and designers doesn't mess up our Umbraco solution, how we do automated build and deployment of Umbraco project and how we customised Umbraco to export translation requests in Xliff v2.0.

In details here are our talks:

Building Umbraco websites in big teams (Wed May 23rd, 15:00, Main Stage)
Ask us anything about the Council of European Union website (Thu May 24th, 11:15, Lightning Talk)
Extending the Umbraco backend to translate content in 24 languages with XLIFF v2.0 (Thu May 24th, 11:5, Lightning Talk)

If you come and attend one our my talk, you might have the chance to win a copy my book, Front-end Development with ASP.NET Core, Angular, and Bootstrap.

See you at CG18

Preface to Frontend development with ASP.NET Core MVC, Angular and Bootstrap - Day 24

Sun, 24 Dec 2017 12:30:32 Z

On the last day of my 24 days of Christmas from my upcoming book Front-end Development with ASP.NET Core, Angular, and Bootstrap I want to share the preface to the book written by Mads Kristensen, PM in the Visual Studio team at Microsoft.

The web becomes an increasingly capable platform with each new browser release. Tomorrow’s new features become available to early adopters while yesterday’s stabilize for mass adoption. This ever-growing toolbox of HTML, CSS, and JavaScript capabilities seems to be accelerating and shows no signs of slowing down. In fact, it’s growing so fast that specialized tooling is required to take advantage of these new features – tooling such as WebPack and Gulp.

The amount of knowledge required to build modern browser applications is illustrated by the new job title “front-end engineer” – a term that didn’t exist just a few years ago.

In addition to the advances in the web platform, the server-side technologies powering the web are evolving as well. To provide the best experience for both end-users and web developers, the server-side platform must be ultra-fast, secure, cross-platform, cloud scalable and have great tooling.

Most web applications consist of client-side code running in the browser and server-side code running on one or more servers. So, to be a proficient web developer it is necessary to know enough of both client- and server technologies and that is a big challenge. Because how much is enough and how much time should we devote to continuously learning?

One way to make it easier for ourselves is to choose the right set of frameworks and tools to build our applications upon. Frameworks are useful because they usually wrap complex platform features into easy-to-use components, so web developers can focus on writing their applications logic instead of all the plumbing needed to work with the browser or server platforms.

Choosing the right frameworks is important. The options are many, but here are a few that have shown to be particularly well suited for building modern web applications. ASP.NET Core as the application framework for the server and Angular for the client is a great combination. Bootstrap makes sure the app looks good in all browsers and on all types of devices.

Simone has done a great job showing how these frameworks complement each other and how tooling provides a great development experience. In the fast-moving world of web development, it is good we have books like this to give us a pragmatic approach to building web applications using the latest and greatest in both client- and server technologies.

With this post I conclude the series. If you liked it, I encourage you to go pre-order my book and now enjoy you season holidays!

The book Table of Content - Day 23 - 24 days of "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

Sat, 23 Dec 2017 12:30:18 Z

With the series coming to an end, it's time to look back at these last 22 days of content, and see how they relate to the outline of my upcoming book "Front-end Development with ASP.NET Core, Angular, and Bootstrap".

Introduction
- Day 1 - Polyglot Developer
Chapter 1: What's new in ASP.NET Core MVC
- Day 2 - Web Host Builder in ASP.NET Core 2.0
- Day 3 - TagHelper syntax for View Components
Chapter 2: The Front-End Developer Toolset
- Day 4 - The Front-end developer toolset
- Day 5: Not just Bootstrap: Semantic UI
Chapter 3: Angular in a Nutshell
Chapter 4: Bootstrap in a Nutshell
- Day 9 - Bootstrap Responsive Grid System
- Day 10 - Bootstrap Snippet Pack for Visual Studio
Chapter 5: Managing dependencies with NuGet and Bower
- Day 11 - What are package managers and why we need them
- Day 12 - How to publish your own Nuget Package
Chapter 6: Building your application with Gulp and webpack
- Day 13 - What is the role of build systems in front-end development
- Day 14 - Introduction to webpack
Chapter 7: Deploying ASP.NET Core
Chapter 8: Developing outside of Windows
- Day 18 - Omnisharp: the tooling behind the C# integration in Visual Studio Code
- Day 19 - Git support in VS Code
Chapter 9: Chapter 9: Putting It All Together

How to add Social Media Authentication to ASPNET Core - Day 22 - 24 days of "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

Fri, 22 Dec 2017 10:27:26 Z

It's day 22 and till now I've shared two or three extracts from all the chapters, in the order in which they appear on my upcoming book "Front-end Development with ASP.NET Core, Angular, and Bootstrap". For today I'll still share something from the last chapter: how to enable social media authorization to an ASP.NET Core application.

Adding social media authentication is easy with ASP.NET Core. You start by creating another project, still as an ASP.NET Core MVC project, and selecting Individual User Accounts as the Authentication mode. This way the project template will add the database entities, controllers, and views to collect and store all the information needed to create a private site where users can register either directly (providing a username and password) or via OAuth providers like Facebook, Twitter, Google, Microsoft, GitHub, and others.

Adding a social login is just a matter of adding the right Nuget package and configuring the authentication provider in the ConfigureService method in the Startup class. For example, to add a Facebook login, add the Nuget package Microsoft.AspNetCore.Authentication.Facebook. Then add the following lines of code in the ConfigureService method:

services.AddAuthentication().AddFacebook(facebookOptions =>
{
    facebookOptions.AppId = Configuration["Authentication:Facebook:AppId"];
    facebookOptions.AppSecret = Configuration["Authentication:Facebook:AppSecret"];
});

Now you have to register a new application on the Facebook developer portal in order to get the AppId and AppSecret needed to authenticate your application with Facebook. Go to the URL https://developers.facebook.com/apps/ and click on the Add a New App button and add the basic information for your app. Once done go the settings and enter the URL for the OAuth redirect page, which is /signin-facebook (but you need to specify the absolute URL, so also http://localhost:nnn). This route is added by the Nuget package for the Facebook authentication.

The last thing is to retrieve the AppId and AppSecrets needed for the application to work. For this go to the Dashboard inside the developer portal

Now that you have these values, you have to store them in the settings of your application. Since these are sensitive data, you don't want to accidentally commit them to a public source repository, so it's better to store them in the User Secrets.

The file is stored in the user profile, still easily readable, but in theory only by its owner. The in production these information can be passed to the app in different ways, like shown when explaining the configuration of app settings inside the WebHost.

{
  "Authentication": {
    "Facebook": {
      "AppId": "myappId",
      "AppSecret": "myappsecret"
    }
  }
}

Now just launch the site and you'll see a new button to sign-in and log-in via Facebook.

This post is an extract of chapter 9 of my upcoming book "Front-end Development with ASP.NET Core, Angular, and Bootstrap". To know more about what I'm publishing, don't forget to check my blog again, subscribe to my RSS feed, follow me on twitter or like the Facebook page of my book.

How to seed your database with EF Core - Day 21 - 24 days of "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

Thu, 21 Dec 2017 12:00:01 Z

Yesterday I've shown how to do EF Core DB migrations using either the Package Manager Console or the dotnet CLI. But you can also do these code migrations automatically, triggering them via code.

After following the steps shown yesterday, you have all your migrations setup, and you can apply the DB changes using the dotnet CLI. But there is less-know feature, still experimental and not ironed out completely, that makes it possible to run migrations from code, and even seeding the DB with initial data.

Apply migrations with code

To just apply migrations you need to call the db.Database.Migrate() method, where db is the EF Context.

Typically the following is the code needed to run the migration in code:

public static void Initialize(IServiceProvider service)
{
    using (var serviceScope = service.CreateScope())
    {
        var scopeServiceProvider = serviceScope.ServiceProvider;
        var db = scopeServiceProvider.GetService<TriathlonRaceTrackingContext>();
        db.Database.Migrate();
    }
}

This method can be called in the Configure method in the Startup class:

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
  ...
  Initialize(app.ApplicationServices);
}

Seeding the DB with data

As part of the database initialization you can also add some initial test data to the database. Unfortunately it is not that automated as in Entity Framework 6, but can be coded manually.

For, example, to add a new entry in the Race table, to code is as following:

private static async Task InsertTestData(TriathlonRaceTrackingContext context)
{
    if(context.Races.Any())
        return;
    var race = new Race { Name="Ironman World Championship 2017",Location="Kona, Hawaii",Date=new DateTime(2017,10,14,7,0,0) };
    context.Add(race);
    await context.SaveChangesAsync();
}

The advantage of having to code it yourself is that you can decide if/when/how to seed the database. In this I just do it if the Race table is empty. But I could have decided to always wipe it clean, or anything else.

To include data seeding into the Initialize method, a few changes have to made as the data seeding is an async method. So the Initialize becomes an InitializeAsync:

public static async Task InitializeAsync(IServiceProvider service)
{
    using (var serviceScope = service.CreateScope())
    {
        var scopeServiceProvider = serviceScope.ServiceProvider;
        var db = scopeServiceProvider.GetService<TriathlonRaceTrackingContext>();
        db.Database.Migrate();
        await InsertTestData(db);
    }
}

Also the call from the Configure method must be slightly changed into InitializeAsync(app.ApplicationServices).Wait();.

Entity Framework Core migration - Day 20 - 24 days of "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

Wed, 20 Dec 2017 12:46:23 Z

In the last chapter of my upcoming book "Front-end Development with ASP.NET Core, Angular, and Bootstrap" I build a very simple application to show how all the various technologies play together, and also to show some features that are not specific to front-end development but are needed in a real world application.

One of the technologies I don't cover in the other chapters of the book but is covered in the last chapter is Entity Framework Core. Today I'm showing is loosely taken from the section about EF Migrations.

Let's say you have a class called Race defined by the following lines of code

public class Race
{
    public int ID { get; set; }
    public string Name { get; set; }
    public string Location { get; set; }
    public DateTime Date { get; set; }
}

In order to work, EF Core needs to know the mapping between database tables, fields and properties of classes. The easiest approach, unless you want to write a lot of mapping code yourself, is to just stick to the default mapping conventions, and name tables and columns accordingly. And the best way of doing it, is to let EF generate the database for you. And this is done with a feature of EF called migrations.

Migrations can be used for the first setup of the database but more importantly later in the development when adding more features that require new tables or columns for existing tables.

To create the baseline migration for the class Race, you need to run the Add Migration command to generate the code to create the database schema (it gets stored in the Migrations folder), followed by the Update Database command to run this code on the database.

These two commands can be run either inside Visual Studio 2017, the Package Manager Console, or using the dotnet command-line tool. In the first option type the following:

PM>Add-Migration Initial
PM>Update-Database

If you prefer using the dotnet command line, type these lines in the command prompt (but first you need to add the Microsoft.EntityFrameworkCore.Tools.DotNet package to the DotNetCliToolReference to the .csproj file).

>dotnet ef migration Initial
>dotnet ef database update

The table is created in the database configured in the appsettings.json file, under the ConnectionSettings section.

In the case of the Race class, the migration code generated is the following:

migrationBuilder.CreateTable(
    name: "Race",
    columns: table => new
    {
        ID = table.Column<int>(type: "int", nullable: false)
            .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
        Date = table.Column<DateTime>(type: "datetime2", nullable: false),
        Location = table.Column<string>(type: "nvarchar(max)", nullable: true),
        Name = table.Column<string>(type: "nvarchar(max)", nullable: true)
    },
    constraints: table =>
    {
        table.PrimaryKey("PK_Race", x => x.ID);
    });

And the following mapping code:

modelBuilder.Entity("TriathlonRaceTracking.Models.Race", b =>
    {
        b.Property<int>("ID")
            .ValueGeneratedOnAdd();
        b.Property<DateTime>("Date");
        b.Property<string>("Location");
        b.Property<string>("Name");
        b.HasKey("ID");
        b.ToTable("Race");
    });

This post is an extract of chapter 9 of my upcoming book "Front-end Development with ASP.NET Core, Angular, and Bootstrap". Tomorrow I'll continue covering Entity Framework Core migrations.

To know more about what I'm publishing, don't forget to check my blog again, subscribe to my RSS feed, follow me on twitter or like the Facebook page of my book.

Git support in VS Code - Day 19 - 24 days of "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

Tue, 19 Dec 2017 12:57:10 Z

Visual Studio Code comes with native support for Source Control systems. Let's see how it integrates with Git.

Originally Visual Studio Code came with native support for Git, but recently, in order to allow support for other systems, also the source control support became an external plugin. At the moment there six SCM provider

Let's have a look at my favorite features of the Git support in Visual Studio Code.

The one I like the most, and was just recently added is the visual representation of which files have changed directly in the file explorer view.

Another feature I like is the diff view, which can be both side by side or inline.

And diff can also be displayed by simply clicking on the gutter.

Another feature I like is the easy procedure for committing code: just type the message and you can commit all the changes. Or you can also choose which changes to commit.

And once committed, the status bar shows that there is a pending commit

Also, in the command palette, there are accessible most of the git commands, like branch, checkout, clone, merge, commit, ecc...

But to really enhance the experience using Git in VS Code, I recommend also checking out two very useful extensions:

Git history which adds, as the name suggests, possibility of reading the change logs, compare between commits and see a graph of all commits, branches and merges
Git Lens which adds code lens features (so small overlay next to lines of code showing when and by who it was changed) and much more

This article contained some of the pieces that didn't make into chapter 8 of my upcoming book "Front-end Development with ASP.NET Core, Angular, and Bootstrap" because to volatile for a printed book. So consider this a "bonus" section.

To know more about what I'm publishing, don't forget to check my blog again, subscribe to my RSS feed, follow me on twitter or like the Facebook page of my book.

Omnisharp: the tooling behind the C# integration in VS Code - Day 18 - 24 days of "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

Mon, 18 Dec 2017 12:56:01 Z

We are entering the last week of the calendar, and we are also reaching the end of the book. Today is time to look at the cross-platform tools used to develop ASP.NET Core application on any platform. We'll have a look at Visual Studio Code, and specifically how the C# integration works.

Visual Studio Code is just a simple text editor, with no language-specific features or knowledge. All language-specific tools are coming as external extensions, either developed by Microsoft or by the community.

So how can Visual Studio Code show Intellisense when you type .NET code, or provide refactoring suggestions or show compilation errors in real time? This is done using Omnisharp. Here is an extract from chapter 8 of book, which briefly explains what Omnisharp is.

All these features, as far as their support for .NET Core is concerned, are possible thanks to OmniSharp. OmniSharp is a set of OSS projects that work together for bringing .NET development to any text editor.

The base layer is a server that runs Roslyn and analyzes the files of the project that is open inside the editor.

On top of this there is an API (REST-based over HTTP or over pipes) that allows clients (text editors via their extensions) to query the code model to get intellisense, parameter information, the references to a variable, or the definition of a method. At the top layer are all the editor-specific extensions that display the information retrieved from the OmniSharp server in a user-friendly way. The top layer also includes other features that are purely client-side such as code formatting or snippet expansion. It is also the extensions that interact with the debugger to provide all the features needed for debugging your code.

OmniSharp extensions have been developed for the most popular text editors on the market. Apart from Visual Studio Code, there are extensions for Atom, Vim, Sublime, and even Emacs. This means that you can continue using your favorite text editor and still be able to get all the benefit of a rich code-editing experience powered by OmniSharp.

This article was short summary of the chapter about deploying ASP.NET Core from my upcoming book "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

To know more about what I'm publishing, don't forget to check my blog again, subscribe to my RSS feed, follow me on twitter or like the Facebook page of my book.

Continuous Deployment on Azure Git - Day 17 - 24 days of "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

Sun, 17 Dec 2017 12:40:46 Z

Deploying to Azure can be done with WebDeploy, as seen yesterday, but we can also go one step further and setup a continuous deployment using Git.

The first step is to create the App Service directly in the Azure portal, and then configure the Deployment Source.

As you can see from the image you can select Visual Studio Team Services, a local Git repository or hosted git like Github or Bitbucket, or even file storage like Drobpox or OneDrive.

The easist solution is configuring a Local repository directly in Visual Studio and then add as additional remote the git repository just created from the portal (the url can be found in the overview of the Azure App Service). This can be done either from within Visual Studio or with the Git command line.

Now the code can be pushed to the remote, either directly from Visual Studio or from the command line. As part of the push operation, Azure launches the publish command, which restores all NuGet packages and builds the application using the project file. Every time a commit is pushed to the repository, the publish process starts, effectively implementing a continuous deployment scenario.

If you created the remote within Visual Studio, the remote is not tracked by the local repository, so the first time you want to push, you have to do it from the Command Prompt and type: git push -u azure master. The -u option instructs git to start tracking the remote branch.

On Azure portal you can see the list of deployments and the log message for each commit.

This article was short summary of the chapter about deploying ASP.NET Core from my upcoming book "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

To know more about what I'm publishing, don't forget to check my blog again, subscribe to my RSS feed, follow me on twitter or like the Facebook page of my book.

Deploy ASP.NET Core apps to Azure - Day 16 - 24 days of "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

Sat, 16 Dec 2017 12:12:34 Z

Yesterday we've seen how to deploy an ASP.NET Core app to IIS, and today we look at how to do the same on Azure.

Publishing on Azure is super-simple and can be easily done from within Visual Studio.

From the overview screen of the project, just select "Publish" and then "Microsoft Azure App Service".

You can then either select an existing App Service or create a new one directly from the Publish dialog, without going to the Azure Portal.

One thing I recommend doing is also creating a new Resource Group and service plan (if you are just testing, remember to select the Free size).

So, nothing different from a standard ASP.NET application. The only difference is that the actual publishing consists on Visual Studio running dotnet publish to create the file bundle on a temporary folder, followed by Web Deploy moving the files to the server.

There is another way of deploying applications to Azure, and it is done via Git. But this is something for another day.

This article was short summary of the chapter about deploying ASP.NET Core from my upcoming book "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

To know more about what I'm publishing, don't forget to check my blog again, subscribe to my RSS feed, follow me on twitter or like the Facebook page of my book.

Deploy ASP.NET Core apps on IIS - Day 15 - 24 days of "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

Fri, 15 Dec 2017 10:54:35 Z

After developing the ASP.NET Core application, adding client-side interactivity with Angular and styling with Bootstrap, all automated using webpack and with dependencies managed with Nuget, the time has come to deploy the application.

My upcoming "Front-end Development with ASP.NET Core, Angular, and Bootstrap" book explains how to deploy ASP.NET Core applications with three different methods:

On-Prem on IIS
On Azure App Services
To Docker containers

On day 15 of my advent calendar I'm showing how to publish to a local IIS.

In "classic" ASP.NET, applications are DLLs that are hosted inside the IIS Application Pool (also known as Worker Process, w3wp.exe). They are instantiated from IIS's runtime manager. When requests come in, they are sent to the HttpRuntime of the right site, which lives inside an AppPool. In short, they are basically modules controlled by IIS itself.

In ASP.NET Core, it is totally different. ASP.NET Core applications (remember, they are all console applications) run their own web server using Kestrel. Each application already hosts itself and can directly respond to requests over HTTP, so you might be wondering why you need IIS in first place.

In this case IIS basically acts as a reverse proxy, receiving the requests and forwarding them to the ASP.NET Core application self-hosted on a Kestrel web server. Then it waits for the execution pipeline to complete its processing and sends back the HTTP output to the originator of the request.

This is accomplished by AspNetCoreModule, which calls the dotnet run command to fire up the application the first time it is requested.

This module is configured via the web.config file in the root of the application.

<?xml version="1.0" encoding="utf-8"?>
<system.webServer>
</system.webServer>

But you don't have to worry too much about this web.config since it's automatically generated, together with the compiled DLLs and other configuration files, when you run the dotnet publish command.

Now rarely people still deploy to servers on premise, so tomorrow I'm going to show how deploying to Azure. Come back to my blog to read more, and to read more about deploying applications on IIS and Azure, please consider pre-ordering my book.

To know more about what I'm publishing, don't forget to check my blog again, subscribe to my RSS feed, follow me on twitter or like the Facebook page of my book.

Introduction to webpack - Day 14 - 24 days of "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

Thu, 14 Dec 2017 10:04:34 Z

What is webpack? Why is it listed as part of my chapter on build automation systems? Let's find it out in this extract from chapter 6 of my upcoming "Front-end Development with ASP.NET Core, Angular, and Bootstrap".

webpack is a module bundler that loads all the dependencies of a JavaScript application and bundles them to optimize the loading time in the browser. Although it is not strictly speaking a task runner, webpack can be used to accomplish most of the tasks performed by Gulp, like minification, bundling, and linting. Let’s see how this works.

webpack’s main concepts

webpack has a bit steeper learning curve compared to Gulp, so before seeing some examples, let’s have a look at the main concepts: entry, output, loaders, and plugins.

It all starts with the entry point of the application, which is where webpack starts to follow the dependencies tree from. The end of the process is the output, which is where webpack will save the bundle once it has completed its job. Between the entry and the output, all the processing happens, which is done by loaders and plugins.

webpack is a JavaScript module bundler, which means that it discovers JavaScript modules and their dependencies and bundles them. However, webpack can also treat .css files, sass files, TypeScript files, and even images and .html files. Loaders are used to “convert” any kind of file in a module treatable by webpack. Plugins do not work on the individual source files but are used to perform general operations on the final output of the bundling.

The configuration of webpack is stored in a webpack.config.js file.

For example, the following configuration bundles all JavaScript files of the application (or at least the ones "reachable" from the entry point via ECMAScript 5 export/import of modules)
var path = require(‘path’);

module.exports = {
  entry: ‘./src/index.js’,
  output: {
    filename: ‘bundle.js’,
    path: path.resolve(__dirname, ‘dist’)
  }
}

The book covers the usage of webpack more in details. If you are interested, please consider pre-ordering my book.

Tomorrow I'm going to cover installation of ASP.NET Core on on-prem IIS. If you are interested, don't forget to check my blog again, subscribe to my RSS feed, follow me on twitter or like the Facebook page of my book.

What is the role of build systems in front-end development - Day 13 - 24 days of "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

Wed, 13 Dec 2017 11:03:55 Z

With JavaScript frameworks becoming more and more complicate, and with the increasing demand for performances also on the client-side of applications, gone are the days when it was just enough to put some javascript or css files in a static folder. Today, 13 days into the advent calendar of my upcoming book "Front-end Development with ASP.NET Core, Angular, and Bootstrap", I'm going to share an extract of chapter 6, which introduces the role build systems in front-end development.

What Front-End Build Systems are for

In the context of server-side compiled languages, build systems are used to compile code into binaries, to run tests, to compute metrics, and to perform transformations of configuration files from development to a production setup. Other typical operations include moving files around and creating release files. Front-end build systems are also used for more or less the same reasons as server-side build systems because even front-end development requires "compiling" code files into "binaries" (for example Less or Sass to CSS or TypeScript to JavaScript) or running JavaScript test suites or metrics (JSLint for example). However, front-end development also requires some tasks that are specific to JavaScript and CSS development and that are used during the development phase and not just during the final release. One such task is automatically including references to Bower files. Another example is minification and concatenation of JavaScript and CSS files to reduce the size and number of files downloaded by the client.

The rest of the chapter explains how to perform some of the most common tasks. It will show how to:

Automatically include references to Bower packages

Compile Sass files to CSS

Compile TypeScript to JavaScript

Combine and minify JavaScript and CSS files

Run JSLint to detect JavaScript problems

Perform tasks and automatically reload the browser when changes are detected in a file

The tool used to show how to perform these tasks is Gulp, since it is the tool the .NET community is mostly leaning toward. Later in the chapter there is also a quick introduction to webpack, which was already briefly mentioned in Chapter 3 since it is used by the Angular Command Line tool and is gaining a lot of traction in the front-end development community.

Tomorrow I'll give a quick introduction to webpack, so come back for more.

If you are liking this series of posts, please consider pre-ordering my upcoming book "Front-end Development with ASP.NET Core, Angular, and Bootstrap", from which all these extracts are taken, and cover all of these topics more in details.

How to publish your own Nuget Package - Day 12 - 24 days of "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

Tue, 12 Dec 2017 15:50:25 Z

With package managers you consume libraries but eventually you will end up releasing yours for others to use, either to the community or as shared among co-workers. Today we look into how to do it with Nuget and .NET Core.

Doing a Nuget package was a bit convoluted with the traditional .NET Framework, but with .NET Core it's very easy.

Add metadata

After having developed the application, just add to your .csproj file the metadata needed (no need for a specific .nuspec).

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>netcoreapp2.0</TargetFramework>
    <PackageId>Wrox.Book</PackageId>
    <PackageVersion>1.0.0</PackageVersion>
    <Authors>Simone Chiaretta</Authors>
    <Description>Show the title of the book</Description>
    <PackageReleaseNotes>First release</PackageReleaseNotes>
    <Copyright>Copyright 2017 (c) Simone Chiaretta</Copyright>
    <PackageTags>book title Wrox</PackageTags>
    <PackageProjectUrl>http://example.com/Wrox.Book/</PackageProjectUrl>
    <PackageIconUrl>http://example.com/Wrox.Book/32x32icon.png</PackageIconUrl>
    <PackageLicenseUrl>http://example.com/Wrox.Book/mylicense.html</PackageLicenseUrl>
  </PropertyGroup>
</Project>

Create the package

Now just go to the root of the project (where the .csproj is) and type dotnet pack -c Release. This will build the project and create a nuget package file, saved in bin\Release.

If you now open the file with the Nuget Package Explorer you'll see the content of the file

Publish the package

Now you can just either copy the file to a local repository or publish it to the Nuget public repository. To do so:

Download the NuGet command line utility (the dotnet cli is not enough here). You can install it via Nuget as well: Install-Package NuGet.CommandLine
Create an account on the NuGet.org gallery (if you don't have one)
Set your API-KEY: nuget setApiKey Your-API-Key
Publish the package: nuget push YourPackage.nupkg

This topic is covered more in details, together with how to develop packages for NPM and bower, on my upcoming book "Front-end Development with ASP.NET Core, Angular, and Bootstrap". If want to read more extracts of the book, come and visit my blog again tomorrow.

What are package managers and why we need them - Day 11 - 24 days of "Front-end Development with ASP.NET Core, Angular, and Bootstrap"

Mon, 11 Dec 2017 11:51:16 Z

Over the weekend I wrote about the Bootstrap grid system and the Bootstrap Snippet Pack for Visual Studio, both extracts from Chapter 4 of my upcoming book "Front-end Development with ASP.NET Core, Angular, and Bootstrap".

Today I'm going to cross halfway point in my book, taking a extract from chapter 5, which is about package managers and Nuget, NPM, Bower. And I'm going to introduce package managers and why we need them.

Why we need package managers

Modern software development, both front-end and server-side, is based on small and very focused components that can be composed as needed.

While it is good to avoid the monolithic frameworks of the past, this new approach introduces a problem: how do you manage all these components? Components usually depend on other components, which depend on yet other components, which depend... well, you got the idea. To make things more difficult, there might be a component, let's call it A, that depends on component B, but also another component, C, that also depends on B, but a different version of it. And on top of this, all components must be kept up-to-date. Finally, in some cases, to correctly install a component, additional operations might be needed, like compiling some native library or changing some configuration files.

Fortunately, all these tasks are automated by specific tools that are called package managers.

What package managers do

All package managers, apart from the obvious differences given by the different technologies or languages they target, are practically identical. Here are their common concepts:

They all rely on a public registry that contains all published packages. The registry might also store the actual package or just provide the URL where the package can be downloaded.

Packages are downloaded and stored in a local folder (usually within the current user folder) that acts as a local cache. This way when a project needs a package that has been already downloaded, it's directly copied from the cache instead of being downloaded again (providing that it is the latest version). This saves bandwidth and time (especially if packages are restored every time a project is built). It also allows some kind of offline development experience that would be otherwise impossible.

Projects declare which third-party libraries they depend on. This is usually done by specifying in a JSON file the names of the packages and their versions.

Package managers take care of downloading not only the projects’ dependencies but also the libraries they depend on, descending the entire tree of packages.

There are still lots of interesting topics coming up from my book. If you are interested in knowing more, come back tomorrow and also remember to follow me on Twitter @simonech and like the Facebook page for my book.