DEV Community: Simone Chiaretta

How to uninstall old versions of .NET Core

Simone Chiaretta — Thu, 12 Mar 2020 22:00:26 +0000

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

Simone Chiaretta — Mon, 15 Jul 2019 17:01:40 +0000

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 so 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 that 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.

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

Simone Chiaretta — Mon, 24 Jun 2019 07:32:08 +0000

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 Benchmarkwas built without optimization enabled (most probably a DEBUGconfiguration). Please, build it in RELEASE. If you want to debug thebenchmarks, please seehttps://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 rightpermissions. 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? Follow me on DEV.to and on Twitter to get notified when my analysis on this gets published.

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

Simone Chiaretta — Fri, 21 Jun 2019 13:53:33 +0000

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

Simone Chiaretta — Mon, 10 Jun 2019 16:51:24 +0000

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 implement 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

Simone Chiaretta — Wed, 05 Jun 2019 11:46:11 +0000

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 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 TTD 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

Simone Chiaretta — Thu, 30 May 2019 21:49:41 +0000

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.

The Ray Tracer Challenge... in .NET Core

Simone Chiaretta — Sat, 25 May 2019 09:10:27 +0000

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)

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.