DEV Community: Zachary Patten

More C# Console Games

Zachary Patten — Thu, 10 Feb 2022 02:11:08 +0000

Back on Jan 28, 2020 I wrote an article, Learn C# Through Console Games.

TLDR: I have been working on a GitHub repository with open source C# console game examples aiming to help people learn C# in fun ways. :)

When I wrote that first article, the repo had 8 console game examples. As of now I have coded 27 console games, so I've added 19 in the past 2 years. I felt like writing this follow-up article so I could highlight some of those games and share some thoughts I had while coding them. :)

Keep in mind I only work on this in my spare time for fun. Most of the games in the repo took me less than 10 hours to develop, although there are a few exceptions I'll mention below.

NOTE! The mobile versions of this site don't use monospace font for code blocks, so the visual examples in this article do not render correctly on mobile. They render correctly when on a desktop browser.

Drive

^{Added November 2021}

..............            ........................
...............            .......................
................            ......................
.................            .....................
..................            ....................
...................            ...................
....................            ..................
....................            ..................
....................            ..................
....................            ..................
....................            ..................
....................            ..................
....................            ..................
...................            ...................
..................            ....................
.................            .....................
..................            ....................
...................            ...................
....................            ..................
.....................            .................
......................            ................
.......................     ^      ...............
......................            ................

In this game, the background scrolls downwards and you try to keep your ^ car on the road with the arrow keys ↑, ←, →.

One topic I had to overcome while making this game is that there is no built-in way to query if a key is down or not; there is no Console.IsKeyDown(ConsoleKey.LeftArrow) method. You would have to dig into native libraries for that, which I wanted to avoid for these game examples. So, I couldn't just have the car move left while you hold down the ← left arrow key. I had to compromise by having the arrow keys ↑, ←, → set the velocity of the car rather than needing to be held down. Press left arrow key ← once and it will set the velocity of the car to turn left. Now there is no need to continually query if the left arrow is down because the velocity will be constant until a different key is pressed.

The road is randomly generated. Each time the background scrolls downward it randomly generates a new row at the top. There are three types of road that it can generate:
    1. straight
    2. turn left
    3. turn right
When I started randomly generating the road, I split it evenly and gave each possible option a 1/3 chance to be the next row. However, that usually resulted in a mostly straight road with jagged edges that wasn't very fun to play. :D

....................            ..................
...................            ...................
....................            ..................
.....................            .................
....................            ..................
....................            ..................
.....................            .................
....................            ..................
.....................            .................
.....................            .................
......................            ................
.....................            .................
......................            ................
.......................     ^      ...............
......................            ................

How did I fix this? I added in a bias that so that when a new row is generated it has a 4/5 chance to be the same as the previously generated row. For example, this meant that once a left turn was started, it would likely continue to turn left for at least several rows. This resulted in roads that you would expect to see in a driving game with some longer turns and straightaways.

Drive was one of the easiest games to make and turned out to be one of the most enjoyable to play in my opinion. Unlike Snake, which starts off slow/easy and gradually gets harder, Drive has a consistent difficulty until you make a mistake and die.

Role Playing Game

^{Added October 2021}

