2/2/2025, 9:07:03 AM

CSharp 12 In a Nutshell

[!NOTE]

This note is not done

C# is a general-purpose, type-safe, object-oriented, platform-neutral programming language. Its goal is to boost programmer productivity.

Unified type system, all types share the same base class.
Class and interfaces
Properties, methods and events
- functions are values
- events are function members, simplify acting on state changes
- support patterns for purity
Automatic memory management
- does not eliminate pointers, just make it unnecessary most of the time.
Supports windows 7+, macOS, Linux, Android & IOS, windows 10 devices.
- Browser through Blazor technology

CLRs, BCLs & Runtimes

.NET .NET 8 is Microsoft's flagship open-source runtime, its update history as follows: .NET Core 1.x → NET Core 2.x → .NET Core 3.x → .NET 5 → .NET 6 → .NET 7 → .NET 8. After .NET Core 3, Microsoft removed “Core” from the name and skipped version 4 to avoid confusion with .NET Framework 4.x. .NET framework 4.x is something comes before .NET Core 1.x but it is still supported and in popular use.
Windows Desktop and WinUI 3 Both are intended for writing client-rich application that runs on Windows 10 and above. WinUI 3 is a successor of Universal Windows Platform (UWP), and was released in 2022. Windows Desktop APIs existed since 2006 and has huge third party library and community support.
MAUI Multi-platform App UI, for developing mobile application on android and iOS, can be used for desktop apps via Mac Catalyst and WinUI 3. It is an evolution of Xamarin.
For cross-platform desktop application, a third-party library called Avalonia offers an alternative to MAUI, which is simpler than MAUI with almost complete WPF compatibility.
.NET Framework .NET Framework is Microsoft’s original Windows-only runtime for writing web and rich-client applications that run (only) on Windows desktop/server. No major new releases planned, but the latest release will continue to be supported and maintained due to wealth of existing applications.
readonly function modifier means it does not modify properties, but not itself cant be modified. It can be used on struct to enforce all fields are readonly.
use @prefix @using to use reserved word as identifier.
use using var reader = File.OpenText(...) to close file when out of scope
use checked to explicitly check for arithmetic overflow exception (vice versa unchecked)
string interpolation $"number is: {x}"
collection expression: char[] vowels = ['a','e','i','o','u'];, declare collection with square bracket
value type like struct is initialized with bitwise zero, otherwise it is null
The design principle here is that users expect the lexical structure of the brackets and commas to be consistent across declaration, initialization and dereferencing.
- about 2d array https://ericlippert.com/2009/08/17/arrays-of-arrays/
array bound check is necessary, but optimization can prevent necessary checks, e.g. in a loop and c# provide unsafe code to bypass it.
prepend ref keyword function parameter to accept value by reference into a function
string is value type
use out to return values back from method.
use _ when you dont care about a variable
- for backward compatibility purpose, it will not work if you have an underscore variable in scope.
use in like a const ref method argument, useful for reducing overhead for copying large value type.
- both caller and callee must use the in keyword
last param as varargs int Sum (params int[] ints)
optional params void Foo (int x = 23) { Console.WriteLine (x); }

named arguments

Foo (x:1, y:2);  // 1, 2 
void Foo (int x, int y) { Console.WriteLine (x + ", " + y); }

you can mix named and positional arguments

When calling ref function, you can call without assigning result to ref variable, this fallback to ordinary value: string localX = GetXRef();
You can also prevent a ref from being modified: static ref readonly string Prop => ref x;
var implicit typed local variable
use new() when the class can be inferenced from left hand side
multi initialize: a = b = c = d = 0
assignment in expression: y = 5 * (x = 2)
binary operators, except for assignment, lambda and null-coalescing operators are left-associative
null-coalescing operator: string s2 = s1 ?? "nothing"

null conditional

int x = sb?.ToString().Length;  // Illegal: int cant be null]
int? x = sb?.ToString().Length;  // ok, int? can be null

you can open a scope anytime with curly brackets {}

imports

  using System;
  System.Console.Writeline("x");

  using static System.Console;
  Writeline("x");

```
  global using System;
```

All type names are converted to fully qualified names
you can call using xxx within some namespace
using alias: using R = System.Reflection; class Program { R.PropertyInfo p; }
:: namespace qualification, e.g. global::A.B(), useful for referring to hidden namespace.
naming
- private: camel-cased with underscore _firstName
- local variable: camel-cased firstName
- public: Cap case: FirstName

