diff --git a/docs/languages/dotnet/csharp/csharp.md b/docs/languages/dotnet/csharp/csharp.md
index aa3f436..d18eff2 100644
--- a/docs/languages/dotnet/csharp/csharp.md
+++ b/docs/languages/dotnet/csharp/csharp.md
@@ -40,23 +40,26 @@ to native code later.
| Event, Enum, Enum Value, | PascalCase |
| Variables, Parameters | camelCase |
-### Namespaces & Imports
+### Namespaces, Imports & Aliases
Hierarchic organization of programs an libraries.
```cs linenums="1"
using System; // import the System Namespace
-using Alias = Namespace; // set an alias for a specific namespace
using static System.Console; // statically import a class to use its static methods w/o qualification
+// type aliases
+using Alias = Namespace.SubNamespace.Type;
+using LookupTable = Dictionary<string, string>;
+using Points = (int, int, int)[];
+
// global using [C# 10], should be in dedicated file
global using <namespace>;
namespace Namespace; // [C# 10]
//or
-namespace Namespace // namespace declaration
+namespace Namespace
{
- // class here
}
```
@@ -788,7 +791,7 @@ Both of these are designed primarily for code generation scenarios, although the
| --------- | ---------------------- |
| x `+=` y | x = x + y |
| x `-=` y | x = x - y |
-| x `*=` y | x = x \* y |
+| x `*=` y | x = x * y |
| x `/=` y | x = x / y |
| x `%=` y | x = x % y |
| x `<<=` y | x = x << y |
@@ -1419,63 +1422,66 @@ If any part is declared abstract, then the whole type is considered abstract.
If any part is declared sealed, then the whole type is considered sealed.
If any part declares a base type, then the whole type inherits that class.
-### Class Declaration
+### Methods
+
+```cs linenums="1"
+class Class
+{
+ static Type Method(Type Argument, ...) {} // static method, can operate ONLY on STATIC VARIABLES
+
+ Type Method(Type Argument, ...) {} // instance method, can operate on INSTANCE VARIABLES
+
+ // override inherited method
+ public override Type Method()
+ {
+ }
+
+ // visrual methods CAN be overridden
+ public virtual Type Method()
+ {
+ }
+}```
+
+### Constructors
+
+```cs
+class Class(Type Parameter, ...) // primary constructor (like records)
+{
+
+ public Class() { } // parameterless constructor
+
+ // standard constructor
+ public Class(type parameter)
+ {
+ _field = field;
+ }
+
+ // extends an existing constructor adding parameters to the existing ones
+ public Class(type parameter, type other) : this(parameter)
+ {
+ _other = other;
+ }
+}
+```
+
+> **Note**: if a _primary constructor_ is used all other constructors must use `this(...)` to invoke it
+
+### Properties & Fields
+
+[Properties Docs](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties)
A _field_ is a variable of any type that is declared directly in a class or struct. Fields are members of their containing type.
A _property_ is a member that provides a flexible mechanism to read, write, or compute the value of a private field.
-The `static` keyword declares that a member is not associated with any particular instance of the class.
-
```cs linenums="1"
class Class
{
- // if static contractor exists the initializer is runned immediately before the static constructor,
- // otherwise is will run no later than the first access to one on the type's fields or methods
- public static type Field = value; // static (non-instance) public field w/ initializer
- // runs before instance's constructor
- private type _field = value; // private instance field w/ initializer
+ public static Type Field = value; // static (non-instance) public field w/ initializer
- private type _field; // private instance field, initialized by constructor
+ private Type _field = value; // private instance field w/ initializer
+ private Type _field; // private instance field, initialized by constructor
- // static constructor, not called explicitly, has no arguments
- // triggered by one of two events, whichever occurs first: creating an instance, or accessing any static member of the class.
- // since it's static and takes no arguments there can be at most one for each class
- static Class() {
- // place to init static fields
- }
-
- public Class() { /* ... */} // parameterless constructor
-
- // class constructor
- public Class(type parameter) {
- _field = parameter;
- }
-
- // extends an existing constructor adding parameters to the existing ones
- public Class(type anotherParameter, type parameter) : this(parameter)
- {
- this._anotherField = anotherParameter;
- }
-
- // called by Console.WriteLine(obj)
- public override string ToString(){
- return <string>
- }
-
- static type Method(arguments) {} // static method, can operate on STATIC VARIABLES
-
- type Method(arguments) {} // instance method, can ONLY operate on INSTANCE VARIABLES
-}
-```
-
-### Properties
-
-[Properties Docs](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties)
-
-```cs linenums="1"
-class Class
-{
private type _backingField;
// PROPERTY
@@ -1587,18 +1593,59 @@ var identity = new Matrix
};
List<int> digits = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+List<int> digits = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ];
+
+int[] digits = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+int[] digits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+int[] digits = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ];
+
+Dictionary<int, string> digits = new Dictionary<int, string> {
+ { 0, "zero" },
+ { 1, "one" },
+ { 2, "two" },
+ { 3, "three" },
+ { 4, "four" },
+ { 5, "five" },
+ { 6, "six" },
+ { 7, "seven" },
+ { 8, "eight" },
+ { 9, "nine" }
+};
+
+Dictionary<int, string> digits = [
+ 0: "zero",
+ 1: "one",
+ 2: "two",
+ 3: "three",
+ 4: "four",
+ 5: "five",
+ 6: "six",
+ 7: "seven",
+ 8: "eight",
+ 9: "nine"
+];
```
### `Static` Class
+The `static` keyword declares that a member is not associated with any particular instance of the class.
Static classes **can't** instantiate objects and all their methods **must** be static.
```cs linenums="1"
static class Class
{
- static type variable = value;
+ // static constructor, not called explicitly, has no arguments
+ // triggered by one of two events, whichever occurs first: creating an instance, or accessing any static member of the class.
+ // since it's static and takes no arguments there can be at most one for each class
+ static Class()
+ {
+ }
- static type method (type parameter, ...)
+ static Type _field = value;
+
+ static Type Property { get; set; } = value;
+
+ static Type Method (Type parameter, ...)
{
}
}
@@ -2212,13 +2259,14 @@ Delegate<Type> lambda = (Type input) => <expr>;
Delegate<Type> lambda = input => { return <expr>; };
Delegate<Type> lambda = (input) => { return <expr>; };
Delegate<Type> lambda = (Type input) => { return <expr>; };
+Delegate<Type> lambda = (Type input = default) => { return <expr>; }; // lambda default parameter
// static modifier prevents unintentional capture of local variables or instance state by the lambda
Delegate<Type> lambda = (static Type input) => <expr>;
Type variable = delegate { <expression>; }; // ignore arguments of the method passed to the delegate
-// lambda type inference [C# 10]
+// lambda type inference
var f = Console.WriteLine;
var f = x => x; // inferring the return type
var f = (string x) => x; // inferring the signature
@@ -2972,7 +3020,6 @@ unsafe
[ptr_math]: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/unsafe-code#pointer-arithmetic
[ptr_comparison]: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/unsafe-code#pointer-comparison
[stack_alloc]: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/unsafe-code#stack-allocation
-[fixed_buffers]: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/unsafe-code#fixed-size-buffers
### Native Memory