╔═══════════════════════════════════════════════════════════════════════════════════════════════════╗
║                                                                                                   ║
║                                                                                                   ║
║            /---\                                                                 /---\            ║
║      /---\/-Inn-\                              _._                              /Store\  /---\    ║
║     /-\/-\|     |                             |___|                             |     | /-\/-\    ║
║     \ /\ /|  █  |                                                               |  █  | \ /\ /    ║
║                                                 O                                                 ║
║                                                L|(                                                ║
║                                                 |                                                 ║
║                                                ( \                                                ║
║--\         /---\  /---\         /---\                       /---\  /---\         /---\         /--║
║---\       /-----\/-----\       /-----\                     /-----\/-----\       /-----\       /---║
║   |#######|     ||     |#######|     |                     |     ||     |#######|     |#######|   ║
║█  |#######|  █  ||  █  |#######|  █  |                     |  █  ||  █  |#######|  █  |#######|  █║
║═══╗╔═════╗╔═════╗╔═════╗╔═════╗╔═════╗  |-|    |-|    |-|  ╔═════╗╔═════╗╔═════╗╔═════╗╔═════╗╔═══║
║███║║█████║║█████║║█████║║█████║║█████║ _| |_  _| |_  _| |_ ║█████║║█████║║█████║║█████║║█████║║███║
║███║║█████║║█████║║█████║║█████║║█████║ \   /  \   /  \   / ║█████║║█████║║█████║║█████║║█████║║███║
║═══╝╚═════╝╚═════╝╚═════╝╚═════╝╚═════╝  \ /    \ /    \ /  ╚═════╝╚═════╝╚═════╝╚═════╝╚═════╝╚═══║
║                                                                                                   ║
╚═══════════════════════════════════════════════════════════════════════════════════════════════════╝
Move: arrow keys or (w, a, s, d)                                                                     
Check Status: [enter]                                                                                
Quit: [escape]

This game is pretty self explanatory... It is a role playing game. When most people think of a "text based RPG" they probably think of a purely text question-and-answer type of game with stuff like Where would you like to move (n, s, e, w)?. Although Role Playing Game is technically a "text-based RPG", it visually represents the world with WASD movement and character animations (albeit rather simple character animations).

Role Playing Game is currently the most complex of the games I have added to the repo. While most games took 5-10 hours to code, Role Playing Game took 25-30 hours to code. Luckily I was able to re-use some assets from other games, such as the character running animation from Hurdles, and the punching + fall + get up + idle animations from Fighter.

One of the features I wanted to add with this game was respecting the current console size. You can resize the console window and the game will re-render itself with the character in the center of the screen. Nothing revolutionary of course :D but dynamic screen size is a little weird when you are dealing with a console/terminal application. Not sure if it was a bug, but I kept getting ArgumentOutOfRangeException exceptions when setting the Console.BufferHeight or Console.BufferWidth even though my values were totally valid, so I had to wrap it in an ugly try-catch. Also, there are some differences between cmd.exe and the VsDebugConsole.exe (Visual Studio Debug Console). When you write to the last character in a line, they behave differently. One will write the character and stay on the same line while the other will write the character and jump to the next line, and since I was Console.WriteLine()-ing at the end of each row, one console had blank lines while the other did not. :D But it was an easy fix once I figured out what was happening.

Even though all the graphics were made out of ascii characters, I still found it beneficial to make sprite sheets and define the maps with sprites. The game has 3 different maps: town, field, and castle. Here is what the definition of the field map currently looks like for example:

public static readonly char[][] Field = new char[][]
{
    "mmmpmmmmpmmmmmpmmmmmpmmmmmpmmmpmmmpmmmpmm".ToCharArray(),
    "mmpppppppmmmpppmmmpppppmmppmmmpmmmmpppmmm".ToCharArray(),
    "mmpmmpmmpmppmmpmpmmpmmpmmmmmmpppmmpmpmmmp".ToCharArray(),
    "TTTTTc     mpmm    cTT           m2mcmmpp".ToCharArray(),
    "TTTT        mm                    g   mmm".ToCharArray(),
    "TTT   TT                 mm           mpm".ToCharArray(),
    "TTT           TTT      mmmm     TT    ppm".ToCharArray(),
    "www      T              mm     TTT    www".ToCharArray(),
    "www          TT    ww           T     www".ToCharArray(),
    "www                 ww  TTT         wwwww".ToCharArray(),
    "www   w0w      Tww                 mmmmmm".ToCharArray(),
    "wwww          wwwwwww      TT   cmmmmmmmm".ToCharArray(),
    "wwwwwwwwwwwwwwwwwwwwwTTTTTTTTTTTTmmmmmmmm".ToCharArray(),
    "wwwwwwwwwwwwwwwwwwwwTTTTTTTTTTTTTTmmmmmmm".ToCharArray(),
    "wwwwwwwwwwwwwwwwwwwTTTTTTTTTTTTTTTTmmmmmm".ToCharArray(),
};

Each of the characters is an id of a sprite. See the source code for the full list, but here are what a few of the characters represent: W is water, m is mountains, and T is tree.

Wordle

^{Added January 2022}

 ╔═══╦═══╦═══╦═══╦═══╗
 ║ H ║ O ║ U ║ S ║ E ║
 ╠═══╬═══╬═══╬═══╬═══╣
 ║ P ║ L ║ A ║ C ║ E ║
 ╠═══╬═══╬═══╬═══╬═══╣
 ║ S ║ E ║ A ║ R ║ S ║
 ╠═══╬═══╬═══╬═══╬═══╣
 ║   ║   ║   ║   ║   ║
 ╠═══╬═══╬═══╬═══╬═══╣
 ║   ║   ║   ║   ║   ║
 ╠═══╬═══╬═══╬═══╬═══╣
 ║   ║   ║   ║   ║   ║
 ╚═══╩═══╩═══╩═══╩═══╝

"Wordle" has gone a bit viral and is all over social media. I just wanted to mention that I hate this game. :P But I went ahead and coded it because it was too easy not to code it. :D But the game still sucks...

PacMan

^{Added December 2020}

    ╔═══════════════════╦═══════════════════╗
    ║ · · · · · · · · · ║ · · · · · · · · · ║
    ║ · ╔═╗ · ╔═════╗ · ║ · ╔═════╗ · ╔═╗ · ║
    ║ + ╚═╝ · ╚═════╝ · ╨ · ╚═════╝ · ╚═╝ + ║
    ║ · · · · · · · · · · · · · · · · · · · ║
    ║ · ═══ · ╥ · ══════╦══════ · ╥ · ═══ · ║
    ║ · · · · ║ · · · · ║ · · · · ║ · · · · ║
    ╚═════╗ · ╠══════   ╨   ══════╣ · ╔═════╝
          ║ · ║                   ║ · ║
    ══════╝ · ╨   ╔════---════╗   ╨ · ╚══════
            ·     ║ █ █   █ █ ║     ·        
    ══════╗ · ╥   ║           ║   ╥ · ╔══════
          ║ · ║   ╚═══════════╝   ║ · ║
          ║ · ║       READY       ║ · ║
    ╔═════╝ · ╨   ══════╦══════   ╨ · ╚═════╗
    ║ · · · · · · · · · ║ · · · · · · · · · ║
    ║ · ══╗ · ═══════ · ╨ · ═══════ · ╔══ · ║
    ║ + · ║ · · · · · · █ · · · · · · ║ · + ║
    ╠══ · ╨ · ╥ · ══════╦══════ · ╥ · ╨ · ══╣
    ║ · · · · ║ · · · · ║ · · · · ║ · · · · ║
    ║ · ══════╩══════ · ╨ · ══════╩══════ · ║
    ║ · · · · · · · · · · · · · · · · · · · ║
    ╚═══════════════════════════════════════╝

PacMan is... a PacMan clone in the console. Get the dots. Dodge the ghosts. It's not intended to be very faithful though. I didn't research the AI of the ghost, I just came up with my own AIs that worked. Here is what I did for the ghost AIs:
    - Ghost a: follows you via Dijkstra Path Finding and updates every 6 frames (faster)
    - Ghost b: randomly moves and updates every 6 frames (faster)
    - Ghost c: follows you via Dijkstra Path Finding and updates every 12 frames (slower)
    - Ghost d: randomly moves and updates every 12 frames (slower)
Note: for this game I pulled in a reference to my nuget package Towel because it includes generic versions of the Dijkstra Path Finding algorithm.

Out of all the games, this is the only one that really needs color. All the other games could likely be pretty easily made to not rely on color, but without different colors in Pac Man, you wouldn't be able to distinguish the ghosts or Pac Man, and we also need the ghosts to turn blue when Pac Man eats one of the + bigger dots. The ConsoleColor enum only has 16 different colors, but luckily I've been able to make everything work so far with that very limited palette. Yes there are ways to render more colors in the console, but these are intended to be relatively simple examples for newer developers, so I don't want to overcomplicate things if I can make due with just ConsoleColor.

PacMan, like Role Playing Game, took a bit longer than most of the other games to develop. I can't remember exactly how long it took to code, but a good guess is that it took me ~20 hours to code. I've never actually been a fan of Pac Man, so it wasn't all that fun to make for me. :D But... I like a challenge so I did it anyway.

Mancala

^{Added February 2022}

  ╔══════════════════════════════════╗
  ║ |  |[ 8][ 0][ 1][ 0][ 6][ 7]|  | ║
  ║ |  |                        |  | ║
  ║ | 3|                        | 4| ║
  ║ |  |             \/         |  | ║
  ║ |  |[ 7][ 1][ 0][ 7][ 2][ 2]|  | ║
  ╚══════════════════════════════════╝

Mancala is currently the newest game in the repo. It was a suggestion from a user on the C# Discord Server. I had never played Mancala before coding this game, so if anyone is a Mancala expert and finds a bug in my code, please let me know. :D

Mancala was a funny game to code, because the game itself is extremely simple, but I found visually representing it in the console harder than it would seem. When you make a move, you pick up seeds and move in a counter-clockwise motion putting a seed in each pit along the way. How do you represent that in the console? I started to make a little counter clock-wise animation, but quickly found myself thinking, "This animation is not going to help anyone learn how to play Mancala." :D So instead of trying to have some fancy animation, I just show the +X and -X of each pit and store after a move is processed:

  ╔══════════════════════════════════╗
  ║ |  |[ 4][ 4][ 4][ 4][ 4][ 4]|  | ║
  ║ |  |                        |  | ║
  ║ | 0|                      +1| 1| ║
  ║ |  |         -4  +1  +1  +1 |  | ║
  ║ |  |[ 4][ 4][ 0][ 5][ 5][ 5]|  | ║
  ╚══════════════════════════════════╝

I thought that would be the best way to convey what happened to the user. But it still isn't great, and I assume Mancala is probably the most confusing game to play in the entire repo unless you are already familiar with Mancala.

Fighter

^{Added February 2020}

 HP █████         ███████████ HP 
 EN ███████               ███ EN 

                    o            
           O___.   _>)           
          L(       \|            
           |        |            
          / >                    
=================================

I'd never seen a 2D fighter game in the console, so I decided to make this game to try to push myself to see if it was possible. Is it good? Nope. :D But... hey... it works. So, can you make a 2D fighting game in the console? Yes! Yes you can!

As of writing this article, Fighter definitely has the worst code quality of all the games. There is spaghetti code and magic numbers . :P You are welcome. Maybe someday I'll clean up the code and improve the game a bit. But the goal isn't to make AAA games here, this is the console/terminal after all.

Sudoku

^{Added August 2020}

╔═══════╦═══════╦═══════╗
║ 7 6 2 ║ 9 1 5 ║ 8 4 3 ║
║ 5 4 3 ║ 7 8 6 ║ 2 1 9 ║
║ 9 1 8 ║ 2 3 4 ║ 5 7 6 ║
╠═══════╬═══════╬═══════╣
║ 4 3 1 ║ 5 9 8 ║ 7 6 2 ║
║ 6 2 5 ║ 4 7 3 ║ 1 9 8 ║
║ 8 7 9 ║ 1 6 2 ║ 3 5 4 ║
╠═══════╬═══════╬═══════╣
║ 3 9 6 ║ 8 5 1 ║ 4 2 7 ║
║ 1 8 4 ║ 6 2 7 ║ 9 3 5 ║
║ 2 5 7 ║ 3 4 9 ║ 6 8 1 ║
╚═══════╩═══════╩═══════╝

Pretty much exactly what you would expect... Sudoku in the console....

Conclusion

If anything here caught your interest, or if you know someone who is looking for fun beginner C# projects, I encourage you to check out the repo where all the games are open source: https://github.com/ZacharyPatten/dotnet-console-games. My general recommendation is for beginners to play the games, find one they like, then try to code it from scratch; if you get stuck you have the working example to refer to.

I would also gladly accept contributions if you make a console game of your own and would be willing to add it to the repo. Or if you have an idea of a game you would like to see in the console, feel free to comment below or open a discussion on the GitHub repo. :)

How many more console game will I make? No idea. :P But I have several ideas, so you can expect to see more in the future.

Thank you for reading. Have a great day!

Random Generation (with efficient exclusions)

Zachary Patten — Sun, 31 Jan 2021 05:41:01 +0000

Note: code examples are in C#, but the theory should be applicable to most programing languages

"How do I generate random numbers except for certain values?" - This is a relatively common question that I aim to answer with this post. I wrote some extension methods for the topic that look like this:

Random random = new();

int[] randomNumbers = random.Next(
    count: 5,
    minValue: 0,
    maxValue: 100,
    excluded: stackalloc[] { 50, 51, 52, 53 });

// if you want to prevent duplicate values
int[] uniqueRandomNumbers = random.NextUnique(
    count: 5,
    minValue: 0,
    maxValue: 100,
    excluded: stackalloc[] { 50, 51, 52, 53 });

There are two algorithms you can use:

Pool Tracking: you can dump the entire pool of possible values in a data structure (such as an array) and randomly generate indices of that data structure. See Example Here
Roll Tracking: you can track the values that that need to be excluded, reduce the range of random generation, and then apply an offset to the generated values. See Example Here

Which algorithm is faster? It depends...
Here are estimated runtime complexities of each algorithm:

Pool Tracking: O(range + count + excluded)
Roll Tracking: O(count * excluded + excluded ^ 2)

Notice how algorithm #1Pool Tracking is dependent on the range of possible values while algorithm #2 Roll Tracking is not. This means if you have a relatively large range of values, then algorithm #2 is faster, otherwise algorithm #1 is faster. So if you want the most efficient method, you just need to compare those runtime complexities based on the parameters and select the most appropriate algorithm. Here is what my "Next" overload currently looks like: See Source Code Here

public static void Next<Step, Random>(int count, int minValue, int maxValue, ReadOnlySpan<int> excluded, Random random = default, Step step = default)
    where Step : struct, IAction<int>
    where Random : struct, IFunc<int, int, int>
{
    if (count * excluded.Length + .5 * Math.Pow(excluded.Length, 2) < (maxValue - minValue) + count + 2 * excluded.Length)
    {
        NextRollTracking(count, minValue, maxValue, excluded, random, step);
    }
    else
    {
        NextPoolTracking(count, minValue, maxValue, excluded, random, step);
    }
}

Notes:

I have included these extensions in a Nuget Package.
I have Benchmark Results Here and the Benchmarks Source Code Here.
I have another article on this topic (with graphs) here if interested: Generating Unique Random Data (but I wrote that before these overloads that allow exclusions)

Specifically to point out one benchmark in particular:


BenchmarkDotNet=v0.12.1, OS=Windows 10.0.18363.1316 (1909/November2018Update/19H2)
Intel Core i7-4790K CPU 4.00GHz (Haswell), 1 CPU, 8 logical and 4 physical cores
.NET Core SDK=5.0.200-preview.20614.14
  [Host]     : .NET Core 5.0.2 (CoreCLR 5.0.220.61120, CoreFX 5.0.220.61120), X64 RyuJIT
  Job-JNMXTF : .NET Core 5.0.2 (CoreCLR 5.0.220.61120, CoreFX 5.0.220.61120), X64 RyuJIT

InvocationCount=1  UnrollFactor=1

Method	MaxValue	Count	Exclued	Mean	Error	StdDev	Median
Towel	1000000	1: sqrt(sqrt(range))	1: sqrt(sqrt(range))	3.575 μs	0.2149 μs	0.6025 μs	3.300 μs
HashSetAndArray	1000000	1: sqrt(sqrt(range))	1: sqrt(sqrt(range))	6,172.451 μs	128.1054 μs	369.6132 μs	6,091.300 μs
SetHashLinkedAndArray	1000000	1: sqrt(sqrt(range))	1: sqrt(sqrt(range))	6,975.152 μs	344.0002 μs	1,014.2922 μs	6,633.050 μs
RelativelySimpleCode	1000000	1: sqrt(sqrt(range))	1: sqrt(sqrt(range))	NA	NA	NA	NA

In that benchmark the range was 1,000,000 and the count was sqrt(sqrt(1,000,000)) ~= 31 and the number of excluded values was sqrt(sqrt(1,000,000)) ~= 31 so it is a rather extreme example but it demonstrates the difference between algorithm #1 (3.575 μs) and #2 (6,172.451 μs).

Thanks for reading. Feedback appreciated. :)

Value-Based Attributes in C#

Zachary Patten — Sun, 20 Sep 2020 00:59:24 +0000

Value-Based Attributes in C Sharp

This code is a snippet from the https://github.com/ZacharyPatten/Towel project.
Please check out the project if you want to see more code like it. :)

Attributes in C# are great. They let you add metadata onto members of your code that can be dynamically looked up at runtime. However, they are also a bit of a pain to deal with. You generally have to make your own class that inherits System.Attribute and add a decent bit of boiler plate code to look up your attribute with reflection. Here is an example of making your own attribute:

using System;
using System.Linq;
using System.Reflection;

static class Program
{
    static void Main()
    {
        MyAttribute attribute = typeof(MyClass).GetCustomAttributes<MyAttribute>().FirstOrDefault();
        Console.WriteLine("MyCustomAttribute...");
        if (!(attribute is null))
        {
            Console.WriteLine("Found: " + true);
            Console.WriteLine("Value: " + attribute.Value);
        }
        else
        {
            Console.WriteLine("Found: " + false);
            Console.WriteLine("Value: " + null);
        }
    }
}

public class MyAttribute : Attribute
{
    public string Value { get; private set; }

