Quais são os números de versão corretos para C #? O que saiu quando? Por que não consigo encontrar respostas sobre o C # 3.5 ?

Esta pergunta é principalmente para ajudar aqueles que estão procurando uma resposta usando um número de versão incorreto, por exemplo, C # 3.5 . A esperança é que alguém que não encontre uma resposta com o número de versão errado encontre essa pergunta e pesquise novamente com o número de versão correto.

Histórico de versão do idioma C #:

Estas são as versões do C # conhecidas no momento em que este artigo foi escrito:

• C # 1.0 lançado com .NET 1.0 e VS2002 (janeiro de 2002)
• C # 1.2 (estranhamente); lançado com .NET 1.1 e VS2003 (abril de 2003). Primeira versão a chamada Disposeno IEnumerators quais implementadas IDisposable. Alguns outros pequenos recursos.
• C # 2.0 lançado com o .NET 2.0 e o VS2005 (novembro de 2005). Principais novos recursos: genéricos, métodos anônimos, tipos anuláveis, blocos de iteradores
• C # 3.0 lançado com o .NET 3.5 e o VS2008 (novembro de 2007). Principais novos recursos: expressões lambda, métodos de extensão, árvores de expressão, tipos anônimos, digitação implícita (var ), expressões de consulta
• C # 4.0 lançado com o .NET 4 e o VS2010 (abril de 2010). Principais novos recursos: ligação tardia ( dynamic), variação genérica de delegação e interface, mais suporte a COM, argumentos nomeados, tipo de dados de tupla e parâmetros opcionais
• C # 5.0 lançado com o .NET 4.5 e o VS2012 (agosto de 2012). Principais recursos : programação assíncrona, atributos de informações do chamador. Mudança de ruptura: fechamento variável do loop .
• C # 6.0 lançado com o .NET 4.6 e VS2015 (julho de 2015). Implementado por Roslyn . Características : initializers para propriedades implementadas automaticamente, usando diretivas para importar membros estáticos, filtros de exceção, initializers elemento, awaitem catche finally, extensão Addmétodos em inicializadores de coleção.
• C # 7.0 lançado com .NET 4.7 e VS2017 (março de 2017). Principais novos recursos : tuplas , refs locais e ref retorno , correspondência de padrões (incluindo instruções de chave com base em padrões), declarações de parâmetros em linhaout , funções locais , literais binários, separadores de dígitos e retornos assíncronos arbitrários .
• C # 7.1 lançado com o VS2017 v15.3 (agosto de 2017) Novos recursos: principal assíncrono , inferência de nome de membro da tupla , expressão padrão , correspondência de padrão com genéricos .
• C # 7.2 lançado com o VS2017 v15.5 (novembro de 2017) Novos recursos: modificador de acesso protegido privado , Span <T>, aka ponteiro interno, aka stackonly struct , tudo mais .
• C # 7.3 lançado com o VS2017 v15.7 (maio de 2018). Novos recursos: enumeração, delegação e unmanagedrestrições de tipo genérico . refreatribuição. Melhorias inseguras: stackallocinicialização, fixedbuffers indexados não fixados , fixedinstruções personalizadas . Resolução de sobrecarga aprimorada. Variáveis ​​de expressão em inicializadores e consultas. ==e !=definido para tuplas. Os campos de apoio das propriedades automáticas agora podem ser segmentados por atributos.
• C # 8.0 lançado com .Net Core 3.0 e VS2019 v16.3 (setembro de 2019). Principais novos recursos : tipos de referência anuláveis , fluxos assíncronos , índices e intervalos , membros somente leitura , usando declarações , métodos de interface padrão , funções locais estáticas e aprimoramento de seqüências verbais interpoladas .
• O C # 9.0 ainda está em pré-visualização. Previsto para ser lançado em novembro de 2020, juntamente com o .Net 5 . Principais novos recursos : propriedades somente init, registros, com expressões, classes de dados, registros posicionais, programas de nível superior, correspondência de padrões aprimorada (padrões de tipo simples, padrões relacionais, padrões lógicos), digitação de destino aprimorada ( newexpressões de tipo de destino , alvo digitado ??e ?), retornos covariantes. Recursos secundários: ordem de relaxamento refe partialmodificadores, verificação de nulo de parâmetro, parâmetros de descarte lambda, ints nativos , atributos em funções locais, ponteiros de função, lambdas estáticas, extensão GetEnumerator, inicializadores de módulo, extensão parcial.

