A session for .Net Conf TLV 30.10.2019 (Tel-Aviv, Israel). The session describes most of the new features that were added to C# 8.0 and .Net Core 3. Sample Code can be found here: https://github.com/MoaidHathot/.NET-Conf-TLV-2019

1. www.dotnetconf.net

3. What’s new in C# 8.0

4. What’s new in C# 8.0

5. What’s new in C# 8.0

6. What’s new in C# 8.0

7. About Me
• Software engineer, consultant and code Jedi
• Software Craftsmanship advocate
• Clean Coder
• Developing Software professionally since 2013
• OzCode Evangelist
@MoaidHathot
https://moaid.codes
moaidh@codevalue.net
https://github.com/moaidhathot

8. How to try the new features
Install .Net Core 3.0 SDK
Visual Studio 2019
Visual Studio Code
LinqPad 6
RoslynPad 14
Sharplab.io
Jetbrains Rider

9. null

11. Nullable in code
https://docs.microsoft.com/en-us/dotnet/csharp/nullable-references

12. Nullable in Visual Studio
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>netcoreapp3.0</TargetFramework>
</PropertyGroup>
</Project>

13. Nullable in Visual Studio
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>netcoreapp3.0</TargetFramework>
<Nullable>enable</Nullable>
</PropertyGroup>
</Project>

14. Nullable in Visual Studio
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>netcoreapp3.0</TargetFramework>
<Nullable>enable</Nullable>
<WarningsAsErrors>CS8600;CS8602;CS8603;CS8625</WarningsAsErrors>
</PropertyGroup>
</Project>

15. Implementation
https://docs.microsoft.com/en-us/dotnet/csharp/nullable-attributes
https://github.com/dotnet/roslyn/blob/master/docs/features/nullable-metadata.md

16. Adoption
https://docs.microsoft.com/en-us/dotnet/csharp/tutorials/upgrade-to-nullable-references

17. interface

18. Motivation
• Enable an API author to add methods to an interface in future versions without breaking source
or binary compatibility.
• Enables C# to interoperate with APIs targeting Android (Java) and iOS (Swift).
• Provides the elements of “traits”.

20. Allowed modifiers
• Private
• Protected
• Internal
• Public
• Virtual
• Abstract
• Sealed
• Static
• Extern
• partial

21. Learn more
• C# 8 Feature Documentation
• Language Feature Status

22. It is your leg

23. stream

25. Motivation
• Support async/await in Enumerators
• Pull data asynchronously

26. Implementation
public interface IEnumerable<T>
{
IEnumerator<T> GetEnumerator();
}

27. Implementation
public interface IAsyncEnumerable<T>
{
IAsyncEnumerator<T> GetEnumerator(CancellationToken cancellationToken = null)
}

28. Implementation
public interface IEnumerator<T>
{
T Current { get; }
bool MoveNext();
void Reset();
}

29. Implementation
public interface IAsyncEnumerator<T> : IAsyncDisposable
{
T Current { get; }
ValueTask<bool> MoveNextAsync();
ValueTask DisposeAsync();
void Reset();
}

30. Implementation
public interface IDisposable
{
void Dispose();
}

31. Implementation
public interface IAsyncDisposable
{
ValueTask DisposeAsync();
}

32. Usage
public IEnumerable<int> GetRandomNumbers(int count)
{
var random = new Random();
for (var index = 0; index < count; ++index)
{
var number = random.Next(500, 4001);
yield return number;
}
}

33. Usage
public async IAsyncEnumerable<int> GetRandomNumbersAsync(int count)
{
var random = new Random();
for (var index = 0; index < count; ++index)
{
var number = random.Next(500, 4001);
await Task.Delay(number);
yield return number;
}
}

34. Usage
foreach(var item in GetRandomNumbers(10))
{
item.Dump();
}

35. Usage
await foreach(var item in GetRandomNumbersAsync(10))
{
item.Dump();
}

36. Usage
void Test()
{
var foo = new Foo();
foo.Dispose();
}
class Foo : IDisposable
{
public void Dispose()
{
"Disposed".Dump();
}
}

37. Usage
async Task Test()
{
var foo = new Foo();
await foo.DisposeAsync();
}
class Foo : IAsyncDisposable
{
public async ValueTask DisposeAsync()
{
await Task.Delay(500);
"Disposed".Dump();
}
}

38. Usage
void Test()
{
using(var foo = new Foo())
{
}
}
class Foo : IDisposable
{
public void Dispose()
{
"Disposed".Dump();
}
}

39. Usage
async Task Test()
{
await using(var foo = new Foo())
{
}
}
class Foo : IAsyncDisposable
{
public async ValueTask DisposeAsync()
{
await Task.Delay(500);
"Disposed".Dump();
}
}

40. pattern

41. History
• C# 7.0 introduced two Pattern matching features
• The ‘is‘ operator
• The switch match expressions

42. Pattern Matching
• C# 8.0 introduced four Pattern Matching features
• Switch Expressions (as opposed to Statements)
• Property patterns
• Tuple patterns
• Positional patterns

44. index

