C# — Beginner
Build real C# from your first program to working applications: variables, control flow, methods, collections, classes, LINQ, files, exceptions, and an introduction to async — every step practiced and graded in a sandbox running the real .NET SDK.
Who this course is for
Absolute beginners and developers from other languages who want a rigorous, practice-first start in C# and .NET.
What you will be able to do
- Read and write idiomatic modern C# with confidence
- Model data with classes, records, and collections
- Debug and test C# programs systematically
- Use LINQ and the core .NET libraries productively
- Build and persist small real applications
Hello, C#
Meet C# and .NET, write and run your first programs, and learn how Code Journey grades what you write.
Variables and Types
Declare, initialize, and convert the core C# types — and learn when the compiler is saving you from yourself.
Input, Output, and Parsing
Turn text in, numbers out: ReadLine, Parse vs TryParse, and validation that refuses garbage politely.
Operators, Conditions, Loops
Make decisions and repeat work: comparison and logic operators, if/switch patterns, and every loop shape.
Methods
Name a computation once, call it everywhere: declarations, parameters, overloads, and the discipline of small methods.
Strings and Characters
Text is data: indexing and iterating strings, the core string API, and char-level work with its conversion traps.
Arrays
Fixed-size, typed collections: declare, iterate, copy, search, and sort — plus the aliasing trap that starts every reference-type discussion.
Collections
Lists, dictionaries, and sets: dynamic containers, key-value lookups, uniqueness — and when each is the right shape.
Classes and Objects
Grouping state and behavior: fields, constructors, and properties — the vocabulary of every C# program.
Object-Oriented Programming
Inheritance, virtual methods, and interfaces: how C# types share behavior and swap implementations behind a contract.
Enums, Records, and Data Modeling
Fixed option sets, value-shaped data, and the class/struct/record decision — modeling domain data honestly.
Generics
Type parameters: writing an algorithm once and letting the compiler stamp it out for every type — safely.
Exceptions and Error Handling
Failures as typed events: throw when a contract breaks, catch when you can actually handle it — and let the rest bubble.
Files and Persistence
Program state that survives the process: Path, File, and Directory — plus the disposal rule that keeps handles honest.
LINQ Fundamentals
Queries as method calls: filter, project, order, group, aggregate — and the deferred-execution rule that surprises everyone once.
Delegates, Lambdas, and Events
Methods as values: Func and Action, lambda syntax, and the publisher-subscriber pattern behind every UI framework.
Debugging and Testing
Turn failures into information: read the error, isolate the bug, and pin the fix with an executable test.
.NET Project Structure and CLI
From single files to real projects: .csproj anatomy, the dotnet CLI verbs, and how solutions bind projects together.
Git and Professional Workflow
The commit graph as a data structure: branches, merges, ignores, and the hygiene that makes a history readable.
Problem Solving and Algorithms
Reasoning about growth, searching honestly, and the two loop shapes that solve most problems: frequency maps and recursion.
Beginner Capstone
One domain, every tool: model transactions, validate them, aggregate them, and produce a statement — the shape of every real C# program.