multi-field declare

static readonly int legs = 8,                    
					eyes = 2;

const public const string Message = "Hello World"
static readonly maybe different each time the program runs (e.g. DateTime.Now), but const will always be the same (e.g. PI).
adding static modifier to a local method prevent it from seeing other local variables.
this refers to instance itself, invalid when static
property's get and set method can be overridden
- internally, they are compiled to get_XXX and set_XXX

custom indexer

public string this[int wordNum]   // indexer
{
    get { return words[wordNum]; }
    set { words[wordNum] = value; }
}

static field initializer runs in order they are declared

class Foo {  
    public static int X = Y;    // 0  
    public static int Y = 3;    // 3 
}

finalizer / destructor ~ClassName() { ... }
partial methods

nameof operator returns the name of the symbol

nameof(count);  // count
nameof(StringBuilder.Length);  // Length

use as to downcast and evaluate to null if fails. Stock s = a as Stock
pattern variable x: if (x is Stock s) { ... }
use virtual to declare unimplemented method, and override to implement it in subclass
- you can call parent implementation with base keyword
- calling virtual method in constructor is dangerous, because the overriding method may not know it is working on a partially initialized object
- from c# 9, overriding method can return a subclass type
abstract is like virtual, but without default implementation
when you hide a parent class member, use new keyword to tell compiler it is intended behaviour to avoid a compiler warning
```
public class A     { public     int Counter = 1; } 
public class B : A { public new int Counter = 2; }
```
you can also hide a method instead of override it, the difference is, when you call that method using a parent type (which instance is actually a subtype), it will use the parent implementation instead of child implementation, unlike override, where you get polymorphism.
subclass must declare its own constructor, but it can call any base class constructor using the base keyword
```
public class Subclass : Baseclass {  
    public Subclass (int x) : base (x) {
    	...
    } 
}
```
- if base keyword is missing, the base type's parameter-less constructor is implicitly called
  - if no such constructor exists in base class, subclass must use the base keyword
required member must be populated via object initializer when constructed
object is the base class for all types

boxing and unboxing

int x = 9; 
object obj = x; // boxing
int y = (int)obj; // unboxing

array variance only works with reference convertion, not boxing convertion

object[] a1 = new string[3];   // Legal 
object[] a2 = new int[3];      // Error

  Point p = new Point(); Console.WriteLine (p.GetType().Name); // Point 
  Console.WriteLine (typeof (Point).Name);          // Point 
  Console.WriteLine (p.GetType() == typeof(Point)); // True 
  Console.WriteLine (p.X.GetType().Name);           // Int32 
  Console.WriteLine (p.Y.GetType().FullName);       // System.Int32
  public class Point { public int X, Y; }

ToString() returns type name if you don't override it
struct
- is a value type
- no inheritance (other than derived from System.ValueType)
- no finalizer
- before c# 10, it is further restricted with no initializer and parameter-less constructors, it is relaxed primarily for benefits of record struct
  - even if you define a constructor, a bitwise zero initialization is still possible with default keyword: Point p = default. A good strategy is giving valid value for default state
- ref struct is a niche feature introduced in c# 7.2
when you inherit two interfaces with same function, you can implement them by int I2.Foo() and int I1.Foo(), the only way to call it is by casting the instance to the corresponding interface and then call the method ((I1)w).Foo(); and ((I2)w).Foo();.
enums
```
public enum BorderSide { Left, Right, Top, Bottom }

public enum BorderSide : byte { Left=1, Right=2, Top=10, Bottom=11 }
```
- you can convert it to underlying type by explicit cast
- because enum cast be cast from and to other type, enums' actual value can fall outside of range, e.g. BorderSide b = (BorderSide)12345; b++; // no error
  - you can use Enum.IsDefined to check if an enum actually have valid values

generics

you can use value type: Stack<int>
generics does not exists in runtime, only compilation. However, you can have a Type that holds unbounded generic type
```
Type a1 = typeof (A<>);   // Unbound type (notice no type arguments). 
Type a2 = typeof (A<,>);  // Use commas to indicate multiple type args.
```
It is used in conjunction with reflection apis
use default keyword to get the default value for a generic parameter, for reference type, it is null, and bitwise zero for value type.
you can omit type parameter when the compiler is able to infer it

you can specify type constraints