45. Try and guess
array[0]
array[^0]
array[^1]
array[..]
array[0..]
array[..3]
array[0..3]
array[0..^1]
array[0..^0]
array[^3..^1]
array[^3..^0]
array[^1..^2]
array[0..0]
array[..^0]
var array = new[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//1
//IndexOutOfRangeException
//10
//1, 2, 3, 4, 5, 6, 7, 8, 9, 10
//1, 2, 3, 4, 5, 6, 7, 8, 9, 10
//1, 2, 3
//1, 2, 3
//1, 2, 3, 4, 5, 6, 7, 8, 9
//1, 2, 3, 4, 5, 6, 7, 8, 9, 10
//8, 9
//8, 9, 10
//ArgumentOutOfRangeException
//Empty
//1, 2, 3, 4, 5, 6, 7, 8, 9, 10

46. Try and guess
array[^0]
array[^1]
array[..]
array[0..^1]
array[0..^0]
var array = new[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//array[ array.Length – 0 ]
//array[ array.Length – 1 ]
//array[0] to array[ array.Length ]
//array[0] to array[ array.Length – 1 ]
//array[0] to array [ array.Length]

47. Implementation
• Indices are implemented using System.Index
• Ranges are implemented using System.Range

48. Index
public readonly struct Index : IEquatable<Index>
{
public int Value { get; } //Actual index
public bool IsFromEnd { get; }
public Index(int value, bool fromEnd = false)
public static Index Start { get; } //Return new Index(0) – Private API
public static Index End { get; } //Return new Index(-1) – Private API
public int GetOffset(int length);
public static Index FromStart(int value);
public static Index FromEnd(int value);
public static implicit operator Index(int value);
}

49. Range
public readonly struct Range : IEquatable<Range>
{
public Index Start { get; }
public Index End { get; }
public Range(Index start, Index end);
public static Range All { get; } //Compiler Magic
public static Range StartAt(Index start);
public static Range EndAt(Index start);
public (int offset, int length) GetOffsetAndLength(int length)

50. Type support
• Both Index and Range
• Array
• String
• Span<T>
• ReadOnlySpan<T>
• Indices only
• List<T>

51. Implicit support
• The compiler provides implicit support for Index and Range
• Given some conditions
• Using Duck Typing

52. Countable types
• A type is countable if it has one of the following properties
• Length
• Accessible and returns an int
• Count
• Accessible and returns an int
• If both Count and Length exists, the compiler will use Length

53. Implicit support for Index
• Conditions
• The type is Countable
• The type has an accessible instance indexer with a single int argument
• The type does not have an accessible instance indexer with Index as the first parameter
• Index must be the only parameter or the remaining parameters must be optional
• What is generated
• For indices of the form n
• It will be translated to Index.GetOffset(n) and used with the available indexer;
• For indices of the form ^n
• It will be translated to Index.GetOffset(obj.Length – n) and used with the available
indexer

54. Implicit support for Range
• Conditions
• The type is Countable
• The type has an accessible member named Slice accepting two int parameters
• The type does not have an instance indexer with Range as the first parameter
• Range must be the only parameter or the remaining parameters must be optional
• What is generated
• It has more use cases than Index but the result is similar
• The Range will be translated into a call to the Slice member.

55. Index
void Main()
{
var test = new Test(10);
test[^1].Dump();
test[new Index(4)].Dump();
}
class Test
{
public int Count { get; }
public Test(int maximum)
{
Count = maximum;
}
public int this[int index] => index;
}

56. Index
void Main()
{
var test = new Test(10);
test[^1].Dump();
test[new Index(4)].Dump();
}
class Test
{
public int Count { get; }
public Test(int maximum)
{
Count = maximum;
}
public IEnumerable<int> Slice(int start, int end) => Enumerable.Range(start, end - start);
}

58. useful

59. Using declaration
void Test()
{
using(var foo = new Foo())
{
}
}
class Foo : IDisposable
{
public void Dispose()
{
"Disposed".Dump();
}
}

60. Using declaration
void Test()
{
using(var foo1 = new Foo())
{
using(var foo2 = new Foo())
{
}
}
}
class Foo : IDisposable
{
public void Dispose()
{
"Disposed".Dump();
}
}

61. Using declaration
void Test()
{
using var foo = new Foo();
}
class Foo : IDisposable
{
public void Dispose()
{
"Disposed".Dump();
}
}

62. Using declaration
void Test()
{
using var foo1 = new Foo();
using var foo2 = new Foo();
}
class Foo : IDisposable
{
public void Dispose()
{
"Disposed".Dump();
}
}

63. Using declaration
async Task Test()
{
await using var foo1 = new Foo();
await using var foo2 = new Foo();
}
class Foo : IDisposable
{
public void Dispose()
{
"Disposed".Dump();
}
}

64. Using declaration
Foo foo = new Foo();
try
{
foo.Dump();
}
finally
{
if (foo != null)
{
((IDisposable)foo).Dispose();
}
}

65. Null-coalescing assignment
String str = null;
if(condition)
{
str = “.Net”;
}
…
str = str ?? “C#”;

66. Null-coalescing assignment
String str = null;
….
str ??= “C#”;

67. Enhancement of interpolated verbatim strings

68. Enhancement of interpolated verbatim strings
Starting from C# 8, both of them are allowed
• $@”{value}”
• @$”{value}”

69. Thank you
@MoaidHathot
https://moaid.codes
moaidh@codevalue.net
https://github.com/moaidhathot
https://github.com/MoaidHathot/.NET-Conf-TLV-2019