Add documentation for C# Generics and Linux Software Installation; remove outdated files; improve code-behind

Author: EXStevens

docs/CSharpDotNet/Generics/Async-Generics.md

@@ -0,0 +1,151 @@
+---
+title: Basic Syntax
+sidebar_position: 1
+---
+
+# Basic Syntax
+## Declaration
+### Generic Class
+```CSharp
+public class Box<T>
+{
+    public T Value { get; set; }
+}
+```
+### Generic Method
+```CSharp
+public T Method<T>(T value)
+{
+    return value;
+}
+```
+### Generic Interface
+```CSharp
+public interface IRepository<T>
+{
+    T Get(int id);
+}
+```
+### Generic Constraints
+```CSharp
+public class Factory<T> where T : new()
+{
+    public T Create() => new T();
+}
+```
+
+:::tip
+- T is a type parameter (a placeholder)
+- `where T : new()` is a constraint, which restricts what kinds of types can be used
+:::
+
+## Constraint
+Generic constraints specify the requirements that a type parameter must satisfy. They allow the compiler to ensure that `T` supports certain operations, such as having a parameterless constructor, inheriting from a specific base class, or implementing an interface.
+
+Without constraints, the compiler cannot assume anything about `T`.
+
+## Basic Syntax
+
+```CSharp
+class MyClass<T> where T : ConstraintType
+{
+}
+```
+
+Multiple constraints can be combined:
+
+```CSharp
+class MyClass<T> where T : BaseClass, IInterface, new()
+{
+}
+```
+
+Constraint order must follow this pattern:
+
+1. class or struct  
+2. Base class  
+3. Interfaces  
+4. new()
+
+## Common Constraint Types
+
+### Reference type constraint
+
+```CSharp
+where T : class
+```
+
+### Value type constraint
+
+```CSharp
+where T : struct
+```
+
+### Parameterless constructor
+
+```CSharp
+where T : new()
+```
+
+### Inherit from a base class
+
+```CSharp
+where T : BaseClass
+```
+
+### Implement an interface
+
+```CSharp
+where T : IDisposable
+```
+
+## Why Constraints Are Needed
+
+### Calling members that may not exist
+
+```CSharp
+void CloseItem<T>(T item)
+{
+    item.Dispose(); // Cannot compile
+}
+```
+
+```CSharp
+void CloseItem<T>(T item) where T : IDisposable
+{
+    item.Dispose(); // ✔ Safe
+}
+```
+
+### Creating instances of T
+
+```CSharp
+class Factory<T>
+{
+    T Create() => new T(); // Not allowed
+}
+```
+
+```CSharp
+class Factory<T> where T : new()
+{
+    T Create() => new T(); // ✔ Allowed
+}
+```
+
+## Method-Level Constraints
+
+Constraints can also be applied to individual methods:
+
+```CSharp
+public void Save<T>(T item) where T : IEntity
+{
+    item.Store();
+}
+```
+
+## Summary
+
+- Constraints define what a type parameter must support.  
+- They ensure type safety for operations involving `T`.  
+- Common constraints include: class, struct, new(), base classes, and interfaces.

docs/CSharpDotNet/Generics/Basic-Syntax.md

@@ -0,0 +1,30 @@
+# Miscellaneous
+
+## System
+### `Nullable<T>` : (struct) enables value types to be null → `int?`, `bool?`
+
+## System.Threading.Tasks
+### `Task<T>` : (class) async operation returning `T`
+### `ValueTask<T>` : (struct) lightweight async return → reduces allocation
+### `TaskCompletionSource<T>` : (class) manually completes `Task<T>`
+
+## System.Lazy
+### `Lazy<T>` : (class) lazy-initialized value container
+
+## System.Tuple
+### `Tuple<T1, T2...>` : (class) legacy tuple type
+### `ValueTuple<T1, T2...>` : (struct) modern tuple type behind `(a, b, c)`
+
+## System.Memory
+### `Memory<T>` : (struct) sliceable, safe memory buffer
+### `ReadOnlyMemory<T>` : (struct) read-only memory slice
+### `Span<T>` : (ref struct) high-performance stack-only span
+### `ReadOnlySpan<T>` : (ref struct) read-only span
+
+## System.Buffers
+### `ArrayPool<T>` : (class) shared array pool → high-performance allocations
+### `MemoryPool<T>` : (class) pooled `Memory<T>` blocks
+### `IMemoryOwner<T>` : (interface) owner of pooled `Memory<T>`
+
+## System.IO / Array utilities
+### `ArraySegment<T>` : (struct) slice of an array without copying

docs/CSharpDotNet/Generics/ConcurrentCollections.md

@@ -0,0 +1,44 @@
+---
+title: System.Collections.Generic
+sidebar_position: 2
+---
+
+# `System.Collections.Generic`
+Core Generic Collections
+
+## `List<T>`
+Resizable dynamic array.  
+Fast random access (O(1)), append is amortized O(1).
+
+## `Dictionary<TKey, TValue>`
+Hash map (hash table).  
+Fast lookup/insert/delete average O(1).
+
+## `HashSet<T>`
+Unique-value collection (mathematical set).  
+Insert & lookup average O(1).
+
+## `Queue<T>`
+FIFO (First-In-First-Out) collection.
+
+## `Stack<T>`
+LIFO (Last-In-First-Out) collection.
+
+## `LinkedList<T>`
+Doubly linked list.  
+Efficient insertion/removal in the middle of the list.
+
+## `SortedList<TKey, TValue>`
+Sorted Key–Value pairs backed by *array*.  
+Good for smaller datasets.
+
+## `SortedDictionary<TKey, TValue>`
+Sorted Key–Value pairs backed by *red-black tree*.  
+Good for larger datasets.
+
+## `SortedSet<T>`
+Sorted unique elements.  
+Uses balanced tree (RB-tree).
+
+## `KeyValuePair<TKey, TValue>`
+Struct used when iterating `Dictionary<K, V>`.