C# on Russell Patterson

New in C# 7.0: Part 4 - Expression-Bodied Members

Sun, 01 Apr 2018 23:00:33 +0000

This week, we’re discussing Expression-Bodied Members in C# 7.0. Now, this was an existing feature in C# 6.0, but it was limited to only methods, like so:

public void DoAThingCS6() => Console.WriteLine("This is a test");

With the new additions in C# 7.0, we can now do Constructors, Deconstructors, and Properties. A Constructor definition looks like this:

public SomeClass() => DoAThing();

Similarly, a Deconstructor looks like this:

~SomeClass() => DoAThing();

Finally, although auto-properties are shorter, you can write properties with specific implementations with this new shorthand:

New in C# 7.0: Part 3 – Ref Returns

Sun, 25 Mar 2018 23:00:10 +0000

Picking up where I left off last week, there’s another interesting new feature called “Ref Returns”. Similar to Ref Locals, this allows you to return a reference from a method, and then optionally use it as a Ref Local in the calling code.

Let’s look at the following method definition:

private static string[] strings = { "this", "is", "a", "test" };

public static ref string GetSomeString(int number)
{
 if (number < 0 || number >= strings.Length) 
 throw new IndexOutOfRangeException();

 // Returns a reference to the actual string, instead of just a copy of it.
 return ref strings[number];
}

The method takes an integer, and returns an entry from an array with that index. The important differences from a normal method is the ref keyword in the method signature, and the ref keyword after the return keyword. This tells the compiler that you want the method to return a reference to the variable/object, instead of passing it back by value.

New in C# 7.0: Part 2 – Ref Locals

Sun, 18 Mar 2018 23:22:39 +0000

After about a year, I’m finally trying to start writing some more blog posts, so I’ll pick up right where I left off. Today, I’m going to give a brief overview of Ref Locals.

Ref Locals allow you to create an alias for a variable so that you are not creating another copy of the data or reference (in the case of an object), in memory. In previous versions of C#, if you wanted to refer to a local variable with a different name, you’d have to do this:

New in C# 7.0: Part 1 - Out Variables

Sat, 11 Feb 2017 13:00:09 +0000

This is the first post in a series on the new features available in Visual Studio 2017 and C# 7.0. Today, I’m going to be talking about Out Variables.

One of the great new features is probably something you will use frequently, which is defining an out variable, and using that variable in the same statement. Currently, to use an out variable, one must do something like this:

DateTime dt;
if (DateTime.TryParse("2016-09-14", out dt))
{
 Console.WriteLine(dt);
}

With simple syntactic sugar in the new version, you can instead do this: