Coronavirus News

Stay up-to-date with the latest news about the Coronavirus with tools and data in my Collection: Coronavirus Critical Links.

5 Uncommon C# Statements/Keywords

After digging around in C#, I found some interesting discoveries. In today's post, I go over these uncommon C# statements/keywords with some examples.

Written by Jonathan Danylko • Last Updated: • Develop •
Image of Magnifying glass looking at a city

With C# 8.0 coming soon, I decided to dig into C# and look at some interesting statements and/or keywords developers have forgotten about or don't use anymore.

For today's post, I wanted to bring them to the surface and see if anyone still uses them.

While these statements/keywords are definitely rare, I can't remember the last time I've used them.

Oh, and just because I mention them here doesn't mean you can run rampant writing goto statements everywhere! ;-)


Who doesn't remember Goto?

Goto sends the program's execution to a labeled piece of code (and no, not line numbers).

Goto statements can be applied to a switch statement or with a label.

Here is one example:

class SwitchTest
    static void Main()
        Console.WriteLine("Coffee sizes: 1=Small 2=Medium 3=Large");

        Console.Write("Please enter your selection: ");         string s = Console.ReadLine();
        int n = int.Parse(s);         int cost = 0;
        switch (n)         {             case 1:                 cost += 25;                 break;             case 2:                 cost += 25;                 goto case 1;             case 3:                 cost += 50;                 goto case 1;             default:                 Console.WriteLine("Invalid selection.");                 break;         }
        if (cost != 0)         {             Console.WriteLine("Please insert {0} cents.", cost);         }
        Console.WriteLine("Thank you for your business.");         // Keep the console open in debug mode.         Console.WriteLine("Press any key to exit.");         Console.ReadKey();     } } /* Sample Input:  2   Sample Output: Coffee sizes: 1=Small 2=Medium 3=Large Please enter your selection: 2 Please insert 50 cents. Thank you for your business. */

The GOTO statement has been around for a while...and not just in C#, but other various languages in general. For example, I remember writing BASIC code on my Commodore VIC-20 using GOTO statements.

Man, things have changed, but, honestly, I don't miss the GOTO statement.

Now if I see it in a program, I scratch my head and ask "why is it there?"


This was an interesting find.

The checked block is meant to explicitly enable overflow checking for integral-type arithmetic operations and conversions where the unchecked block is meant to suppress or prevent overflow-checking.

An example would look like this:

// Checked block.
    int i3 = 2147483647 + ten;

Personally, I've never gone past the limits of an integer type to even warrant a checked/unchecked block, but that doesn't mean it won't happen in the future.


Now THIS is a versatile little statement.

You can use this in two ways:

  1. In the case label of a switch statement
  2. In the catch statement of a a try..catch exception block

In the case of an exception, this example catches a number of Http Status Codes thanks to when.

class Program
    static void Main()

    public static async Task<string> MakeRequest()     {          var client = new System.Net.Http.HttpClient();         var streamTask = client.GetStringAsync("https://localHost:10000");         try {             var responseText = await streamTask;             return responseText;         }          catch (HttpRequestException e) when (e.Message.Contains("301")) {             return "Site Moved";         }         catch (HttpRequestException e) when (e.Message.Contains("404")) {             return "Page Not Found";         }         catch (HttpRequestException e) {             return e.Message;         }     } }

With multiple errors in an HttpRequestException, you really don't know what error occurred. This is where the when clause makes sense and saves space.

When it comes to a case statement, the when clause makes your code even more readable.

private static void ShowShapeInfo(Object obj)
    switch (obj)
        case Shape shape when shape.Area == 0:
            Console.WriteLine($"The shape: {shape.GetType().Name} with no dimensions");
        case Rectangle r when r.Area > 0:
            Console.WriteLine("Information about the rectangle:");
            Console.WriteLine($"   Dimensions: {r.Length} x {r.Width}");
            Console.WriteLine($"   Area: {r.Area}");
        case Square sq when sq.Area > 0:
            Console.WriteLine("Information about the square:");
            Console.WriteLine($"   Length of a side: {sq.Side}");
            Console.WriteLine($"   Area: {sq.Area}");
        case Shape shape:
            Console.WriteLine($"A {shape.GetType().Name} shape");
        case null:
            Console.WriteLine($"The {nameof(obj)} variable is uninitialized.");
            Console.WriteLine($"The {nameof(obj)} variable does not represent a Shape.");

This gives you an expanded syntax to properly hit your case statements under the proper conditions.


Again, never knew these existed.

The explicit keyword is meant for declaring a user-defined type conversion operator that must be invoked with a cast.

The example is a better way to define it.

    struct Digit
        byte value;
        public Digit(byte value)
            if (value > 9)
                throw new ArgumentException();
            this.value = value;

        // Define explicit byte-to-Digit conversion operator:         public static explicit operator Digit(byte b)         {             Digit d = new Digit(b);             Console.WriteLine("conversion occurred");             return d;         }     }
    class ExplicitTest     {         static void Main()         {             try             {                 byte b = 3;                 Digit d = (Digit)b; // explicit conversion             }             catch (Exception e)             {                 Console.WriteLine("{0} Exception caught.", e);             }         }     } /* Output: conversion occurred */

The implicit keyword declares an implicit user-defined type conversion operator (again, an example may clear things up).

class Digit
    public Digit(double d) { val = d; }
    public double val;
    // ...other members

    // User-defined conversion from Digit to double     public static implicit operator double(Digit d)     {         return d.val;     }

    //  User-defined conversion from double to Digit     public static implicit operator Digit(double d)     {         return new Digit(d);     } }
 Program {     static void Main(string[] args)     {         Digit dig = new Digit(7);
        //This call invokes the implicit "double" operator         double num = dig;
        //This call invokes the implicit "Digit" operator         Digit dig2 = 12;
        Console.WriteLine("num = {0} dig2 = {1}", num, dig2.val);         Console.ReadLine();     } }

Of course, these only work on operators and I ask you...when did you need the ability to code custom operators?

Yeah...I thought so. ;-)

Extern Alias

Let's say you have to reference two versions of assemblies that use the same fully-qualified type names with two or more versions of an assembly in the same app.

By using an external assembly alias, those namespaces from each assembly can be wrapped inside a root-level namespaces names by the alias where they can be used n the same file.

Based on their example, you have two grids in your application. One uses an old version (grid.dll) and one uses the new version (grid20.dll). When you compile your code, on one assembly, use the /r compiler flag:


and on the other assembly, use the /r flag to identify that grid.


Once these are in place, you can access them through your code by adding the extern alias keyword:

extern alias GridV1

extern alias GridV2

This allows you to version your code, but still keep them separated from each other.


These five statements/keywords may be buried under a pile of C# code and not used as much, but C# continues to impress me with the amount of language changes it delivers to developers making it extremely flexible and competitive with the latest languages out there.

It makes me wonder what's coming next for C#.

Do you use any of these keywords or statements? Did I miss any rare gems in C#? Post your comments below and let's discuss!

Did you like this content? Show your support by buying me a coffee.

Buy me a coffee  Buy me a coffee
Picture of Jonathan Danylko

Jonathan Danylko is a freelance web architect and avid programmer who has been programming for over 20 years. He has developed various systems in numerous industries including e-commerce, biotechnology, real estate, health, insurance, and utility companies.

When asked what he likes to do in his spare time, he replies, "Programming."

comments powered by Disqus