Em resposta à pergunta do OP:

Quais são os números de versão corretos para C #? O que saiu quando? Por que não consigo encontrar respostas sobre o C # 3.5?

Não existe C # 3.5 - a causa da confusão aqui é que o C # 3.0 está presente no .NET 3.5. A linguagem e a estrutura são versionadas independentemente, no entanto - como é o CLR, que está na versão 2.0 para .NET 2.0 a 3.5, .NET 4 que introduz o CLR 4.0, service packs, não obstante. O CLR no .NET 4.5 possui várias melhorias, mas o controle de versão não é claro: em alguns lugares, pode ser chamado de CLR 4.5 ( esta página do MSDN costumava se referir a ela dessa maneira, por exemplo), mas a Environment.Versionpropriedade ainda reporta 4.0. xxx.

Em 3 de maio de 2017, a equipe de idiomas do C # criou um histórico de versões e recursos de C # em seu repositório GitHub: Recursos adicionados nas versões de idiomas do C # . Há também uma página que rastreia os recursos de idioma futuros e implementados recentemente .

É o mesmo que a maioria das respostas aqui, mas tabularizadas para facilitar, e possui versões do Visual Studio e .NET para garantir a integridade.

╔════════════╦════════════╦══════════════╦═════════════╦══════════════╗
║ C# version ║ VS version ║ .NET version ║ CLR version ║ Release date ║
╠════════════╬════════════╬══════════════╬═════════════╬══════════════╣
║    1.0     ║    2002    ║    1.0       ║     1.0     ║   Feb 2002   ║
║    1.2     ║    2003    ║    1.1       ║     1.1     ║   Apr 2003   ║
║    2.0     ║    2005    ║    2.0       ║     2.0     ║   Nov 2005   ║
║            ║            ║    3.0       ║     2.0     ║   Nov 2006   ║
║    3.0     ║    2008    ║    3.5       ║     2.0     ║   Nov 2007   ║
║    4.0     ║    2010    ║    4.0       ║     4       ║   Apr 2010   ║
║    5.0     ║    2012    ║    4.5       ║     4       ║   Aug 2012   ║
║    5.0     ║    2013    ║    4.5.1     ║     4       ║   Oct 2013   ║
║            ║            ║    4.5.2     ║     4       ║   May 2014   ║
║    6.0     ║    2015    ║    4.6       ║     4       ║   Jul 2015   ║
║            ║            ║    4.6.1     ║     4       ║   Nov 2015   ║
║            ║            ║    4.6.2     ║     4       ║   Aug 2016   ║
║    7.0     ║    2017    ║              ║             ║   Mar 2017   ║
║            ║            ║    4.7       ║     4       ║   May 2017   ║
║    7.1     ║ 2017(v15.3)║              ║             ║   Aug 2017   ║
║            ║            ║    4.7.1     ║     4       ║   Oct 2017   ║
║    7.2     ║ 2017(v15.5)║              ║             ║   Dec 2017   ║
║            ║            ║    4.7.2     ║     4       ║   Apr 2018   ║
║    7.3     ║ 2017(v15.7)║              ║             ║   May 2018   ║
║    8.0     ║    2019    ║    4.8       ║     4       ║   Apr 2019   ║    
╚════════════╩════════════╩══════════════╩═════════════╩══════════════╝

Nota: Atualmente, o desenvolvimento do .NET é praticamente independente do VS, não há correlação entre as versões de cada um.
Consulte " Versões e dependências do .NET Framework " para obter mais informações.

O maior problema ao lidar com os números de versão do C # é o fato de ele não estar vinculado a uma versão do .NET Framework, o que parece dever-se às liberações sincronizadas entre o Visual Studio e o .NET Framework.

A versão do C # está realmente vinculada ao compilador, não à estrutura. Por exemplo, no Visual Studio 2008, você pode escrever C # 3.0 e direcionar o .NET Framework 2.0, 3.0 e 3.5. A nomenclatura C # 3.0 descreve a versão da sintaxe do código e os recursos suportados da mesma maneira que ANSI C89, C90, C99 descreve a sintaxe do código / recursos para C.

Dê uma olhada no Mono e você verá que o Mono 2.0 (versão 2.0 do .NET Framework implementada principalmente nas especificações da ECMA) oferece suporte à sintaxe e aos recursos do C # 3.0.