    public MyAttribute(string value)
    {
        Value = value;
    }
}

[MyAttribute("hello world")]
public class MyClass { }

Sure... it's not a ton of boiler plate... but it is still annoying... so I made a value-based attribute so that I can use constant values rather than having to define a new attribute type:

using System;
using Towel;

static class Program
{
    static void Main()
    {
        var (Found, Value) = typeof(MyClass).GetValueAttribute("MyCustomAttribute");
        Console.WriteLine("MyCustomAttribute...");
        Console.WriteLine("Found: " + Found);
        Console.WriteLine("Value: " + Value);
    }
}

[Value("MyCustomAttribute", "hello world")]
public class MyClass { }

The first parameter of the ValueAttribute is like a key while the second parameter of the
attribute is the actual value. Then you just use the GetValueAttribute extension method with the key (first parameter) and it will do the reflection for you. You can add multiple ValueAttributes per code member:

[Value("Name", "Array Benchmarks")]
[Value("Description", "These benchmarks do...")]
[Value("Source URL", "google.com")]
public class MyBenchmarks
{
    // code...
}

How does it work? It does exactly the same thing as the first example, but it just looks for
the the ValueAttribute that contains the matching key value. Here is the source code:

using System;
using System.Reflection;

namespace Towel
{
    /// <summary>A value-based attribute.</summary>
    [AttributeUsage(AttributeTargets.All, AllowMultiple = true)]
    public class ValueAttribute : Attribute
    {
        internal object Attribute;
        internal object Value;

        /// <summary>Creates a new value-based attribute.</summary>
        /// <param name="attribute">The attribute.</param>
        /// <param name="value">The value.</param>
        public ValueAttribute(object attribute, object value)
        {
            Attribute = attribute;
            Value = value;
        }
    }

    /// <summary>Extension methods for reflection types and <see cref="ValueAttribute"/>.</summary>
    public static class ValueAttributeExtensions
    {
        /// <summary>Gets a <see cref="ValueAttribute"/> on a <see cref="MemberInfo"/>.</summary>
        /// <param name="memberInfo">The type to get the <see cref="ValueAttribute"/> of.</param>
        /// <param name="attribute">The attribute to get the value of.</param>
        /// <returns>
        /// (<see cref="bool"/> Found, <see cref="object"/> Value)
        /// <para>- <see cref="bool"/> Found: True if the attribute was found; False if not or if multiple attributes were found (ambiguous).</para>
        /// <para>- <see cref="object"/> Value: The value if found or default if not.</para>
        /// </returns>
        public static (bool Found, object Value) GetValueAttribute(this MemberInfo memberInfo, object attribute)
        {
            _ = memberInfo ?? throw new ArgumentNullException(nameof(memberInfo));
            bool found = false;
            object value = default;
            foreach (ValueAttribute valueAttribute in memberInfo.GetCustomAttributes<ValueAttribute>())
            {
                if (ReferenceEquals(attribute, valueAttribute.Attribute) || attribute.Equals(valueAttribute.Attribute))
                {
                    if (found)
                    {
                        return (false, default);
                    }
                    found = true;
                    value = valueAttribute.Value;
                }
            }
            return (found, value);
        }

        /// <summary>Gets a <see cref="ValueAttribute"/> on a <see cref="ParameterInfo"/>.</summary>
        /// <param name="parameterInfo">The type to get the <see cref="ValueAttribute"/> of.</param>
        /// <param name="attribute">The attribute to get the value of.</param>
        /// <returns>
        /// (<see cref="bool"/> Found, <see cref="object"/> Value)
        /// <para>- <see cref="bool"/> Found: True if the attribute was found; False if not or if multiple attributes were found (ambiguous).</para>
        /// <para>- <see cref="object"/> Value: The value if found or default if not.</para>
        /// </returns>
        public static (bool Found, object Value) GetValueAttribute(this ParameterInfo parameterInfo, object attribute)
        {
            _ = parameterInfo ?? throw new ArgumentNullException(nameof(parameterInfo));
            bool found = false;
            object value = default;
            foreach (ValueAttribute valueAttribute in parameterInfo.GetCustomAttributes<ValueAttribute>())
            {
                if (ReferenceEquals(attribute, valueAttribute.Attribute) || attribute.Equals(valueAttribute.Attribute))
                {
                    if (found)
                    {
                        return (false, default);
                    }
                    found = true;
                    value = valueAttribute.Value;
                }
            }
            return (found, value);
        }
    }
}

Beginner's Guide To Console Input In C#

Zachary Patten — Sat, 01 Aug 2020 20:57:22 +0000

Beginner's Guide To Console Input In C Sharp

Note: I recommend reading this article in order because Examples 1-6 build on each other.

Example 1: Getting Console Input With Console.ReadLine

How to get console input.

Example 2: Parsing The Console Input From String To Int32

How to convert the console input into a numeric value.

Example 3: Validating Console Input With Int32.TryParse

How to validate numeric input to prevent bugs in your code.

Example 4: Looping Until User Provides Valid Input

How to continually ask for input until the user provides valid input.

Example 5: Additional Validation (0-100)

How to add custom validation logic on the user input.

Example 6: Optional Code Style Changes Over Example 5

How to clean up your code a bit.

Example 7: Another Example... Array Of Possible Inputs

How to allow input from an array of possible inputs.

Example 8: Another Example... Multiple Inputs At Once

How to allow users to input multiple values at once.

Example 9: Watching Individual Key Presses With Console.ReadKey

How to watch each individual key press from the user.

Make sure you have a using System; are the top of your file. Then whenever you want input from the user just use the Console.ReadLine() method.

Example 1: Getting Console Input With `Console.ReadLine`

using System;

class Program
{
    static void Main()
    {
        Console.Write("Provide input: ");
        string input = Console.ReadLine();
        Console.WriteLine($"Your input: {input}");

        Console.WriteLine("Press [enter] to continue...");
        Console.ReadLine();
    }
}

Console.Write(...)

string

= Assignment

Console.ReadLine()

Console.WriteLine(...)

$ String Interpolation

So in Example 1, we are successfully getting input from the user. The input is stored in the input variable and is a string data type. The string data type is not a numerical data type, therfore if you wanted to perform math operations on the input such as int doubleInput = 2 * input; it will not work. So the next step is to convert the data type from string to whatever type you need it to be. For this example we will convert the type from string to int.

Example 2: Parsing The Console Input From `String` To `Int32`

using System;

class Program
{
    static void Main()
    {
        Console.Write("Please enter an integer: ");
        string input = Console.ReadLine();
        int inputValue = int.Parse(input); // <- This is a bug!
        Console.WriteLine($"Your input: {inputValue}");

        Console.WriteLine("Press [enter] to continue...");
        Console.ReadLine();
    }
}

int

int.Parse(...)

Note: There are numerous C# tutorials that use the Convert.ToInt32(...) method, but you should avoid this method. Convert.ToInt32(...) is an old method from before NET Framework 2.0, and we now have better methods to use isntead.

Example 2 shows how you can convert a string to an int using the int.Parse(...) method. It works when the user provides valid input such as 123, but it will throw an exception at runtime if the user provides invalid input such as duck. Thus, this is a bad practice and should be avoided or you may run into bugs in your software. The next step would be to validate the input rather than just trying to directly parse it into an int.

Example 3: Validating Console Input With `Int32.TryParse`

using System;

class Program
{
    static void Main()
    {
        Console.Write("Please enter an integer: ");
        string input = Console.ReadLine();
        int inputValue;
        bool success = int.TryParse(input, out inputValue);
        if (success)
        {
            Console.WriteLine($"Your input: {inputValue}");
        }
        else
        {
            Console.WriteLine($"Invalid Input.");
        }

        Console.WriteLine("Press [enter] to continue...");
        Console.ReadLine();
    }
}

int.TryParse(...)

if-else

An out parameter is a way for methods to pass back more than one value. The int.TryParse method is passing back two values to the calling code:

The bool return value that indicates if the parse was successful. In Example 3 we are storing this value in the success variable.
The int typed out parameter that is the resulting value of the parse. In Example 3 we are storing this value in the inputValue variable.

Example 3 shows how to validate that the input from the user using the int.TryParse method. We just need use branching (in this case an if statement) to check if the return value of int.TryParse is true (successful) or false (unsuccessful).

Now we have proper input validation for int data types, but what if you need a valid input in order to continue? The next step is to loop until the user provides valid input.

Example 4: Looping Until User Provides Valid Input

using System;

class Program
{
    static void Main()
    {
        Console.Write("Please enter an integer: ");
        string input = Console.ReadLine();
        int inputValue;
        bool success = int.TryParse(input, out inputValue);
        while (!success)
        {
            Console.WriteLine("Invalid Input. Try again...");
            Console.Write("Please enter an integer: ");
            input = Console.ReadLine();
            success = int.TryParse(input, out inputValue);
        }
        Console.WriteLine($"Your input: {inputValue}");

        Console.WriteLine("Press [enter] to continue...");
        Console.ReadLine();
    }
}

while

Example 4 shows how we can continually request input from the user until valid input is provided. When we get past the while loop, we are guaranteed that the inputValue variable has been populated by a valid user input. However, what if we need to validate that value further? What if we want it to only be condsidered valid input if the value is between 0 and 100? The next step is to add additional validation.

Example 5: Additional Validation (0-100)

using System;

class Program
{
    static void Main()
    {
        Console.Write("Please enter an integer (0-100): ");
        string input = Console.ReadLine();
        int inputValue;
        bool success = int.TryParse(input, out inputValue);
        bool valid = success && 0 <= inputValue && inputValue <= 100;
        while (!valid)
        {
            Console.WriteLine("Invalid Input. Try again...");
            Console.Write("Please enter an integer 0 and 100: ");
            input = Console.ReadLine();
            success = int.TryParse(input, out inputValue);
            valid = success && 0 <= inputValue && inputValue <= 100;
        }
        Console.WriteLine($"Your input: {inputValue}");

        Console.WriteLine("Press [enter] to continue...");
        Console.ReadLine();
    }
}

! Logical Negation

<= Less Than Or Equal To

&& Logical AND

In Example 5 we added additional validation logic. Now when the loop ends we know that inputValue is a valid int value proviided by the user and it is in the 0-100 range. That is pretty much all you need to know to accept proper int input in your console applications.

Although Example 5 is fully functional, we can shorten it a bit if we want to, but any changes at this point are code style preferences and are not required. In particular though, it would be nice if we created variables for the min and max ranges of the valid user input and used a variable for the message to provide input from the user to prevent duplicated hard-coded string values.

Example 6: Optional Code Style Changes Over Example 5

using System;

