C# Version Numbers Explained: C# vs .NET Framework and Why “C# 3.5” Is Incorrect

By the end of this page, you will understand the difference between C# language versions and .NET platform versions, why names like C# 3.5 are incorrect, and how developers correctly refer to language features by version. You will also see how C# versions are commonly discussed in documentation, codebases, and interviews.

C# has its own language version numbers, while the .NET ecosystem has platform and runtime version numbers such as .NET Framework 3.5, .NET Core 3.1, or .NET 8.

These are related, but they are not the same thing.

A common beginner mistake is to assume that if an application targets .NET Framework 3.5, then the language must be C# 3.5. That is not how C# is versioned.

For example:

• C# 1.0 was the original language release.
• C# 2.0 introduced generics, nullable value types, and iterators.
• C# 3.0 introduced LINQ, lambda expressions, anonymous types, and extension methods.
• .NET Framework 3.5 included support for many features associated with C# 3.0, especially LINQ-related libraries.

That is why people sometimes say C# 3.5 by mistake: they are mixing up the language version with the framework version.

Why this matters

Using the correct version number matters because:

• Documentation is organized by the real language version.
• Compiler feature support depends on the C# version, not just the framework name.
• Searching for the wrong term can lead to confusion or poor results.
• In team discussions, saying the correct version avoids misunderstandings.

A simple historical mapping

A simplified view looks like this:

The key lesson is: C# version numbers and .NET version numbers are separate numbering systems.

Think of C# and .NET like this:

• C# is the language you speak.
• .NET is the country or environment where that language is used.

A country can update its infrastructure without changing the language name, and a language can evolve even while being used in different environments.

So saying C# 3.5 is like mixing up the language with the place it is spoken. The more accurate statement is usually something like:

• "This project targets .NET Framework 3.5"
• "This code uses C# 3.0 features"

That keeps the language version and the platform version separate.

When discussing versions, developers usually write them like this:

C# 3.0
.NET Framework 3.5
C# 5.0
.NET 8

Correct terminology examples

This project targets .NET Framework 3.5.
This code uses C# 3.0 features such as lambda expressions.
The compiler is set to a newer C# language version.

Incorrect terminology examples

This is written in C# 3.5.
We need to upgrade from C# 4.5 to C# 4.8.

Those are incorrect because 3.5, 4.5, and 4.8 are commonly framework/runtime version numbers, not C# language version numbers.

Example of a C# 3.0-era feature

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

        var evenNumbers = numbers.Where(n => n % 2 == 0);

        foreach (var n in evenNumbers)
        {
            Console.WriteLine(n);
        }
    }
}

This code uses:

• var
• lambda expressions: n => n % 2 == 0
• LINQ: Where(...)

These are associated with C# 3.0, even though many developers used them in projects targeting .NET Framework 3.5.

That historical pairing is exactly why the version names often get mixed up.

Consider this example:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        List<string> names = new List<string> { "Ana", "Ben", "Chris" };

        var shortNames = names.Where(name => name.Length <= 3);

        foreach (var name in shortNames)
        {
            Console.WriteLine(name);
        }
    }
}

Here is what happens step by step:

1. names is created as a list containing "Ana", "Ben", and "Chris".
2. names.Where(...) applies a filter to the list.
3. The lambda name => name.Length <= 3 means:
   • take each name
   • check whether its length is 3 or less
4. shortNames stores the filtered sequence.
5. The foreach loop prints each matching name.
6. The output is:

Ana
Ben

Why is this example relevant?

Because features like var, lambdas, and LINQ are classic C# 3.0 features. Many people first met them while targeting .NET Framework 3.5, which led to the mistaken phrase C# 3.5.

Understanding C# version numbers is useful in many real situations:

Reading documentation

Microsoft docs and community articles often say things like:

• "introduced in C# 7"
• "available in C# 8 and later"
• "requires .NET 6"

If you confuse language and platform versions, it becomes hard to tell whether the limitation is from the compiler, the runtime, or the library.

Maintaining older applications

A company may have an app that targets:

• .NET Framework 3.5
• .NET Framework 4.8
• .NET 6

The code inside those apps may use different C# language features depending on compiler settings and toolchain support.

Job interviews and team communication

Saying:

• "This feature was added in C# 3.0"

is much clearer than saying:

• "I think it came in C# 3.5"

Search accuracy

If you search for:

• C# 3.5 lambda expressions

you may miss the best results, because most correct resources classify them under:

• C# 3.0 lambda expressions

In real projects, developers usually separate three different ideas:

• Target framework: what platform the app runs on
• Language version: what C# syntax/features the compiler allows
• Library availability: what APIs are available

Common ways this appears in projects

Project configuration

In modern SDK-style projects, you may see:

<PropertyGroup>
  <TargetFramework>net8.0</TargetFramework>
  <LangVersion>12.0</LangVersion>
</PropertyGroup>

This means:

• the app targets .NET 8
• the compiler should use C# 12 rules

These settings are related, but separate.

Feature discussions in code review

A reviewer might say:

• "This uses pattern matching from C# 7 or later."
• "This collection expression needs a newer language version."

They are talking about the language, not the framework.

Guarding against confusion in teams

Teams often write documentation like:

• "Target framework: .NET Framework 4.8"
• "Language version: latest major supported by our build"

This avoids the common mistake of combining them into one number.

Migration work

When upgrading an old codebase, developers often ask separate questions:

• Can we move from .NET Framework 4.6.1 to .NET 8?
• Can we start using C# 12 features?
• Do our libraries support the new platform?

Those are not all the same upgrade.

1. Mixing C# version with .NET Framework version

Broken idea:

Our codebase uses C# 3.5.

Better:

Our project targets .NET Framework 3.5 and uses C# 3.0 features.

2. Assuming a framework version automatically tells you the exact language version

This is not always safe, especially in modern .NET projects. Tooling and compiler configuration matter.

3. Searching for the wrong version term

Searching for:

C# 3.5 extension methods

may be less useful than:

C# 3.0 extension methods

4. Confusing libraries with language features

For example:

• LINQ syntax support is tied to C# 3.0 language features.
• LINQ APIs are also tied to available framework libraries.

You often need both the language support and the library support.

5. Thinking version numbers always move together

They do not.

For example, a project can target one .NET version while using a separately configured C# language version.

6. Using imprecise wording in documentation

Broken wording:

Upgrade the app from C# 4.6 to C# 4.8.

Correct wording:

Upgrade the app from .NET Framework 4.6 to .NET Framework 4.8.

or, if you mean the language:

Enable a newer C# language version in the project.

Quick comparison

• C# version answers: "What syntax and language features can I use?"
• .NET version answers: "What platform/runtime and APIs am I targeting?"
• Project configuration answers: "What does this specific build allow?"

Quick rules

• C# version = language version
• .NET Framework / .NET / .NET Core version = platform/runtime version
• C# 3.5 is not a correct language version name
• The correct historical term is usually C# 3.0 with .NET Framework 3.5

Common examples

Correct: C# 3.0
Correct: .NET Framework 3.5
Correct: C# 5.0
Correct: .NET 8
Incorrect: C# 3.5
Incorrect: C# 4.8

Historical shorthand

Useful phrasing

This app targets .NET Framework 3.5.
This feature was introduced in C# 3.0.
This project uses C# 10.

Remember

If you are discussing:

• syntax
• compiler features
• language constructs

then use the C# version.

If you are discussing:

• runtime
• target framework
• available APIs

then use the .NET version.

Why is “C# 3.5” wrong?

Because 3.5 refers to .NET Framework 3.5, not an official C# language version. The language version commonly associated with that period is C# 3.0.

Is C# version the same as .NET version?

No. C# is the language, while .NET is the platform/runtime ecosystem.

Did .NET Framework 3.5 include C# 3.0 features?

Yes, that era is strongly associated with C# 3.0 features such as LINQ, lambda expressions, and extension methods. That association is one reason people say C# 3.5 by mistake.

How should I refer to an old project correctly?

Say something like: "This project targets .NET Framework 3.5 and uses C# 3.0 features."

Can a project use a newer C# version than its target framework suggests?

Sometimes yes, depending on compiler support, tooling, and whether the features require runtime or library support.

When searching online, should I search by C# version or .NET version?

Search by C# version for syntax/language features, and by .NET version for runtime, compatibility, deployment, or API questions.

What is the main thing to remember?

Do not combine the language and framework numbers into a fake version such as C# 3.5.

• C# language features — Version numbers are mainly used to describe when language features were introduced.
• .NET Framework — This is the platform version often confused with C# versions.
• .NET Core — A later .NET platform with separate release numbering.
• Modern .NET — Current unified .NET versions such as .NET 6, 7, and 8.
• Compiler — The compiler enforces which C# language version is available.
• LangVersion — Project setting that controls the selected C# language version.
• LINQ — A major feature set often associated with C# 3.0 and the .NET Framework 3.5 era.
• Target Framework Moniker (TFM) — The formal way projects specify what .NET platform they target.