• C # 1.0 com o Visual Studio.NET

• C # 2.0 com o Visual Studio 2005

• C # 3.0 com o Visual Studio 2008

• C # 4.0 com o Visual Studio 2010

• C # 5.0 com Visual Studio 2012

• C # 6.0 com o Visual Studio 2015

• C # 7.0 com Visual Studio 2017

• C # 8.0 com o Visual Studio 2019

VERSÃO_____ ESPECIFICAÇÃO DO ______COMPUTADOR MICROSOFT

C # 1.0 / 1.2 de____ dezembro de 2001 ^? / 2003 ^? ___________Janeiro de 2002 ^?

C # 2.0 _______setembro de 2005________________ novembro de 2005 ^?

C # 3.0 _______maio de 2006_____________________ novembro de 2006 ^?

C # 4.0 _______março de 2009 (rascunho)______________ abril de 2010 ^?

C # 5.0; lançado com o .NET 4.5 em agosto de 2012

C # 6.0; lançado com o .NET 4.6 2015

C # 7.0; lançado com o .NET 4.7 2017

C # 8.0; lançado com o .NET 4.8 2019

Histórico de versões em C #:

C # é uma linguagem de programação simples e poderosa, orientada a objetos, desenvolvida pela Microsoft.

O C # evoluiu muito desde seu primeiro lançamento em 2002. O C # foi introduzido com o .NET Framework 1.0.

A tabela a seguir lista os recursos importantes introduzidos em cada versão do C #.

E a versão mais recente do C # está disponível nas versões do C # .

1 :

Resumi a maioria das versões nesta tabela. Os únicos ausentes devem ser as versões do ASP.NET Core. Também adicionei versões diferentes do ASP.NET MVC.

Observe que o ASP.NET 5 foi renomeado como ASP.NET Core 1.0 e ASP.NET MVC 6 foi renomeado como ASP.NET Core MVC 1.0.0. Acredito que essa alteração ocorreu por volta de janeiro de 2016.

Incluí a data de lançamento do ASP.NET 5 RC1 na tabela, mas ainda não incluí o ASP.NET core 1.0 e outras versões principais, porque não consegui encontrar as datas exatas de lançamento. Você pode ler mais sobre as datas de lançamento do ASP.NET Core aqui: Quando o ASP.NET Core 1.0 (ASP.NET 5 / vNext) está programado para lançamento?

Você pode verificar as versões mais recentes do C # aqui

Comparando os artigos do MSDN "O que há de novo no idioma e compilador C # 2.0" e " O que há de novo no Visual C # 2005 ", é possível deduzir que "C # major_version.minor_version" é cunhado de acordo com a numeração da versão do compilador.

Há C # 1.2 correspondente ao .NET 1.1 e VS 2003 e também chamado Visual C # .NET 2003 .

Mais adiante, porém, a Microsoft parou para incrementar os números da versão menor (depois do ponto) ou para tê-los além de zero 0,. Embora seja necessário observar que o C # correspondente ao .NET 3.5 é nomeado em msdn.microsoft.com como "Visual C # 2008 Service Pack 1" .

Existem duas nomeações paralelas: por numeração de versão principal do .NET / compilador e por numeração do Visual Studio.

C # 2.0 é sinônimo de Visual C # 2005

O C # 3.0 corresponde (ou, mais corretamente, pode ser direcionado) a:

• Visual C # 2005 do .NET 2.0
• .NET3.0 <==> Visual C # 2008
• .NET 3.5 <==> Visual C # 2008 Service Pack 1

C # 1.0 - Visual Studio .NET 2002

Classes
Structs
Interfaces
Events
Properties
Delegates
Expressions
Statements
Attributes
Literals

C # 1.2 - Visual Studio .NET 2003

Dispose in foreach
foreach over string specialization
C# 2 - Visual Studio 2005
Generics
Partial types
Anonymous methods
Iterators
Nullable types
Getter/setter separate accessibility
Method group conversions (delegates)
Static classes
Delegate inference

C # 3 - Visual Studio 2008

Implicitly typed local variables
Object and collection initializers
Auto-Implemented properties
Anonymous types
Extension methods
Query expressions
Lambda expression
Expression trees
Partial methods

C # 4 - Visual Studio 2010