class Program
{
    static void Main()
    {
        int min = 0;
        int max = 100;
        int inputValue;
        string prompt = $"Please enter an integer ({min}-{max}): ";
        Console.Write(prompt);
        while (!int.TryParse(Console.ReadLine(), out inputValue) || inputValue < min || max < inputValue)
        {
            Console.WriteLine("Invalid Input. Try Again...");
            Console.Write(prompt);
        }
        Console.WriteLine($"You input the value: {inputValue}");

        Console.WriteLine("Press [enter] to continue...");
        Console.ReadLine();
    }
}

|| Logical OR

< Less Than

There are ways to simplify the code even further by making your own methods, but these examples should have given you all you need to get started writing your own interactive console applications in C#. :)

Examples 1-6 give you all the fundamentals you need to get console input from the user, but if you are struggling to modify the examples to fit your needs, maybe some more examples will help. Here is an example where the user can select a mathematical operation from a set of values inside an array.

Example 7: Another Example... Array Of Possible Inputs

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string[] operators = new[] { "+", "-", "*", "/" };
        string input;
        string prompt = $"Please enter an operator ({string.Join(", ", operators)}): ";
        Console.Write(prompt);
        while (!operators.Contains(input = Console.ReadLine()))
        {
            Console.WriteLine("Invalid Input. Try Again...");
            Console.Write(prompt);
        }
        Operator inputOperator = input switch
        {
            "+" => Operator.Addition,
            "-" => Operator.Subtraction,
            "*" => Operator.Multiplication,
            "/" => Operator.Division,
            _ => throw new NotImplementedException("unexpected operator"),
        };
        Console.WriteLine($"You selected: {inputOperator}");

        Console.WriteLine("Press [enter] To Exit...");
        Console.ReadLine();
    }
}

public enum Operator
{
    Addition,
    Subtraction,
    Multiplication,
    Division,
}

enum

Arrays

Enumerable.Contains(...)

switch (expression)

throw

NotImplementedException

In Example 7 the user may select one of four operators: Addition (+), Subtraction (-), Multiplcation (*), and Division (/). The program will loop until the user selects a valid operator. After a valid operator is selected, the program uses a switch expression to convert the input string into an Operator value. Although it is not necessary to convert the string into an enum, it is a good practice that will result in better code.

You might want to make it easier on the user and let them input multiple values at once. You don't need to, but I would probably recommend making helper methods for this. Lets see an example for handling multiple int inputs at once.

Example 8: Another Example... Multiple Inputs At Once

using System;

class Program
{
    static void Main()
    {
        int[] inputValues;
        string prompt = $"Please enter multiple integers (1, 2, 3): ";
        Console.Write(prompt);
        while (!TryParseIntegerList(Console.ReadLine(), out inputValues))
        {
            Console.WriteLine("Invalid Input. Try Again...");
            Console.Write(prompt);
        }
        Console.WriteLine($"You input the values: {string.Join(", ", inputValues)}");

        Console.WriteLine("Press [enter] to continue...");
        Console.ReadLine();
    }

    public static bool TryParseIntegerList(string input, out int[] inputValues)
    {
        inputValues = default;
        string[] splits = input.Split(",");
        int[] result = new int[splits.Length];
        for (int i = 0; i < splits.Length; i++)
        {
            if (!int.TryParse(splits[i].Trim(), out result[i]))
            {
                return false;
            }
        }
        inputValues = result;
        return true;
    }
}

string.Split(...)

for

string.Trim()

In Example 8 we take in a line of input from the user that should contain multiple int values seperated by commas. If any of the values are not valid int values it is considered invalid and the user must try again. Once we have the input from the user, the first step is to divide the string up into each seperate value, which Example 8 does using the string.Split(...) method. There are other ways to parse strings than using the string.Split(...) method, but that is one of the easiest ones for beginners. Once each input is seperated, we just need to int.TryParse each value to make sure they are all valid, and store them in an array. The string.Trim() method just removes any white space on the front or back of a string so the users can add spaces in their input if they want to. All of the following are acceptable inputs for example:

1,2,3,4,5
1, 2, 3, 4, 5
1,2, 3, 4,5

Example 9: Watching Individual Key Presses With `Console.ReadKey`

using System;

class Program
{
    static void Main()
    {
        ConsoleKey continueKey = ConsoleKey.C;
        Console.Write($"Press [{continueKey}] to continue...");
        while (Console.ReadKey(true).Key != continueKey)
        {
            // do nothing until they press the correct key
        }
        Console.WriteLine();
        Console.WriteLine($"You pressed {continueKey}.");

        Console.WriteLine("Press [enter] to continue...");
        Console.ReadLine();
    }
}

ConsoleKey

Console.ReadKey

ConsoleKeyInfo.Key

!= Inequality

Example 9 shows how you can watch individual key presses from the user rather than taking in a full string of input. You can do this with the Console.ReadKey(...) method. In this case, Example 9 is requesting that the user press the C key before the program will continue. The Console.ReadKey(...) method also allows you to intercept the input so that the input is accepted but will not be written to the console. Whether or not you want to intercept the input is determined by the parameter on the Console.ReadKey(...) method.

Console Games Examples

Are you wanting to learn how to code games? Even if you aren't interested in game development, making console games is a great way to learn how to program in C#. I have a GitHub repo with examples of console games if you want to give it a look. Many of the games use simple console input techniques like the examples in this gist:
https://github.com/ZacharyPatten/dotnet-console-games

Good Luck!

If you are still relatively new to C# I recommend you stop here. I do not recommend beginners attempt to simplify console input further than the examples in this gist. However, if you want to see some more advanced examples of console input you can expand the following:

Extra: Generic Console Input Helper Method

This is an example of a console input helper method in C# that can make console input one line of code. It is dependent on the Towel nuget package, so you must add the nuget package as a dependency to build and run it. It uses Generics and optional parameters.

using System;
using Towel;
using static Towel.Syntax;

class Program
{
    static void Main()
    {
        // int
        var a = ConsoleHelper.GetInput<int>();
        Console.WriteLine($"You input the value: {a}");
        // double
        var b = ConsoleHelper.GetInput<double>();
        Console.WriteLine($"You input the value: {b}");
        // string
        var c = ConsoleHelper.GetInput<string>();
        Console.WriteLine($"You input the value: {c}");
        // int + overriding the writes
        var d = ConsoleHelper.GetInput<int>(
            prompt: "Insert your favorite integer: ",
            invalidMessage: "Don't be a moron...");
        Console.WriteLine($"You input the value: {d}");
        // custom enum value + overriding the writes
        var e = ConsoleHelper.GetInput<Direction>(
            prompt: "Insert Left or Right: ");
        Console.WriteLine($"You input the value: {e}");
        Console.WriteLine("Press [enter] to exit...");
        Console.ReadLine();
    }
}
public enum Direction
{
    Left,
    Right
}
public static class ConsoleHelper
{
    public static T GetInput<T>(string prompt = null, string invalidMessage = null)
    {
        if (typeof(T) != typeof(string) && !typeof(T).IsEnum && Meta.GetTryParseMethod<T>() == null)
        {
            throw new InvalidOperationException($"Using {nameof(ConsoleHelper)}.{nameof(GetInput)} with a non-supported type.");
        }
    GetInput:
        Console.Write(prompt ?? $"Input a {typeof(T).Name} value: ");
        if (typeof(T) == typeof(string))
        {
            return (T)(object)Console.ReadLine();
        }
        else if (!TryParse(Console.ReadLine(), out T value))
        {
            Console.WriteLine(invalidMessage ?? $"Invalid input. Try again...");
            goto GetInput;
        }
        else
        {
            return value;
        }
    }
}

C# Multi String Replace Extension Method

Zachary Patten — Thu, 30 Jul 2020 02:10:19 +0000

Hey guys. I wrote an extension method in C# that allows you to do multiple string replacements in one method call. This can be a better pattern than iterative replacements that will let future replacements run on the result of previous replacements.

This code is included in the Towel nuget package. Please check it out if you want to see more code like it. Thanks. :)

using System;
using System.Linq;
using Towel;

public class Program
{
    public static void Main()
    {
        /// basic example
        /// -------------

        string input1 = "a b c d e";
        string testresult = input1.Replace(("a", "aaa"), ("b", "bbb"), ("d", "ddd"));
        Console.WriteLine(testresult);

        /// caching example
        /// ---------------

        /// If you need to perform the same replacements on multiple strings, you
        /// can use ReplaceCached for a performance boost. However, once cached,
        /// any updates to the rules instance will not propogate until the relative
        /// cache is purged and rebuilt.

        string input2 = input1.Reverse();
        string input3 = "abcd";

        var rules = new (string From, string To)[]
        {
            (From: "a", To: "aaa"),
            (From: "b", To: "bbb"),
            (From: "d", To: "ddd"),
        };

        Console.WriteLine(input1.ReplaceCached(rules)); /// <- not cached (slower)
        Console.WriteLine(input2.ReplaceCached(rules)); /// <- cached (faster)
        Extensions.ClearReplaceCache();
        Console.WriteLine(input3.ReplaceCached(rules)); /// <- not cached (slower)
        Extensions.RemoveFromReplaceCache(rules);

        /// runtime exceptions
        /// ------------------

        /// Uncomment the following lines for the exception examples to avoid.

        /// ArgumentNullException's
        //_ = Extensions.Replace(null, ("a", "b"));
        //_ = input1.Replace(null);
        //_ = input1.Replace((null, "a"));
        //_ = input1.Replace(("a", null));

        /// ArgumentException's
        //_ = input1.Replace();
        //_ = input1.Replace(("a", "b"), ("a", "c"));
        //_ = input1.Replace((string.Empty, "hello world"));

        Console.WriteLine("Press [enter] to contiue...");
        Console.ReadLine();
    }
}

#region Framework Code

namespace Towel
{
    using System;
    using System.Collections.Generic;
    using System.Text.RegularExpressions;

    public static class Extensions
    {
        /// <summary>Returns a new <see cref="string"/> in which all occurrences of Unicode <see cref="string"/> patterns in this instance are replaced with a relative Unicode <see cref="string"/> replacements.</summary>
        /// <remarks>Uses Regex without a timeout.</remarks>
        /// <param name="this">The <see cref="string"/> to perform the replacements on.</param>
        /// <param name="rules">The patterns and relative replacements to apply to this <see cref="string"/>.</param>
        /// <returns>A new <see cref="string"/> in which all occurrences of Unicode <see cref="string"/> patterns in this instance are replaced with a relative Unicode <see cref="string"/> replacements.</returns>
        /// <exception cref="ArgumentNullException">Thrown if any of the parameters are null or contain null values.</exception>
        /// <exception cref="ArgumentException">Thrown if <paramref name="rules"/> is empty, <paramref name="rules"/> contains empty patterns, or <paramref name="rules"/> contains duplicate patterns.</exception>
        public static string Replace(this string @this, params (string Pattern, string Replacement)[] rules) => ReplaceBase(@this, rules, false);

