C Sharp
C# 9.0
Required
2019 16.8.2 and .NET 5.0
Type not Required For New is implied
Like auto in c++ or var in c# we can now omit the new Keyword if the type can be implied
public IainType ConvertToIain(String inParam1) {
// return new IainType(inParam1);
return new(inParam1);
}
Init for Properties
The init keyword on a property means that the value can only be set at initialisation time.
class Thing {
public int Id {get; init; }
public String Name {get; init; }
}
...
// Works
var myThing = new MyThing {
Id = 123,
Name = "No Name"
}
// No longer works
myThing.id = 55
Records and Properties
So to implement readonly class with getters we can now write. It will probably take more time to get pigments to work.
public abstract record Thing(int Id, String Name(;
Note A record is equal to another record when the properties and values match AND they are of the sames type. We can derive from a record like so
public record ChildThing(int newProp, int Id, String Name): Thing(Id,Name)
We can clone immutable records using the clone oops with command
var myThing2 = mything with { Name = "Derek"}
Records support constructors, functions and properties too
public record MyDto(String Name) {
public string City {get; init;}
public void SuperFunctionOopsMethod(} {
}
}
Patterns and Expression
Finally switch with expression has arrived
var myBaseViewModel = type switch {
Type.Unknown => new BaseViewModel(),
Type.Sport => new SportViewModel(),
not null => throw new ArgumentException($"Unknown type {type}"),
_ => throw new ArgumentException($"Unknown type {type}")
};
In c# 9.0 the boolean expression is now a direct pattern called a relational pattern. The old approach
price += e,.numberOfDays switch {
var days when days < 3 => price * e.NumberOfDays,
var days when days >= 3 && days < 6 => 200,
var days when days >= 6 => 360
}
The new. Note the && become "and".The fancy words for this is conjunctive pattern.
price += e,.numberOfDays switch {
< 3 => price * e.NumberOfDays,
>= 3 and days < 6 => 200,
>= 6 => 360
}
C# 8.0 and .Net Core 3.0
Intro
Here is the history of C#
- 2.0 included generics
- 3.0 Added Linq with Lambda and anonymous types
- 4.0 Added Dynamics
- 5.0 Added Async and Await
- 6.0 Added Null propagating operator (targer?.IsActive ?? false;
- 7.0 Expressions, Span and Tuples
C# 8.0 brings
- Nullable Reference Types
- Pattern Matching
- Indices and Ranges
- Built-in Json Support
- Windows Desktop Support
- Build and Deploy Improvements
- Other Language Improvements
- Other .NET Core Platform Improvements
Nullable Reference Types
This allows you to specify a possibility of null. e.g.
class
{
public string? Title {get; set;}
public List<Comment> Title {get;} = new List<Comment>();
}
Bad code is highlighted a compile time with CS8618 Non-nullable property and via intellisence.
You and enable and restore this feature on a file basis using #nullable enable and #nullable restore
Pattern Matching
Deconstructors
Hardcoded unlike javascript
claas Test
{
public PropA {get; set;}
public PropB {get; set;}
public PropC {get; set;}
public PropD {get; set;}
Test(string a, string b, string c, string d)
{
PropA = a;
PropB = b;
PropC = c;
PropD = d;
}
void Deconstructor(
out string a,
out string b,
out string c,
out string d)
{
a = PropA;
b = PropB
c = PropC;
d = PropD;
}
}
Positional Pattern
public static bool TestHasCValue5(Test inTest)
{
return inTest is Test(_,_,"5",_);
}
Property Pattern
public class Employee
{
public string FirstName {get; set;}
public string LastName {get; set;}
public string Region {get; set;}
public Employee ReportsTo {get; set;}
}
public static bool IsUsBasedWithUkManager(object o)
{
return o is Employee e &&
e is { Region: "US", ReportsTo: {Region:" UK" }};
}
Switch Expression
Allows switching on types
var result = shape switch
{
Rectangle r => "{r.Length}",
Circle {Radius: 1} c => "Small Circle", // We can use LHS too!
Circle c => "{c.Radius}",
Triangle t => "{t.Side1}",
_ => "Default"
}
Tuple Pattern
public statis bool MakesBlue(Color c1, Color c2)
{
return (c1,c2) is (Color.Red, Color.Green) ||
(c2,c1) is (Color.Red, Color.Green);
}
Indices and Ranges
Index reference as location in the sequence
var numbers = new[] {0,1,2,3,4,5};
var number = numbers[1]; // number is 1
var numberFromRHS = numbers[^2]; // number is 4
Note ^1 is the last element
C# now supports the range expressions with dots.
var numbers = Enumerable.Range(1,10).ToArray();
var copy = numbers[0..^0];
var lastThreeItems = numbers[3^..];
Built-in Json Support
Adds support similar to NewtownSoft but does lack features. Just some key reminders in the code below. Google examples
// Reading as Tokens
var myBytes = File.ReadAllBytes("my.json");
var jsonSpan = myBytes.AsSpan();
var json = new Utf8JsonReader(jsonSpan);
while(json.Read()) // goes to next token
{
GetData(json);
}
// Parse
using var stream = File.OpenRead("my.json");
using var document = JsonDocument.Parse(stream);
var root = document.RootElement;
foreach(var prop in root.EnumerateObject())
{
if(prop.Value.ValueKind == JsonValueKind.Object)
...
}
// Writing
var outputOptions = new JsonWriteOptions {
Indented = true;
};
var buffer = new ArrayBufferWriter<byte>();
using var json = new Utf8JsonWriter(buffer, outputOptions);
json.WriteStartObject();
json.WritePropertyName("NAME");
json.WriteStringValue"Value");
...
json.WriteEndObject();
json.Flush();
// Deserialize
var serialOptions = new JsonSerializerOptions {
PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
};
var myTestObject = JsonSerializer.Deserialize<TestObject>(text,serialOptions);
// Serialize
JsonSerializer.Serialize(myTestObject, serialOptions);
Windows Desktop Support
- Only on Windows
- Supports WPF in Core
- Supports WinForms in Core
Build and Deploy Improvements
- Builds a platform application .exe and deps copied
- Can publish single file (not default)
- Trimmed only publishes used parts (not default)
- ReadyToRun Image, as Native and .Net Code (Difficult o understand what this is)
<TarghetFramework>3.0<TarghetFramework>
<PublishSingleFile>true</PublishSingleFile>
<PublishTrimmed>true</PublishTrimmed>
<PublishReadyToRun>true</PublishReadyToRun>
Other Language Improvements
Supports Default Implementation on Interface
public interface IStarTrekWidget
{
string Captain {get; }
string WriteLog() // Not allowed prior to 8.0
{
Console.WriteLine("Captain's Log Stardate");
}
}
Using Fixed
Finally the language supports this
using var leakingResource = new LeakyResource();
Asyncronous Streams
When consuming an asynchronous stream, you need to specify the await keyword followed by the foreach keyword. You can call the method in the above example from the Main method as shown in the code snippet below.
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Test
{
class Program
{
const int DELAY = 1000;
const int MIN = 1;
const int MAX = 10;
static async Task Main(string[] args)
{
await foreach (int number in GetData())
{
Console.WriteLine(number);
}
Console.ReadLine();
}
static async IAsyncEnumerable<int> GetData()
{
for (int i = MIN; i < MAX; i++)
{
yield return i;
await Task.Delay(DELAY);
}
}
}
}
Local Functions
You can add static to local function to disallow access to global, local values
public void Run()
{
var state = "42";
static string NotAllowed()
{
return state + "99";
}
}
Disposable ref Structs
You can now use the using keyword to destroy.
public unsafe ref struct UnmanagedHandle
{
private int* handle;
public UnmanagedHandle(int* handle) = this.handle = handle;
public int* GetHandle() {
return handle;
}
public void Dispose() {
ResourceManager.Free(this.handle);
}
}
Other .NET Core Platform Improvements
- Supports Intrinsics (SSE etc)
- Supports OpenSSL 1.1.1
- Floating point Support
- HTTP 2.0 protocol
- GPIO Support