Dynamic binding
Named and optional arguments
Co- and Contra-variance for generic delegates and interfaces
Embedded interop types ("NoPIA")

C # 5 - Visual Studio 2012

    Asynchronous methods
    Caller info attributes

C # 6 - Visual Studio 2015

Draft Specification online
Compiler-as-a-service (Roslyn)
Import of static type members into namespace
Exception filters
Await in catch/finally blocks
Auto property initializers
Default values for getter-only properties
Expression-bodied members
Null propagator (null-conditional operator, succinct null checking)
String interpolation
nameof operator
Dictionary initializer

C # 7.0 - Visual Studio 2017

Out variables
Pattern matching
Tuples
Deconstruction
Discards
Local Functions
Binary Literals
Digit Separators
Ref returns and locals
Generalized async return types
More expression-bodied members
Throw expressions

C # 7.1 - Visual Studio 2017 versão 15.3

Async main
Default expressions
Reference assemblies
Inferred tuple element names
Pattern-matching with generics

C # 7.2 - Visual Studio 2017 versão 15.5

Span and ref-like types
In parameters and readonly references
Ref conditional
Non-trailing named arguments
Private protected accessibility
Digit separator after base specifier

C # 7.3 - Visual Studio 2017 versão 15.7

System.Enum, System.Delegate and unmanaged constraints.
Ref local re-assignment: Ref locals and ref parameters can now be reassigned with the ref assignment operator (= ref).
Stackalloc initializers: Stack-allocated arrays can now be initialized, e.g. Span<int> x = stackalloc[] { 1, 2, 3 };.
Indexing movable fixed buffers: Fixed buffers can be indexed into without first being pinned.
Custom fixed statement: Types that implement a suitable GetPinnableReference can be used in a fixed statement.
Improved overload candidates: Some overload resolution candidates can be ruled out early, thus reducing ambiguities.
Expression variables in initializers and queries: Expression variables like out var and pattern variables are allowed in field initializers, constructor initializers and LINQ queries.
Tuple comparison: Tuples can now be compared with == and !=.
Attributes on backing fields: Allows [field: …] attributes on an auto-implemented property to target its backing field.

C # 8.0 - .NET Core 3.0 e Visual Studio 2019 versão 16.3

Nullable reference types: express nullability intent on reference types with ?, notnull constraint and annotations attributes in APIs, the compiler will use those to try and detect possible null values being dereferenced or passed to unsuitable APIs.
Default interface members: interfaces can now have members with default implementations, as well as static/private/protected/internal members except for state (ie. no fields).
Recursive patterns: positional and property patterns allow testing deeper into an object, and switch expressions allow for testing multiple patterns and producing corresponding results in a compact fashion.
Async streams: await foreach and await using allow for asynchronous enumeration and disposal of IAsyncEnumerable<T> collections and IAsyncDisposable resources, and async-iterator methods allow convenient implementation of such asynchronous streams.
Enhanced using: a using declaration is added with an implicit scope and using statements and declarations allow disposal of ref structs using a pattern.
Ranges and indexes: the i..j syntax allows constructing System.Range instances, the ^k syntax allows constructing System.Index instances, and those can be used to index/slice collections.
Null-coalescing assignment: ??= allows conditionally assigning when the value is null.
Static local functions: local functions modified with static cannot capture this or local variables, and local function parameters now shadow locals in parent scopes.
Unmanaged generic structs: generic struct types that only have unmanaged fields are now considered unmanaged (ie. they satisfy the unmanaged constraint).
Readonly members: individual members can now be marked as readonly to indicate and enforce that they do not modify instance state.
Stackalloc in nested contexts: stackalloc expressions are now allowed in more expression contexts.
Alternative interpolated verbatim strings: @$"..." strings are recognized as interpolated verbatim strings just like $@"...".
Obsolete on property accessors: property accessors can now be individually marked as obsolete.
Permit t is null on unconstrained type parameter

[fonte]: https://github.com/dotnet/csharplang/blob/master/Language-Version-History.md

O C # 8.0 é a versão mais recente do c # .it é suportado apenas no .NET Core 3.xe versões mais recentes. Muitos dos recursos mais recentes exigem recursos de biblioteca e tempo de execução introduzidos no .NET Core 3.x

A tabela a seguir lista a estrutura de destino com a versão e sua versão C # padrão.

Origem - controle de versão em linguagem C #