        /// <summary>Returns a new <see cref="string"/> in which all occurrences of Unicode <see cref="string"/> patterns in this instance are replaced with a relative Unicode <see cref="string"/> replacements. Caches internal values relative to the instance of rules.</summary>
        /// <remarks>Uses Regex without a timeout. This method is not thread-safe.</remarks>
        /// <param name="this">The <see cref="string"/> to perform the replacements on.</param>
        /// <param name="rules">The patterns and relative replacements to apply to this <see cref="string"/>.</param>
        /// <returns>A new <see cref="string"/> in which all occurrences of Unicode <see cref="string"/> patterns in this instance are replaced with a relative Unicode <see cref="string"/> replacements.</returns>
        /// <exception cref="ArgumentNullException">Thrown if any of the parameters are null or contain null values.</exception>
        /// <exception cref="ArgumentException">Thrown if <paramref name="rules"/> is empty, <paramref name="rules"/> contains empty patterns, or <paramref name="rules"/> contains duplicate patterns.</exception>
        public static string ReplaceCached(this string @this, params (string Pattern, string Replacement)[] rules) => ReplaceBase(@this, rules, true);

        /// <summary>Cache for the <see cref="ReplaceCached"/> method.</summary>
        private readonly static Dictionary<object, (Regex Regex, Dictionary<string, string> RuleSet)> ReplaceCachedCache =
            new Dictionary<object, (Regex Regex, Dictionary<string, string> RuleSet)>();

        private static string ReplaceBase(string @this, (string Pattern, string Replacement)[] rules, bool cached)
        {
            if (@this is null) throw new ArgumentNullException(nameof(@this));
            if (rules is null) throw new ArgumentNullException(nameof(rules));
            if (rules.Length <= 0) throw new ArgumentException($"{nameof(rules)}.{nameof(rules.Length)} <= 0");
            if (!cached || !ReplaceCachedCache.TryGetValue(rules, out (Regex Regex, Dictionary<string, string> RuleSet) regexAndRuleSet))
            {
                regexAndRuleSet.RuleSet = new Dictionary<string, string>(rules.Length);
                foreach (var rule in rules)
                {
                    if (rule.Pattern is null) throw new ArgumentNullException(nameof(rules), $"{nameof(rules)} contains null {nameof(rule.Pattern)}s");
                    if (rule.Replacement is null) throw new ArgumentNullException(nameof(rules), $"{nameof(rules)} contains null {nameof(rule.Replacement)}s");
                    if (rule.Pattern == string.Empty) throw new ArgumentException(nameof(rules), $"{nameof(rules)} contains empty {nameof(rule.Pattern)}s");
                    if (!regexAndRuleSet.RuleSet.TryAdd(rule.Pattern, rule.Replacement)) throw new ArgumentException($"{nameof(rules)} contains duplicate {nameof(rule.Pattern)}s");
                }
                string regexPattern = string.Join("|", rules.Select(rule => Regex.Escape(rule.Pattern)));
                RegexOptions regexOptions = cached ? RegexOptions.Compiled : RegexOptions.None;

                // NOTE:
                // Regex has a matchTimeout parameter that prevents security threats of long-running
                // regex patterns. However, an overload with a TimeSpan parameter likely is not required as
                // this impementation is not allowing special syntax in the regex. It is only flat strings
                // that are OR-ed together.

                regexAndRuleSet.Regex = new Regex(regexPattern, regexOptions);
                if (cached)
                {
                    ReplaceCachedCache.Add(rules, regexAndRuleSet);
                }
            }
            return regexAndRuleSet.Regex.Replace(@this, match => regexAndRuleSet.RuleSet[match.Value]);
        }

        /// <summary>Clears the cache for the <see cref="ReplaceCached"/> method.</summary>
        public static void ClearReplaceCache() => ReplaceCachedCache.Clear();

        /// <summary>Removes a rule set from the <see cref="ReplaceCached"/> method cache if it exists.</summary>
        /// <param name="rules">The rule set to remove from the cache.</param>
        public static void RemoveFromReplaceCache((string Pattern, string Replacement)[] rules)
        {
            if (ReplaceCachedCache.ContainsKey(rules))
            {
                ReplaceCachedCache.Remove(rules);
            }
        }
    }
}

#endregion

The ReplaceCached method is comparable in speed to StringBuilder.Replace however there is one key difference. This method does not chain the rules. If one rule results in the pattern of another rule, it will not apply a second rule onto a replace that has already occured.

string result = "a b c d e".Replace(("a", "aaa"), ("b", "bbb"), ("aaa", "ERROR"))
// result = "aaa bbb c d e"

But if you do the comparable replace using StringBuilder.Replace...

StringBuilder stringBuilder = new stringBuilder("a b c d e");
stringBuilder.Replace("a", "aaa");
stringBuilder.Replace("b", "bbb");
stringBuilder.Replace("aaa", "ERROR");
result = stringBuilder.ToString();
// result = "ERROR bbb c d e"

Here are some benchmarks to get a rough idea, but there need to be more/better benchmarks to really compare them...

using System.Text;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using Towel;

namespace MyBenchmarks
{
    public class ReplaceBenchmarks
    {
        const string input = "a b c d e f g h i j k l m n o p q r s t u v w x y z";

        [Benchmark]
        public string Towel()
        {
            return input.Replace(("a", "aaa"), ("b", "bbb"), ("d", "ddd"), ("p", "ppp"), ("z", "zzz"));
        }

        (string, string)[] rules = new[]
        {
            ("a", "aaa"),
            ("b", "bbb"),
            ("d", "ddd"),
            ("p", "ppp"),
            ("z", "zzz")
        };

        [Benchmark]
        public string TowelCached()
        {
            return input.ReplaceCached(rules);
        }

        [Benchmark]
        public string StringBuilder()
        {
            StringBuilder builder = new StringBuilder(input);
            builder.Replace("a", "aaa");
            builder.Replace("b", "bbb");
            builder.Replace("d", "ddd");
            builder.Replace("p", "ppp");
            builder.Replace("z", "zzz");
            return builder.ToString();
        }
    }

    public class Program
    {
        public static void Main()
        {
            var summary = BenchmarkRunner.Run<ReplaceBenchmarks>();
        }
    }
}

Benchmark results...


BenchmarkDotNet=v0.12.0, OS=Windows 10.0.18363
Intel Core i7-4790K CPU 4.00GHz (Haswell), 1 CPU, 8 logical and 4 physical cores
.NET Core SDK=5.0.100-preview.6.20318.15
  [Host]     : .NET Core 3.1.6 (CoreCLR 4.700.20.26901, CoreFX 4.700.20.31603), X64 RyuJIT
  DefaultJob : .NET Core 3.1.6 (CoreCLR 4.700.20.26901, CoreFX 4.700.20.31603), X64 RyuJIT

Method	Mean	Error	StdDev
Towel	4.992 us	0.1060 us	0.0885 us
TowelCached	1.533 us	0.0047 us	0.0040 us
StringBuilder	1.459 us	0.0053 us	0.0049 us

Learn C# Through Console Games

Zachary Patten — Wed, 29 Jan 2020 04:53:25 +0000

Learning to program for the first time (or just picking up a new language) can be frustrating. Many languages have documentation that covers the basic features of the language, and that documentation is usually the best place to start, but once you complete that... What do you do now?

This is one of the most common questions I see beginner developers asking (especially self-taught developers). They learn the basics but they don't know how/where to start on their first actual project. There are tons of ideas that make great starter projects, such as a console math calculator, movie library manager, or file I/O operations (perhaps with csv files).

However, the most important thing about your first project is to choose something that you will actually enjoy and be motivated to complete. If you don't complete your first project in a new programming language, it will likely lead you to resent the language.

Most programmers enjoy video games so why not make a game? Making small games (especially for the console/terminal) is a great way to get started, and it will definitely help you learn a programming language.

My programming language of choice is C#, and in attempts to help more programmers learn how to code C#, I started a GitHub project with game examples implemented as .NET Core (C#) console applications:

GitHub: https://github.com/ZacharyPatten/dotnet-console-games

As of writing this article, I have already implemented 8 games in the GitHub project, and each of them is only a few hundred lines of code. Making a game might be easier than you think.

So if you want to learn C# (or know someone else who does) and making a game sounds fun, I encourage you to give it a shot. Play the games in the GitHub project and pick one you want to try to make. Try to code the game yourself from scratch, but if you ever get stuck, you have a working example to refer to. Then if/when you complete your own version of the game, compare it to the provided example. Your implementation might be better than my version. :)

Good Luck!

Generating Unique Random Data: A Practical Example Of Algorithm Analysis

Zachary Patten — Wed, 01 Jan 2020 22:23:58 +0000

I ran across a practical example of algorithm analysis when I wrote a method that generates unique random values inside a provided range. Figured I would share it...

The code in this article was included in my https://github.com/ZacharyPatten/Towel project. Please check it out if you want to see more code like it. :)

Note: all code examples are in C#.

Introduction

When you want to generate unique random numbers, there are two approaches you can take: 1) you can track the remaining possible values of generation or 2) you can track the values that have already been randomly selected. For variables/parameters, let count be the number of values to generate, minValue be the inclusive lower bound of generation, and maxValue be the exclusive upper bound of generation.

Algorithm #1/A

After a bit of googling, option #1 seems to be more common. You often see people throw all the possible values into an array/list and remove a randomly generated index. Here is an implementation of that algorithm:

public static IEnumerable<int> NextUniqueA(this Random random, int count, int minValue, int maxValue)
{
    // Algorithm A: Θ(range + count)
    int pool = maxValue - minValue;
    int[] array = new int[pool];
    for (int i = 0, j = minValue; j < maxValue; i++, j++) // Θ(range)
        array[i] = j;
    for (int i = 0; i < count; i++) // Θ(count)
    {
        int rollIndex = random.Next(0, pool);
        int roll = array[rollIndex];
        array[rollIndex] = array[--pool];
        yield return roll;
    }
}

Algorithm #2/B

Now, here is what option #2 can look like. For this implementation, I use a linked list to store all the values that have already been generated in sorted order:

public static IEnumerable<int> NextUniqueB(this Random random, int count, int minValue, int maxValue)
{
    // Algorithm B: O(.5*count^2), Ω(count), ε(.5*count^2)
    Node head = null;
    for (int i = 0; i < count; i++) // Θ(count)
    {
        int roll = random.Next(minValue, maxValue - i);
        Node node = head;
        Node previous = null;
        while (!(node is null)) // O(count / 2), Ω(0), ε(count / 2)
        {
            if (node.Value > roll)
                break;
            roll++;
            previous = node;
            node = node.Next;
        }
        yield return roll;
        if (previous is null)
            head = new Node() { Value = roll, Next = head, };
        else
            previous.Next = new Node() { Value = roll, Next = previous.Next };
    }
}

internal class Node
{
    internal int Value;
    internal Node Next;
}