Constraint	Description
`where T : base-class`	Base-class constraint
`where T : interface`	Interface constraint
`where T : class`	Reference-type constraint
`where T : class?`	Nullable Reference Types (see Chapter 4)
`where T : struct`	Value-type constraint (excludes Nullable types)
`where T : unmanaged`	Unmanaged constraint. ( T must be a simple value type or a struct that is (recursively) free of any reference types.)
`where T : new()`	Parameterless constructor constraint
`where U : T`	Naked type constraint
`where T : notnull`	Non-nullable value type, or (from C# 8) a non-nullable reference type

Runtime type check is possible because every object on heap internally stores a little type token, you can retrieve it by calling GetType method of object.

historically speaking, relying on constructors for object initialization could be advantageous in that it allowed us to create fields with read-only access, but this also means we abandoned object initializer (caller side initialization). To solve this problem, c# 9 introduced init keyword to only allow a property to be set either in constructor or object initializer.

Optional parameters have two drawbacks:

It does not easily allow non-destructive mutation (obj with { ... }).
when used in library, it hinders backward compatibility, because adding an optional parameters breaks assembly's binary compatibility with existing consumers
- When application code compiles with library code, library's optional parameter values are copied to the application code, effective making library.Test() becomes library.Test(optionalBool=True) in the application's binary code. If later library decided to change optionalBool to be something else, the application code is not updated automatically. Furthermore, because there is no optional parameter in the binary, if library decided to add a new optional parameters, it breaks application code because now the signature has changed, and application cant find library's new method. It does not just use the default value like python.

Covariance

if A convertible to B, T has covariance parameter if T<A> is convertible to T<B>. This means,
- e.g. IEnumerable<T>

typical class cant be covariant,

Stack<Bear> bears = new Stack<Bear>(); 
Stack<Animal> animals = bears;            // Compile-time error
animals.Push (new Camel());      // Prevent adding Camel to bears

For historical reason, array supports covariance, the above code only fails in compile time

declare a covariant parameter
```
public interface IPoppable<out T> { T Pop(); }
```
- this means T can only be at output position, i.e. return type, there is no way to make it as a input parameter and accidentally adding it to the wrong collection
- due to limitation in CLR, method parameter with out is not eligible for covariance

contravariant is similar concept where you cast upwards, converting from T<Bear> to T<Animals>

you declare such parameter with in keyword public interface IPushable<in T> { void Push (T obj); }

this means you can only use T in input position

public interface IComparer<in T> {  // Returns a value indicating the relative ordering of a and b  
	int Compare (T a, T b); 
}
var objectComparer = Comparer<object>.Default; 
// objectComparer implements IComparer<object> 
IComparer<string> stringComparer = objectComparer; 
int result = stringComparer.Compare ("Brett", "Jemaine");

c# generics happens in compile time, you write a class, compile it into a .dll library, and other application use it freely. Note that this means c# generics must declare all possible values when writing it.

  // OK
  static T Max <T> (T a, T b) where T : IComparable<T>  => a.CompareTo (b) > 0 ? a : b;
  
  // Compile error, > operator might not exists in all types
  static T Max <T> (T a, T b)  => (a > b ? a : b);
  
  // For C++ template, this is OK
  template <class T> T Max (T a, T b) {  return a > b ? a : b; }
  // Reason: C++ template exists as source code as part of the application using this code
  // because this code exists as source code, it is recompiled everytime it is used,
  // therefore compiler can check on the fly whether the new code's T parameter type
  // support the > operator and fail if needed.

Accessibility Level	Description
public	Fully accessible. This is the implicit accessibility for members of an enum or interface.
internal	Accessible only within the containing assembly or friend assemblies. This is the default accessibility for non-nested types.
private	Accessible only within the containing type. This is the default accessibility for members of a class or struct.
protected	Accessible only within the containing type or subclasses.
protected internal	The union of `protected` and `internal` accessibility. A member that is `protected internal` is accessible in two ways.
private protected	The intersection of `protected` and `internal` accessibility. A member that is `private protected` is accessible only within the containing type, or from subclasses that reside in the same assembly.
file (from C# 11)	Accessible only from within the same file. Intended for use by source generators (see "Extended partial methods" on page 125). This modifier can be applied only to type declarations.

Modifier Type	Modifier
Static modifier	`static`
Access modifiers	`public` `internal` `private` `protected`
Inheritance modifier	`new`
Unsafe code modifier	`unsafe`
Read-only modifier	`readonly`
Threading modifier	`volatile`

Category	Operator symbol	Operator name	Example	User-overloadable
Primary	.	Member access	`x.y`	No
Primary	?. and ?[]	Null-conditional	`x?.y` or `x?[0]`	No
Primary	! (postfix)	Null-forgiving	`x!.y` or `x![0]`	No
Primary	-> (unsafe)	Pointer to struct	`x->y`	No
Primary	()	Function call	`x()`	No
Primary	[]	Array/index	`a[x]`	Via indexer
Primary	++	Post-increment	`x++`	Yes
Primary	--	Post-decrement	`x--`	Yes
Primary	new	Create instance	`new Foo()`	No
Primary	stackalloc	Stack allocation	`stackalloc(10)`	No
Primary	typeof	Get type from identifier	`typeof(int)`	No
Primary	nameof	Get name of identifier	`nameof(x)`	No
Primary	checked	Integral overflow check on	`checked(x)`	No
Primary	unchecked	Integral overflow check off	`unchecked(x)`	No
Primary	default	Default value	`default(char)`	No

Category	Operator symbol	Operator name	Example	User-overloadable
Unary	await	Await	`await myTask`	No
Unary	sizeof	Get size of struct	`sizeof(int)`	No
Unary	+	Positive value of	`+x`	Yes
Unary	-	Negative value of	`-x`	Yes
Unary	!	Not	`!x`	Yes
Unary	~	Bitwise complement	`~x`	Yes
Unary	++	Pre-increment	`++x`	Yes
Unary	--	Pre-decrement	`--x`	Yes
Unary	()	Cast	`(int)x`	No
Unary	^	Index from end	`array[^1]`	No
Unary	* (unsafe)	Value at address	`*x`	No
Unary	& (unsafe)	Address of value	`&x`	No
Range	..	Range of indices	`x..y`	No
Range	..^		`x..^y`	No
Switch & with	switch	Switch expression	`num switch { 1 => true, _ => false }`	No
Switch & with	with	With expression	`rec with { X = 123 }`	No
Multiplicative	*	Multiply	`x * y`	Yes
Multiplicative	/	Divide	`x / y`	Yes
Multiplicative	%	Remainder	`x % y`	Yes
Additive	+	Add	`x + y`	Yes
Additive	-	Subtract	`x - y`	Yes
Shift	<<	Shift left	`x << 1`	Yes
Shift	>>	Shift right	`x >> 1`	Yes
Shift	>>>	Unsigned shift right	`x >>> 1`	Yes
Relational	<	Less than	`x < y`	Yes
Relational	>	Greater than	`x > y`	Yes
Relational	<=	Less than or equal to	`x <= y`	Yes
Relational	>=	Greater than or equal to	`x >= y`	Yes
Relational	is	Type is or is subclass of	`x is y`	No
Relational	as	Type conversion	`x as y`	No

Category	Operator symbol	Operator name	Example	User-overloadable
Equality	==	Equals	`x == y`	Yes
Equality	!=	Not equals	`x != y`	Yes
Bitwise And	&	And	`x & y`	Yes
Bitwise Xor	^	Exclusive Or	`x ^ y`	Yes
Bitwise Or			Or	`x
Conditional And	&&	Conditional And	`x && y`	Via &
Conditional Or				Conditional Or
Null coalescing	??	Null coalescing	`x ?? y`	No
Conditional	?:	Conditional	`isTrue ? thenThis : elseThis`	No
Assignment and lambda	=	Assign	`x = y`	No
Assignment and lambda	*=	Multiply self by	`x *= 2`	Via *
Assignment and lambda	/=	Divide self by	`x /= 2`	Via /
Assignment and lambda	%=	Remainder & assign to self	`x %= 2`	Via %
Assignment and lambda	+=	Add to self	`x += 2`	Via +
Assignment and lambda	-=	Subtract from self	`x -= 2`	Via -
Assignment and lambda	<<=	Shift self left by	`x <<= 2`	Via <<
Assignment and lambda	>>=	Shift self right by	`x >>= 2`	Via >>
Assignment and lambda	>>>=	Unsigned shift self right by	`x >>>= 2`	Via >>>
Assignment and lambda	&=	And self by	`x &= 2`	Via &
Assignment and lambda	^=	Exclusive-Or self by	`x ^= 2`	Via ^
Assignment and lambda		=	Or self by	`x
Assignment and lambda	??=	Null-coalescing assignment	`x ??= 0`	No
Assignment and lambda	=>	Lambda	`x => x + 1`	No

CSharp 12 In a Nutshell

CLRs, BCLs & Runtimes

Comments