🍿 CornPop

C# MOC

6 min read

Phase 0: Setting the Stage (Conceptual Background)

Goal: Understand the “why” and “where” of C# before diving into syntax.

Topics:

Phase 1: C# Fundamentals (Core Syntax and Building Blocks)

Goal: Write basic C# programs, understand variables, data flow, and simple logic.

First Steps:

  • Intro
    • Your first program, basic structure.
  • [[Cs Output|Output]]
    • Console.WriteLine etc.
  • [[Cs Comments|Comments]]
    • Documenting your code.
  • [[Cs Input|Input]]
    • Console.ReadLine etc.

Data & Variables:

  • [[Cs Value and Reference Types|Value and Reference Types]]
    • Crucial Foundational Concept.
  • [[Cs Data Types|Data Types]]
    • Built-in types: int, float, bool, char, etc.
  • [[Cs Data Types Storage and sign|Data Types Storage]]
    • Understanding memory, range, signed/unsigned.
  • [[Cs Variables|Variables]]
    • Declaration, initialization, scope.
  • [[Cs String|String]]
    • Working with text, immutability.
  • [[Cs Operators|Operators]]
    • Arithmetic, Logical, Comparison, Assignment, etc.
  • [[Cs Type Casting|Type Casting]]
    • Implicit vs. Explicit conversions.
    • [[Cs as|As Keyword]] - Safe casting for reference types.
  • [[Cs Null|Null and Nullable Types]]
    • Handling the absence of a value, ? syntax.
    • [[Cs Protective code|Protective code]] - Null checks, null-coalescing ??, null-conditional ?..

Control Flow:

  • [[Cs Control Flow Statements|If, Switch, For, While and more]]
    • Conditional logic and looping: if-else, switch, for, foreach, while, do-while, break, continue.
  • [[Cs Switch case vs Switch|Switch case vs Switch]]
    • Classic vs. pattern matching switch expressions.
  • [[Cs is|Is Keyword]]
    • Type checking, often used with if and switch.

Methods (Functions):

  • [[Cs Function|Methods]]
    • Using the C# term “Method”. Defining and calling reusable blocks of code.
  • [[Cs Pass parameters|How to Pass Parameters]]
    • By value, ref, out, in.
  • [[Cs params Keyword|Params Keyword]]
    • Methods accepting variable arguments.

Basic Data Structures:

  • [[Cs Arrays|Arrays]]
    • Fixed-size, indexed collections.
  • [[Cs Lists|Lists (Generic Lists)]]
    • List<T> - dynamic-size, typed collections. Preferred over ArrayList.
  • [[Cs Dictionary|Dictionary]]
    • Dictionary<TKey, TValue> - key-value pair collections.
  • [[Cs ArrayList|ArrayList]]
    • Mention its existence and why List<T> is generally better (non-generic, potential boxing).

Error Handling & Resource Management:

  • [[Cs Handle Exception|Handle Exception]]
    • try-catch-finally blocks.
  • [[Cs Using|Using Statement]]
    • Ensuring Dispose is called for resource cleanup (IDisposable).

Basic File I/O:

  • [[Cs Files|Files]]
    • Reading from and writing to files using System.IO.

Phase 2: Object-Oriented Programming (OOP) in C#

Goal: Design and implement applications using classes, objects, and OOP principles.

OOP Concepts Recap:

  • [[OOP]] at General (Review the four pillars if needed)
    • [[Encapsulation]]
    • [[Abstraction]]
    • [[Inheritance]]
    • [[Polymorphism]]

Core OOP Constructs:

  • [[Cs Class|Class]]
    • The blueprint for objects.
  • [[Cs System.Object|Object]]
    • The ultimate base class.
  • [[Cs Constructor|Constructor]]
    • Initializing objects, constructor chaining, this keyword.
  • [[Cs Access Modifiers|Access Modifiers]]
    • public, private, protected, internal, protected internal, private protected.
  • [[Cs Properties|Properties]]
    • Controlled access to class data - Getters/Setters, auto-properties.
  • [[Cs Static|Static]]
    • Static members vs. Instance members.
  • [[Cs Struct|Struct]]
    • User-defined value types - contrast with classes.
  • [[Cs Enums|Enum]]
    • Named constants.
  • [[Cs Boxing and Unboxing|Boxing and Unboxing]]
    • Converting between value types and object/interfaces.