Analyzing Algorithm Complexities

These two implementations have different runtime algorithm complexities. The #1/A option has a runtime complexity of Θ(range + count) while the #2/B option has a runtime complexity of O(.5*count^2), Ω(count), ε(.5*count^2) where O is the worst case, Θ is every case, Ω is the best case, and ε is the expected average between the worst and the best cases. Long story short, when the count is relatively low you want to use algorithm #2/B. When the count is relatively high you want to use algorithm #1/A. So if you want to make a faster all-around general purpose method, you need to combine the two approaches. But how do you do that? You need to find the intersection of the two runtime complexities of each method.

If you treat both algorithm complexities as linear functions and do some simple math to find the intesection, you will find that they intersect at about √(maxValue - minValue) the square root of the range of random generation relative to count. Now that you know the intersection point, you can combine the two algorithms into a single function that is optimized for more use cases:

Combination of #1/A and #2/B

public static IEnumerable<int> NextUnique(this Random random, int count, int minValue, int maxValue)
{
    if (count > Math.Sqrt(maxValue - minValue))
    {
        // Algorithm A
    }
    else
    {
        // Algorithm B
    }
}

Benchmarks

Here are some benchmarks so you can compare theory with practical results. Note that for these benchmarks I used a random generation range of 0..10000. So minValue = 0 and maxValue = 10000. From the theory, I knew that the intersection of the runtime algorithms is roughly √(maxValue - minValue) = √(100000 - 0) = √(100000) = 100. So when count is less than ~100 the #2/B algorithm should be faster, but when count is greater than ~100 algorithm #1/A should be faster.

Benchmarks Source Code

Note: This code uses the BenchmarkDotNet nuget package. It also uses the Plots exporter to generate the graphs, which requires R be installed.

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System;
using System.Linq;
using System.Collections.Generic;
using BenchmarkDotNet.Exporters;
using BenchmarkDotNet.Configs;

namespace UniqueRandomGeneration
{
    class Program
    {
        static void Main(string[] args) => BenchmarkRunner.Run<Benchmarks>();
    }

    [RPlotExporter]
    [Config(typeof(Config))]
    public class Benchmarks
    {
        public class Config : ManualConfig
        {
            public Config() => Add(RPlotExporter.Default);
        }

        const int MinValue = 0;
        const int MaxValue = 10000;

        [Params(25, 50, 75, 100, 125, 150, 175, 200, 225, 250)]
        public int Count;

        readonly Random random = new Random();

        [Benchmark] public void RandomUniqueA() => random.NextUniqueA(Count, MinValue, MaxValue).ToArray();

        [Benchmark] public void RandomUniqueB() => random.NextUniqueB(Count, MinValue, MaxValue).ToArray();

        [Benchmark] public void RandomUnique() => random.NextUnique(Count, MinValue, MaxValue).ToArray();
    }

    public static class Extensions
    {
        internal class Node
        {
            internal int Value;
            internal Node Next;
        }

        public static IEnumerable<int> NextUnique(this Random random, int count, int minValue, int maxValue)
        {
            if (maxValue < minValue)
                throw new ArgumentOutOfRangeException(nameof(minValue) + " > " + nameof(minValue));
            if (count < 0)
                throw new ArgumentOutOfRangeException(nameof(count) + " < 0");
            if (maxValue - minValue < count)
                throw new ArgumentOutOfRangeException(nameof(count) + " is larger than " + nameof(maxValue) + " - " + nameof(minValue) + ".");
            if (count > Math.Sqrt(maxValue - minValue))
            {
                // Algorithm A: Θ(range + count)
                int pool = maxValue - minValue;
                int[] array = new int[pool];
                for (int i = 0, j = minValue; j < maxValue; i++, j++) // Θ(range)
                    array[i] = j;
                for (int i = 0; i < count; i++) // Θ(count)
                {
                    int rollIndex = random.Next(0, pool);
                    int roll = array[rollIndex];
                    array[rollIndex] = array[--pool];
                    yield return roll;
                }
            }
            else
            {
                // Algorithm B: O(.5*count^2), Ω(count), ε(.5*count^2)
                Node head = null;
                for (int i = 0; i < count; i++) // Θ(count)
                {
                    int roll = random.Next(minValue, maxValue - i);
                    Node node = head;
                    Node previous = null;
                    while (!(node is null)) // O(count / 2), Ω(0), ε(count / 2)
                    {
                        if (node.Value > roll)
                            break;
                        roll++;
                        previous = node;
                        node = node.Next;
                    }
                    yield return roll;
                    if (previous is null)
                        head = new Node() { Value = roll, Next = head, };
                    else
                        previous.Next = new Node() { Value = roll, Next = previous.Next };
                }
            }
        }

        public static IEnumerable<int> NextUniqueA(this Random random, int count, int minValue, int maxValue)
        {
            if (maxValue < minValue)
                throw new ArgumentOutOfRangeException(nameof(minValue) + " > " + nameof(minValue));
            if (count < 0)
                throw new ArgumentOutOfRangeException(nameof(count) + " < 0");
            if (maxValue - minValue < count)
                throw new ArgumentOutOfRangeException(nameof(count) + " is larger than " + nameof(maxValue) + " - " + nameof(minValue) + ".");
            // Algorithm A: Θ(range + count)
            int pool = maxValue - minValue;
            int[] array = new int[pool];
            for (int i = 0, j = minValue; j < maxValue; i++, j++) // Θ(range)
                array[i] = j;
            for (int i = 0; i < count; i++) // Θ(count)
            {
                int rollIndex = random.Next(0, pool);
                int roll = array[rollIndex];
                array[rollIndex] = array[--pool];
                yield return roll;
            }
        }

        public static IEnumerable<int> NextUniqueB(this Random random, int count, int minValue, int maxValue)
        {
            if (maxValue < minValue)
                throw new ArgumentOutOfRangeException(nameof(minValue) + " > " + nameof(minValue));
            if (count < 0)
                throw new ArgumentOutOfRangeException(nameof(count) + " < 0");
            if (maxValue - minValue < count)
                throw new ArgumentOutOfRangeException(nameof(count) + " is larger than " + nameof(maxValue) + " - " + nameof(minValue) + ".");
            // Algorithm B: O(.5*count^2), Ω(count), ε(.5*count^2)
            Node head = null;
            for (int i = 0; i < count; i++) // Θ(count)
            {
                int roll = random.Next(minValue, maxValue - i);
                Node node = head;
                Node previous = null;
                while (!(node is null)) // O(count / 2), Ω(0), ε(count / 2)
                {
                    if (node.Value > roll)
                        break;
                    roll++;
                    previous = node;
                    node = node.Next;
                }
                yield return roll;
                if (previous is null)
                    head = new Node() { Value = roll, Next = head, };
                else
                    previous.Next = new Node() { Value = roll, Next = previous.Next };
            }
        }
    }
}

Benchmarks Results Table


BenchmarkDotNet=v0.12.0, OS=Windows 10.0.18363
Intel Core i7-4790K CPU 4.00GHz (Haswell), 1 CPU, 8 logical and 4 physical cores
.NET Core SDK=3.1.100
  [Host]     : .NET Core 3.1.0 (CoreCLR 4.700.19.56402, CoreFX 4.700.19.56404), X64 RyuJIT
  DefaultJob : .NET Core 3.1.0 (CoreCLR 4.700.19.56402, CoreFX 4.700.19.56404), X64 RyuJIT

Method	Count	Mean	Error	StdDev
RandomUniqueA	25	7.406 us	0.1576 us	0.1876 us
RandomUniqueB	25	1.307 us	0.0256 us	0.0414 us
RandomUnique	25	1.300 us	0.0046 us	0.0043 us
RandomUniqueA	50	7.761 us	0.0263 us	0.0246 us
RandomUniqueB	50	2.893 us	0.0084 us	0.0079 us
RandomUnique	50	3.022 us	0.0755 us	0.0707 us
RandomUniqueA	75	8.387 us	0.1317 us	0.1232 us
RandomUniqueB	75	5.180 us	0.1070 us	0.1001 us
RandomUnique	75	5.298 us	0.0634 us	0.0593 us
RandomUniqueA	100	9.151 us	0.1800 us	0.2340 us
RandomUniqueB	100	8.013 us	0.0994 us	0.0930 us
RandomUnique	100	8.246 us	0.1205 us	0.1127 us
RandomUniqueA	125	9.335 us	0.1533 us	0.1434 us
RandomUniqueB	125	11.291 us	0.1093 us	0.1023 us
RandomUnique	125	9.394 us	0.1773 us	0.1658 us
RandomUniqueA	150	9.509 us	0.0323 us	0.0302 us
RandomUniqueB	150	14.486 us	0.0653 us	0.0610 us
RandomUnique	150	9.355 us	0.0428 us	0.0400 us
RandomUniqueA	175	9.972 us	0.0319 us	0.0298 us
RandomUniqueB	175	18.778 us	0.0792 us	0.0741 us
RandomUnique	175	9.789 us	0.0593 us	0.0554 us
RandomUniqueA	200	10.270 us	0.0297 us	0.0278 us
RandomUniqueB	200	23.384 us	0.0623 us	0.0520 us
RandomUnique	200	10.112 us	0.0499 us	0.0466 us
RandomUniqueA	225	10.724 us	0.1754 us	0.1465 us
RandomUniqueB	225	28.748 us	0.0872 us	0.0816 us
RandomUnique	225	10.612 us	0.0430 us	0.0381 us
RandomUniqueA	250	11.144 us	0.0518 us	0.0484 us
RandomUniqueB	250	34.320 us	0.1249 us	0.1107 us
RandomUnique	250	10.891 us	0.0826 us	0.0772 us

Benchmarks Results Bar Graph

Probability/Validity Testing

Here is some validity testing to hopefully make sure I am not full of shit. In this code, I generate 5 values in the 0..26 range. I do this 1000000 times, and I calculate the mean that each values was randomly selected. All the values should be selected an average of 5 / 26 = ‭0.1923...‬ times.

Validity Testing Source Code

using System;
using System.Linq;
using System.Collections.Generic;

