History of C# & .NET
Trace C# and .NET from their origins at Microsoft through the shift to open-source, cross-platform .NET.
Origins: Why Microsoft Built C#
In the late 1990s, Microsoft found itself in an awkward position. Its flagship application language was C++ — powerful, but notoriously easy to shoot yourself in the foot with (manual memory management, pointer arithmetic, buffer overruns). Meanwhile, Sun Microsystems' Java was rapidly winning over enterprise developers with automatic memory management and "write once, run anywhere" portability, and Microsoft had no real answer to it.
Microsoft had actually tried to extend its reach into the Java world with a customized version called "J++", but a lawsuit from Sun over licensing violations shut that effort down in 1997 — indirectly clearing the path for Microsoft to build its own language from scratch instead of extending someone else's. A team led by Anders Hejlsberg (who had previously designed the hugely popular Turbo Pascal and Delphi languages/tools at Borland) began work on a new language and a new runtime platform to go with it, under the internal codename "Project 42" (a Hitchhiker's Guide to the Galaxy reference) and later "Cool" (C-like Object-Oriented Language).
C# 1.0 and the original .NET Framework were officially unveiled to the public in June 2000 at Microsoft's Professional Developers Conference, and released to the public in January 2002, alongside Visual Studio .NET — Microsoft's answer to both C++'s safety problems and Java's growing dominance.
Anders Hejlsberg openly credited Java as a major influence on early C#, while also pointing out specific design choices he disagreed with (like Java's lack of operator overloading and unsigned integer types) — early C# was explicitly positioned as "what Java could have been, with a few corrections."
The .NET Framework Era (2002–2016)
For over a decade, ".NET" meant the .NET Framework — a powerful, mature, but Windows-only platform. This was the era when C# and .NET built their reputation in enterprise software, powering an enormous share of internal business applications, intranets, and Windows desktop software across corporate America and beyond.
C# itself grew substantially during this period, with the language design team adding features roughly every 2-3 years to keep pace with (and sometimes get ahead of) the industry.
C# Language Evolution, Version by Version
| Version | Year | Landmark Feature(s) |
|---|---|---|
| C# 1.0 | 2002 | The original language — classes, interfaces, delegates, basic OOP. |
| C# 2.0 | 2005 | Generics — type-safe collections without boxing every value into object. |
| C# 3.0 | 2007 | LINQ, lambda expressions, extension methods, anonymous types, var — arguably the biggest single leap in the language's history. |
| C# 4.0 | 2010 | The dynamic keyword, named/optional parameters, improved COM interop. |
| C# 5.0 | 2012 | async/await — transformed how asynchronous code is written, from callback-heavy to nearly synchronous-looking. |
| C# 6.0 | 2015 | String interpolation ($"..."), expression-bodied members, the null-conditional operator (?.). |
| C# 7.0 | 2017 | Tuples, pattern matching (is/switch), local functions, out variables. |
| C# 8.0 | 2019 | Nullable reference types, default interface members, switch expressions. |
| C# 9.0 | 2020 | Records, top-level statements, init-only setters — released alongside .NET 5. |
| C# 10–12 | 2021–2023 | Global usings, required members, primary constructors, collection expressions. |
C# 3.0's LINQ (Language Integrated Query) was so influential that it directly inspired similar query-syntax features added later to other languages and libraries — it remains one of the most distinctive, beloved features of C# to this day, and you'll get a full dedicated lesson on it later in this course.
The Shift to Open Source
In November 2014, Microsoft — under new CEO Satya Nadella, who had recently taken over and begun steering the company toward a more open, cross-platform strategy — made a landmark announcement that surprised much of the industry: the .NET runtime, along with the C# compiler itself (codenamed "Roslyn"), would be fully open-sourced and rebuilt from the ground up to run natively on Linux and macOS, not just Windows.
This effort became .NET Core, whose first stable version (1.0) shipped in June 2016. It was, in engineering terms, essentially a parallel rewrite: a smaller, modular, high-performance runtime built to run identically across operating systems, sitting alongside (not immediately replacing) the older .NET Framework, which continued to receive security patches but few new features.
This shift opened .NET to cloud-native development, Docker containers, and Linux servers — environments where the old Windows-only .NET Framework simply couldn't compete, and where the vast majority of the modern cloud (including a large share of Azure itself) actually runs.
Miguel de Icaza's independent open-source Mono project had already been running C#/.NET-compatible code on Linux and macOS since the early 2000s, years before Microsoft's own official cross-platform push — Mono's work (and the Xamarin company built around it) was eventually acquired by Microsoft in 2016 and folded directly into official .NET, rather than staying an unofficial workaround.
Modern .NET (2020–Present)
With .NET 5 in November 2020, Microsoft deliberately dropped the "Core" branding — there was no longer a separate "real" .NET Framework to distinguish it from, since .NET Framework 4.8 (released 2019) was declared its final version, receiving only security fixes from then on. .NET 5 unified .NET Framework, .NET Core, and Xamarin into one platform, simply called ".NET".
Notice there is no ".NET 4" in this modern lineage — Microsoft deliberately skipped that version number specifically to avoid confusion with the older ".NET Framework 4.x" line, jumping straight from ".NET Core 3.1" to ".NET 5".
Since 2020, a new major version has shipped every November like clockwork, with even-numbered releases (.NET 6, .NET 8, .NET 10) marked as Long Term Support (LTS), receiving three years of support, while odd-numbered releases (.NET 7, .NET 9) are "Standard Term Support," receiving 18 months.
Timeline
Release Cadence & LTS Explained
Understanding .NET's release rhythm is genuinely useful for real project decisions, not just trivia — choosing which version to target has real consequences for how long you get security updates.
LTS (Even Numbers: 6, 8, 10...)
- 3 years of official support
- The safe default for most production apps
- Fewer forced upgrades over a project's lifetime
STS (Odd Numbers: 7, 9, 11...)
- 18 months of support
- Good for trying new features early
- Requires upgrading sooner to stay supported
Teams sometimes accidentally build a new production app on a Standard Term Support version (like .NET 7) simply because it was the newest at the time, not realizing it will stop receiving security patches over a year sooner than the LTS release right next to it — always check a version's support end date before committing a serious project to it.
Common Beginner Mistakes
".NET Core" was retired as a brand name starting with .NET 5 in 2020 — modern documentation and job listings simply say ".NET" or a specific version like ".NET 8".
There is no single "final" C# version — new language features ship essentially every year, tied to each new .NET release.
Xamarin was the older, separate cross-platform mobile framework; .NET MAUI (Multi-platform App UI) is its official, modern successor, fully merged into unified .NET.
FAQs
It's in maintenance mode, not actively developed further, but Microsoft has committed to supporting it as long as it ships with Windows — it's "dead" only in the sense that all new feature development happens on modern, cross-platform .NET instead.
C# language design happens fully in the open on GitHub (the dotnet/csharplang repository), through public proposals, community discussion, and a small core Language Design Team at Microsoft that makes final calls — anyone can read the design meeting notes.
To avoid confusion with the pre-existing ".NET Framework 4.x" line — jumping to "5" made it immediately clear this was a distinct, new, unified platform rather than a continuation of the old Framework numbering.
Modern .NET (the current LTS version) — .NET Framework is only relevant if you're specifically maintaining a legacy application that hasn't migrated yet, which this course does not cover.
If you stay on LTS versions, roughly every 2-3 years is typical for a well-maintained production app, timed around when the current LTS approaches its support end date.
Key Takeaways
- C# and .NET Framework launched in 2002, Windows-only, partly as Microsoft's answer to Java and the limitations of C++.
- .NET Core (2016) was a from-scratch, open-source rebuild enabling Linux/macOS support, running alongside the old .NET Framework for years.
- .NET 5 (2020) unified .NET Framework, .NET Core, and Xamarin under one modern ".NET" umbrella, dropping the "Core" name entirely.
- C# itself has evolved continuously — LINQ (2007) and async/await (2012) are widely considered its two most transformative additions.
- Even-numbered .NET versions get 3 years of LTS support; odd-numbered versions get 18 months — this matters for real production decisions.
Summary
C#/.NET's history is a story of a Windows-only enterprise platform reinventing itself into a fully open-source, cross-platform, continuously evolving ecosystem — a transformation few competing platforms have pulled off as successfully. Next, you'll tour the pieces of the modern .NET ecosystem you'll actually be using throughout this course.