Implementing the Pillars in C#:

  • Encapsulation:
    • [[Cs Encapsulation]]
    • Achieved via access modifiers, properties.
    • [[Cs Indexer|Indexer]] - Accessing objects like arrays.
  • Inheritance:
    • [[Cs Inheritance]]
    • Base classes, derived classes, base keyword.
  • Polymorphism:
    • [[Cs Polymorphism]]
    • virtual, override, new (hiding), abstract methods/classes.
    • [[Cs Operator Overloading]] - Customizing operators for your types.
    • [[Cs Casting Operator]] - Defining custom explicit/implicit conversions.
  • Abstraction:
    • [[Cs Abstraction]]
    • Abstract classes vs. Interfaces.
    • [[Cs Interface|Interface]] - Defining contracts.

Advanced Class Concepts:

  • [[Cs Sealed|Sealed]]
    • Preventing inheritance/overriding.
  • [[Cs Partial Class|Partial Class]]
    • Splitting a class definition across files.

Object Behavior & Relationships:

  • [[Cs Shallow and deep copy|Shallow and deep copy]]
    • Copying objects, especially relevant with reference types.
  • [[Cs Equality|Equality]]
    • Reference vs. Value equality, overriding Equals() and GetHashCode().
  • [[Cs Binding|Binding]]
    • Static (compile-time) vs. Dynamic (runtime) binding.

Working with Interfaces:

  • [[Cs IEnumerable|IEnumerable]] & IEnumerator
    • The iteration pattern, enabling foreach.
  • [[Cs ICloneable|ICloneable Interface]]
    • Standard way for cloning - note caveats.
  • [[Cs ICompareable|IComparable Interface]] & IComparer
    • Standard ways for comparison/sorting.
  • [[IEnumerable vs IQueryable vs ICollection]]
    • Understanding different collection interface capabilities.
  • [[IEnumerable vs IReadOnlyList]]
    • Read-only collection perspectives.

Phase 3: Intermediate C# & Key .NET APIs

Goal: Utilize more advanced C# features, leverage powerful .NET libraries, and write more efficient/expressive code.

Topics:

  • [[Cs StringBuilder]]
    • Efficient string manipulation for multiple changes.
  • [[Cs Generics]]
    • Fundamental. Type-safe reusable code: Generic classes, methods, interfaces, constraints.
  • [[Cs Extension Methods|Extension Methods]]
    • Adding methods to existing types without modifying them.
  • [[Cs Delegates|Delegates]]
    • Type-safe function pointers - foundation for events and LINQ.
  • [[Cs Lambda Expressions|Lambda Expressions]]
    • Concise anonymous functions - used heavily with delegates, LINQ, async.
  • [[Cs Event]]
    • Implementing the publish-subscribe pattern.
  • LINQ (Language Integrated Query): (Essential Added Topic)
    • [[LINQ Query vs Method Syntax|Query Syntax vs. Method Syntax]]
    • [[LINQ Standard Query Operators|Standard Query Operators]] (Filtering, Projection, Ordering, Grouping, Joining, Aggregation)
    • [[LINQ Deferred Execution|Deferred Execution]]
    • [[LINQ IQueryable vs IEnumerable|IQueryable vs IEnumerable]] (Especially in context of LINQ to SQL/EF)
  • [[Cs Regex|Regex]]
    • Advanced pattern matching for strings.
  • Attributes & Reflection: (Important Added Topics)
    • [[Attributes]]
      • Adding metadata to code.
    • [[Reflection]]
      • Inspecting types and members at runtime.

Phase 4: Advanced C# & Asynchronous Programming

Goal: Tackle complex scenarios, concurrency, and performance optimization.

Topics:

  • [[Cs Recursion|Recursion]]
    • Solving problems by breaking them into smaller, self-similar problems.
  • Asynchronous Programming:
    • [[Cs Multithreading Basics]]
      • Concepts: Threads, ThreadPool, Race Conditions, Locking (lock), Monitor.
    • [[Cs Task-Based Asynchronous Pattern]]
      • async / await, Task, Task<TResult> - the modern standard.
    • [[SynchronizationContext]]
      • Understanding context switching in async operations.
  • Further Exploration (Depending on Need):
    • [[Garbage Collection Deep Dive|Garbage Collection]]
      • Deeper understanding of memory management.
    • [[Memory Management and IDisposable|Memory Management & IDisposable]]
      • Advanced resource management, SafeHandle.
    • [[Dependency Injection|Dependency Injection (DI)]]
      • Using DI frameworks.
    • [[Advanced Debugging]]
      • Advanced techniques and tools.
    • [[Platform Invoke (PInvoke)|P/Invoke]] & [[COM Interop]]
      • Interacting with native code.
    • [[Unsafe Code]]
      • Working with pointers (use with caution).

Phase 5: Practice & Resources

Goal: Solidify knowledge through application.

Resources:

Graph View

Backlinks