namespace ValidityTesting
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine(nameof(Extensions.NextUnique));
            PrintPriorities(CalculateProbabilities(Extensions.NextUnique));
            Console.WriteLine();

            Console.WriteLine(nameof(Extensions.NextUniqueA));
            PrintPriorities(CalculateProbabilities(Extensions.NextUniqueA));
            Console.WriteLine();

            Console.WriteLine(nameof(Extensions.NextUniqueB));
            PrintPriorities(CalculateProbabilities(Extensions.NextUniqueB));
            Console.WriteLine();
        }

        internal static void PrintPriorities(Dictionary<int, double> results)
        {
            foreach (var keyVal in results.OrderBy(x => x.Key))
                Console.WriteLine(keyVal.Key + ": " + keyVal.Value);
        }

        internal static Dictionary<int, double> CalculateProbabilities(Func<Random, int, int, int, IEnumerable<int>> algorithm)
        {
            Random random = new Random();
            const int size = 5;
            const int min = 0;
            const int max = 26;
            const int iterations = 1000000;
            var counts = new Dictionary<int, int>();
            for (int i = min; i < max; i++)
                counts.Add(i, 0);
            for (int i = 0; i < iterations; i++)
                foreach (int j in algorithm(random, size, min, max))
                    counts[j]++;
            var results = new Dictionary<int, double>();
            foreach (var keyVal in counts)
                results.Add(keyVal.Key, keyVal.Value / (double)iterations);
            return results;
        }
    }

    public static class Extensions
    {
        internal class Node
        {
            internal int Value;
            internal Node Next;
        }

        public static IEnumerable<int> NextUnique(this Random random, int count, int minValue, int maxValue)
        {
            if (maxValue < minValue)
                throw new ArgumentOutOfRangeException(nameof(minValue) + " > " + nameof(minValue));
            if (count < 0)
                throw new ArgumentOutOfRangeException(nameof(count) + " < 0");
            if (maxValue - minValue < count)
                throw new ArgumentOutOfRangeException(nameof(count) + " is larger than " + nameof(maxValue) + " - " + nameof(minValue) + ".");
            if (count > Math.Sqrt(maxValue - minValue))
            {
                // Algorithm A: Θ(range + count)
                int pool = maxValue - minValue;
                int[] array = new int[pool];
                for (int i = 0, j = minValue; j < maxValue; i++, j++) // Θ(range)
                    array[i] = j;
                for (int i = 0; i < count; i++) // Θ(count)
                {
                    int rollIndex = random.Next(0, pool);
                    int roll = array[rollIndex];
                    array[rollIndex] = array[--pool];
                    yield return roll;
                }
            }
            else
            {
                // Algorithm B: O(.5*count^2), Ω(count), ε(.5*count^2)
                Node head = null;
                for (int i = 0; i < count; i++) // Θ(count)
                {
                    int roll = random.Next(minValue, maxValue - i);
                    Node node = head;
                    Node previous = null;
                    while (!(node is null)) // O(count / 2), Ω(0), ε(count / 2)
                    {
                        if (node.Value > roll)
                            break;
                        roll++;
                        previous = node;
                        node = node.Next;
                    }
                    yield return roll;
                    if (previous is null)
                        head = new Node() { Value = roll, Next = head, };
                    else
                        previous.Next = new Node() { Value = roll, Next = previous.Next };
                }
            }
        }

        public static IEnumerable<int> NextUniqueA(this Random random, int count, int minValue, int maxValue)
        {
            if (maxValue < minValue)
                throw new ArgumentOutOfRangeException(nameof(minValue) + " > " + nameof(minValue));
            if (count < 0)
                throw new ArgumentOutOfRangeException(nameof(count) + " < 0");
            if (maxValue - minValue < count)
                throw new ArgumentOutOfRangeException(nameof(count) + " is larger than " + nameof(maxValue) + " - " + nameof(minValue) + ".");
            // Algorithm A: Θ(range + count)
            int pool = maxValue - minValue;
            int[] array = new int[pool];
            for (int i = 0, j = minValue; j < maxValue; i++, j++) // Θ(range)
                array[i] = j;
            for (int i = 0; i < count; i++) // Θ(count)
            {
                int rollIndex = random.Next(0, pool);
                int roll = array[rollIndex];
                array[rollIndex] = array[--pool];
                yield return roll;
            }
        }

        public static IEnumerable<int> NextUniqueB(this Random random, int count, int minValue, int maxValue)
        {
            if (maxValue < minValue)
                throw new ArgumentOutOfRangeException(nameof(minValue) + " > " + nameof(minValue));
            if (count < 0)
                throw new ArgumentOutOfRangeException(nameof(count) + " < 0");
            if (maxValue - minValue < count)
                throw new ArgumentOutOfRangeException(nameof(count) + " is larger than " + nameof(maxValue) + " - " + nameof(minValue) + ".");
            // Algorithm B: O(.5*count^2), Ω(count), ε(.5*count^2)
            Node head = null;
            for (int i = 0; i < count; i++) // Θ(count)
            {
                int roll = random.Next(minValue, maxValue - i);
                Node node = head;
                Node previous = null;
                while (!(node is null)) // O(count / 2), Ω(0), ε(count / 2)
                {
                    if (node.Value > roll)
                        break;
                    roll++;
                    previous = node;
                    node = node.Next;
                }
                yield return roll;
                if (previous is null)
                    head = new Node() { Value = roll, Next = head, };
                else
                    previous.Next = new Node() { Value = roll, Next = previous.Next };
            }
        }
    }
}

Validity Testing Console Output

NextUnique
0: 0.192031
1: 0.19208
2: 0.192785
3: 0.192287
4: 0.192593
5: 0.192686
6: 0.191937
7: 0.191998
8: 0.19244
9: 0.192112
10: 0.19212
11: 0.192707
12: 0.192877
13: 0.192086
14: 0.192277
15: 0.191907
16: 0.192366
17: 0.192386
18: 0.192423
19: 0.19229
20: 0.192017
21: 0.191901
22: 0.19285
23: 0.19282
24: 0.191902
25: 0.192122

NextUniqueA
0: 0.192705
1: 0.191956
2: 0.192313
3: 0.192613
4: 0.193418
5: 0.191957
6: 0.192116
7: 0.192217
8: 0.192773
9: 0.191862
10: 0.19233
11: 0.192145
12: 0.192044
13: 0.192749
14: 0.192097
15: 0.19224
16: 0.192526
17: 0.19225
18: 0.191653
19: 0.192546
20: 0.192156
21: 0.191686
22: 0.192908
23: 0.19174
24: 0.192605
25: 0.192395

NextUniqueB
0: 0.192408
1: 0.191776
2: 0.191809
3: 0.192623
4: 0.192399
5: 0.192451
6: 0.192135
7: 0.1931
8: 0.192594
9: 0.19232
10: 0.192281
11: 0.191723
12: 0.192358
13: 0.19216
14: 0.192697
15: 0.192975
16: 0.192357
17: 0.192507
18: 0.191768
19: 0.191874
20: 0.192803
21: 0.191934
22: 0.192075
23: 0.192704
24: 0.192155
25: 0.192014

Sorting Algorithm Benchmarks C# .NET Core 3

Zachary Patten — Sat, 09 Nov 2019 20:50:05 +0000

I benchmarked (using benchmarkdotnet) some of the common sorting algorithms in C# .NET Core 3.0. If you use generic arguments + structs to pass in the comparison function, you can achieve faster custom sorting than than the provided Array.Sort<T>(T[], Comparison<T>) or Array.Sort<T>(T[], IComparer<T>) methods in the .NET libraries. I didn't even replicate the sorting algorithm, but the base Quick and Merge sort algorithms were already faster than the aforementioned .NET methods for at least N ~ 10000 when you use structs (I only benchmarked up to 10000 so far). The source code is available if you want to run the benchmark yourself.

The XXXRunTime benchmarks use runtime delegates for their compare functions.
The XXXCompileTime benchmarks use structs for their compare functions (so there is no delegate at runtime).
The SystemArraySort benchmark is the System.Array.Sort method. Note: the System.Array.Sort method does not allow custom sorting while all other benchmarked methods do.
The SystemArraySortDelegate benchmark is the System.Array.Sort<T>(T[], System.Comparison<T>) method, where System.Comparison<T> is a runtime delegate.
The SystemArraySortIComparer benchmark is the System.Array.Sort<T>(T[], System.Collections.Generic.IComparer<T>) method.

Source Code: https://github.com/ZacharyPatten/Towel/blob/master/Tools/Towel_Benchmarking/Sort.cs


BenchmarkDotNet=v0.11.5, OS=Windows 10.0.18362
Intel Core i7-4790K CPU 4.00GHz (Haswell), 1 CPU, 8 logical and 4 physical cores
.NET Core SDK=3.0.100
  [Host]     : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT
  Job-BDOEBU : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT

InvocationCount=1  UnrollFactor=1

Method	N	Mean	Error	StdDev	Median
SystemArraySort	10	442.0 ns	18.15 ns	53.52 ns	400.0 ns
SystemArraySortDelegate	10	582.2 ns	15.47 ns	38.52 ns	600.0 ns
SystemArraySortIComparer	10	2,822.5 ns	60.41 ns	107.39 ns	2,800.0 ns
BubbleRunTime	10	2,261.9 ns	55.29 ns	101.10 ns	2,250.0 ns
BubbleCompileTime	10	382.0 ns	18.90 ns	55.74 ns	400.0 ns
SelectionRunTime	10	1,552.8 ns	34.65 ns	72.33 ns	1,600.0 ns
SelectionCompileTime	10	360.0 ns	17.38 ns	51.25 ns	400.0 ns
InsertionRunTime	10	1,320.8 ns	30.24 ns	63.12 ns	1,300.0 ns
InsertionCompileTime	10	252.5 ns	18.45 ns	54.10 ns	300.0 ns
QuickRunTime	10	1,822.6 ns	40.08 ns	91.29 ns	1,800.0 ns
QuickCompileTime	10	464.0 ns	20.18 ns	59.49 ns	500.0 ns
MergeRunTime	10	1,622.7 ns	36.06 ns	67.73 ns	1,600.0 ns
MergeCompileTime	10	1,198.7 ns	27.21 ns	69.76 ns	1,200.0 ns
HeapRunTime	10	2,315.7 ns	50.28 ns	102.71 ns	2,300.0 ns
HeapCompileTime	10	1,401.6 ns	31.74 ns	72.94 ns	1,400.0 ns
OddEvenRunTime	10	1,568.3 ns	34.99 ns	92.80 ns	1,600.0 ns
OddEvenCompileTime	10	396.5 ns	17.77 ns	52.12 ns	350.0 ns
GnomeRunTime	10	1,626.8 ns	36.43 ns	89.38 ns	1,600.0 ns
GnomeCompileTime	10	339.4 ns	20.56 ns	60.30 ns	300.0 ns
CombRunTime	10	1,534.2 ns	34.54 ns	75.09 ns	1,550.0 ns
CombCompileTime	10	323.8 ns	36.66 ns	43.64 ns	300.0 ns
ShellRunTime	10	1,498.6 ns	31.74 ns	79.04 ns	1,500.0 ns
ShellCompileTime	10	872.2 ns	21.43 ns	45.21 ns	900.0 ns
CocktailRunTime	10	1,684.5 ns	37.67 ns	101.19 ns	1,700.0 ns
CocktailCompileTime	10	337.0 ns	16.46 ns	48.52 ns	300.0 ns
SlowRunTime	10	3,860.7 ns	79.02 ns	113.33 ns	3,900.0 ns
SlowCompileTime	10	2,714.3 ns	56.42 ns	103.17 ns	2,750.0 ns
BogoRunTime	10	391,003,513.5 ns	121,304,281.36 ns	349,990,587.44 ns	248,319,950.0 ns
BogoCompileTime	10	468,765,539.4 ns	144,668,002.39 ns	424,286,208.04 ns	331,454,600.0 ns
SystemArraySort	1000	29,500.0 ns	328.14 ns	290.89 ns	29,600.0 ns
SystemArraySortDelegate	1000	66,483.3 ns	1,217.36 ns	950.44 ns	66,700.0 ns
SystemArraySortIComparer	1000	81,417.3 ns	1,979.98 ns	5,775.69 ns	83,350.0 ns
BubbleRunTime	1000	5,873,307.8 ns	116,589.84 ns	270,214.68 ns	5,815,000.0 ns
BubbleCompileTime	1000	1,733,672.4 ns	42,492.04 ns	123,951.28 ns	1,699,600.0 ns
SelectionRunTime	1000	3,754,555.0 ns	423,852.01 ns	1,249,737.23 ns	2,915,000.0 ns
SelectionCompileTime	1000	889,730.2 ns	17,768.71 ns	40,826.56 ns	881,100.0 ns
InsertionRunTime	1000	2,162,679.2 ns	43,095.95 ns	56,036.91 ns	2,143,050.0 ns
InsertionCompileTime	1000	257,657.0 ns	8,369.26 ns	24,676.95 ns	244,150.0 ns
QuickRunTime	1000	225,142.2 ns	5,032.60 ns	9,575.05 ns	223,500.0 ns
QuickCompileTime	1000	63,286.3 ns	1,927.54 ns	5,530.47 ns	60,500.0 ns
MergeRunTime	1000	140,117.1 ns	2,749.50 ns	4,517.51 ns	140,800.0 ns
MergeCompileTime	1000	68,186.3 ns	1,798.55 ns	5,160.38 ns	65,800.0 ns
HeapRunTime	1000	393,914.5 ns	7,822.91 ns	16,671.25 ns	389,400.0 ns
HeapCompileTime	1000	323,797.9 ns	6,693.17 ns	13,211.66 ns	319,800.0 ns
OddEvenRunTime	1000	5,011,756.2 ns	99,918.31 ns	155,560.77 ns	4,986,150.0 ns
OddEvenCompileTime	1000	973,746.0 ns	33,628.10 ns	99,153.20 ns	933,100.0 ns
GnomeRunTime	1000	4,275,907.3 ns	97,461.02 ns	175,742.32 ns	4,241,100.0 ns
GnomeCompileTime	1000	849,127.6 ns	33,810.37 ns	98,626.44 ns	854,450.0 ns
CombRunTime	1000	241,954.2 ns	4,787.35 ns	6,224.91 ns	239,800.0 ns
CombCompileTime	1000	55,334.8 ns	2,596.98 ns	3,284.34 ns	54,100.0 ns
ShellRunTime	1000	176,859.1 ns	5,896.09 ns	7,240.93 ns	174,500.0 ns
ShellCompileTime	1000	57,704.4 ns	1,831.03 ns	5,134.41 ns	55,100.0 ns
CocktailRunTime	1000	3,791,028.0 ns	376,516.23 ns	1,110,166.58 ns	3,015,250.0 ns
CocktailCompileTime	1000	1,053,579.4 ns	24,157.94 ns	70,086.57 ns	1,027,600.0 ns
SlowRunTime	1000	NA	NA	NA	NA
SlowCompileTime	1000	NA	NA	NA	NA
BogoRunTime	1000	NA	NA	NA	NA
BogoCompileTime	1000	NA	NA	NA	NA
SystemArraySort	10000	375,656.0 ns	7,459.47 ns	15,068.50 ns	369,400.0 ns
SystemArraySortDelegate	10000	923,688.9 ns	18,135.84 ns	19,405.15 ns	921,550.0 ns
SystemArraySortIComparer	10000	1,023,473.7 ns	20,249.16 ns	22,506.88 ns	1,012,700.0 ns
BubbleRunTime	10000	600,867,614.3 ns	4,690,845.44 ns	4,158,312.30 ns	599,017,050.0 ns
BubbleCompileTime	10000	192,833,142.9 ns	1,284,212.04 ns	1,138,420.52 ns	193,233,400.0 ns
SelectionRunTime	10000	258,595,310.0 ns	1,044,289.74 ns	976,829.27 ns	258,277,750.0 ns
SelectionCompileTime	10000	87,297,760.0 ns	805,172.87 ns	753,159.21 ns	87,415,600.0 ns
InsertionRunTime	10000	118,025,760.0 ns	667,270.63 ns	624,165.36 ns	118,021,000.0 ns
InsertionCompileTime	10000	23,708,953.8 ns	366,291.32 ns	305,869.84 ns	23,604,100.0 ns
QuickRunTime	10000	2,771,133.9 ns	58,543.19 ns	126,020.39 ns	2,722,000.0 ns
QuickCompileTime	10000	760,446.7 ns	14,437.29 ns	13,504.65 ns	762,000.0 ns
MergeRunTime	10000	1,820,241.7 ns	33,955.66 ns	44,151.95 ns	1,807,600.0 ns
MergeCompileTime	10000	785,671.7 ns	16,656.79 ns	21,065.50 ns	781,250.0 ns
HeapRunTime	10000	5,502,445.1 ns	109,420.81 ns	223,517.71 ns	5,475,900.0 ns
HeapCompileTime	10000	2,795,049.0 ns	575,587.02 ns	1,697,131.32 ns	4,231,450.0 ns
OddEvenRunTime	10000	302,667,773.3 ns	1,691,557.61 ns	1,582,284.04 ns	301,906,600.0 ns
OddEvenCompileTime	10000	101,055,620.0 ns	961,584.93 ns	899,467.14 ns	100,707,900.0 ns
GnomeRunTime	10000	266,921,170.0 ns	2,249,810.56 ns	2,104,474.19 ns	266,339,850.0 ns
GnomeCompileTime	10000	67,529,863.6 ns	1,341,591.95 ns	1,647,595.40 ns	67,245,750.0 ns
CombRunTime	10000	3,588,997.7 ns	70,925.62 ns	131,465.18 ns	3,519,500.0 ns
CombCompileTime	10000	744,873.7 ns	14,401.55 ns	16,007.28 ns	747,200.0 ns
ShellRunTime	10000	2,640,967.4 ns	51,866.18 ns	96,137.29 ns	2,611,300.0 ns
ShellCompileTime	10000	752,140.0 ns	14,695.76 ns	19,618.42 ns	751,300.0 ns
CocktailRunTime	10000	294,716,906.7 ns	1,392,103.18 ns	1,302,174.18 ns	295,169,200.0 ns
CocktailCompileTime	10000	113,411,773.3 ns	967,880.93 ns	905,356.43 ns	113,199,600.0 ns
SlowRunTime	10000	NA	NA	NA	NA
SlowCompileTime	10000	NA	NA	NA	NA
BogoRunTime	10000	NA	NA	NA	NA
BogoCompileTime	10000	NA	NA	NA	NA

Generic Measurements Mathematics In C#

Zachary Patten — Sun, 09 Jun 2019 23:20:09 +0000

I wanted to share a pattern I am developing to make working with scientific measurements easier in C#.

Usually when people code scientific topics, they use "double" for all their values. This means positions, accelerations, velocities, etc are all stored as numeric scalars that can be added to each other (causing bugs) and you have no idea what units the values are in without digging all the way back to the initial assignment of the variables.

How many times have you seen someone pass in a degrees angle measurement into the system trig functions (which generally take an angle measurement in radians)? This will not throw an exception. It will result in bad computations that are very hard to detect in applications (you usually have to manually debug and watch the mathematics).

What can we do to help with scientific calculations in code?

We can use the type-safeness to prevent the miss-use of measurements.
We can track the units that each value is in to perform automatic unit conversions.

Here is the current version of the "Angle" type in my project:

The possible units of measurement are defined in an enum and the value of the measurement is a generic type so you can use whatever type you want: double, float, decimal, BigRational, etc. The conversion factors between the units are implemented as attributes on the enum values and are cached in a static conversion table for fast look up.

But what does the actual usage of the code look like? Here is a usage example:

When you define an angle, you provide the units that the measurement is in. From then on, all unit conversion necessary during mathematics will be automatically handled. In this case, we added a Degrees measurement to a Revolutions measurement, which automatically converted the Revolutions measurement into Degrees [0.5 Revolutions = 180 Degrees] for a result of [90 + 180 = 270 Degrees].

The other measurement types can be implemented as their own types: Length, Speed, Acceleration, Force, etc. This will give you type-safeness so that you cannot misuse the measurements. For example:

If we try to add a Length to an Angle the code will not compile. This is a nice extra layer of validity for your code (helps prevent bugs).

What about operations between measurement types that are valid? Easy, there are operators defined between specific types. This example shows how we can create a Speed value either directly or by dividing a Length value by a Time value:

Velocity is different from speed. Velocity is defined to include the direction as well at the magnitude. If you want to represent a velocity, you can just use Speed inside of a Vector. Here is an example:

C# is a type safe language... How am I doing mathematics on generic types? Runtime compilation! Runtime compilation with generic types allows you to break type safeness and assume that the necessary members exist. Example:

This only scratches the surface of the code. If you want to learn more about how it is implemented and/or try it for yourself please check out the project (it is open source): https://github.com/ZacharyPatten/Towel

Thanks. Hope you learned something.

Towel (C#)

Zachary Patten — Sat, 30 Mar 2019 11:47:39 +0000

I have an open source library in C# that I am working on that I want to start advertising. It has generic mathematics, symbolic mathematics, generic data structures, generic algorithms, and more.

Even if you are not a C# developer, much of the code in my project is low-level code that could be useful in any language.

https://github.com/ZacharyPatten/Towel

I want to get people to see it because nearly all the examples I see on GitHub are doing things wrong.

When writing generic data structures in C#, you should not use interfacing. You should use functional programming. This allows you to use any type in your data structures (even primitive types), and you can have multiple data structures of the same type that use different sorting algorithms.
When writing generic mathematics in C# you should not use interfacing with explicit implementations. You should use generic types, runtime compilation, and delegates.
When writing graph-searching algorithms you should not have to build an entire graph in order to perform an A* algorithm. You should use functional programming to build the graph as needed.
You do not need multiple data structures to sort along multiple dimensions. You can use my "omnitree" (and ND SPT) to perform multidimensional sorting in a single data structure (granted I need to optimize it more).

People need to break the barrier between functional programming and object oriented programming. They should be used side-by-side where appropriate.

If you give the code a look, I hope you like it. Feel free to ask me questions. :)