Qual é a diferença entre C # e .NET?

Posso saber qual é a diferença entre C # e .NET? Quando penso em C #, imediatamente diria que é uma linguagem .NET, mas quando procuro vagas, eles exigem que os candidatos tenham experiência em C # e .NET. Alguém pode me dar uma explicação?

Além do que Andrew disse, vale a pena notar que:

• O .NET não é apenas uma biblioteca , mas também um tempo de execução para a execução de aplicativos.
• O conhecimento de C # implica algum conhecimento de .NET (porque o modelo de objeto C # corresponde ao modelo de objeto .NET e você pode fazer algo interessante em C # apenas usando bibliotecas .NET). O oposto não é necessariamente verdadeiro, pois você pode usar outros idiomas para escrever aplicativos .NET.

A distinção entre uma linguagem , um tempo de execução e uma biblioteca é mais estrita no .NET / C # do que, por exemplo, no C ++, onde a especificação da linguagem também inclui algumas funções básicas da biblioteca. A especificação C # diz muito pouco sobre o ambiente (basicamente, ele deve conter alguns tipos como int, mas isso é mais ou menos tudo).

C # é uma linguagem de programação, .NET é um termo geral que tende a abranger o .NET Framework (uma biblioteca de estrutura de aplicativos) e o Common Language Runtime, que é o tempo de execução no qual os assemblies do .NET são executados.

A implementação do C # da Microsoft está fortemente integrada ao .NET Framework, portanto é compreensível que os dois conceitos fiquem confusos. No entanto, é importante entender que são duas coisas muito diferentes.

Aqui está uma classe escrita em C #:

class Example { }

Aqui está uma classe escrita em C # que usa explicitamente um assembly, tipo e método do .NET framework:

class Example
{
    static void Main()
    {
        // Here we call into the .NET framework to 
        // write to the output console
        System.Console.Write("hello, world");
    }
}

Como mencionei antes, é muito difícil usar a implementação de C # da Microsoft sem usar a estrutura .NET também. Minha primeira Exampleimplementação acima até usa a estrutura .NET (implicitamente, sim, mas ainda assim a usa) porque Exampleherda de System.Object.

Além disso, a razão pela qual uso a frase implementação de C # da Microsoft é porque existem outras implementações de C # disponíveis .

C # é uma linguagem de programação, .NET é a estrutura na qual a linguagem é criada.

C # é uma forte linguagem de programação Orientada a Objetos, construída principalmente na estrutura .NET.

C # é o avião e .NET é a pista;)

C # é uma linguagem, .NET é uma estrutura de aplicativo. As bibliotecas .NET podem ser executadas no CLR e, portanto, qualquer idioma que possa ser executado no CLR também pode usar as bibliotecas .NET.

Se você conhece Java, isso é semelhante ... Java é uma linguagem construída sobre a JVM ... embora qualquer uma das bibliotecas Java pré-montadas possa ser usada por outra linguagem criada sobre a JVM.

Quando as pessoas falam sobre a "estrutura .net", elas tendem a combinar duas áreas principais - a biblioteca de tempo de execução e a máquina virtual que realmente executa o código .net.

Quando você cria uma biblioteca de classes no Visual Studio em C #, a DLL segue um formato prescrito - basicamente, há uma seção que contém metadados que descrevem quais classes estão incluídas nele e quais funções elas têm, etc. e que descrevem onde no binário esses objetos existem. Esse formato .net comum é o que permite que as bibliotecas sejam compartilhadas entre idiomas .net (C #, VB.Net, F # e outros) facilmente. Embora grande parte da "biblioteca de tempo de execução" .net esteja escrita em C # agora (acredito), você pode imaginar quantos deles poderiam ter sido escritos em idiomas não gerenciados, mas organizados neste formato prescrito para que pudessem ser consumidos pelos idiomas .net .

A verdadeira "carne" da biblioteca que você constrói consiste em CIL ("Common Intermediate Language"), que é um pouco como a linguagem assembly de .net - novamente, essa linguagem é a saída comum de todas as linguagens .net, que é o que torna as bibliotecas .net consumíveis por qualquer idioma .net.

Usando a ferramenta "ildasm.exe", disponível gratuitamente nos Microsoft SDKs (e talvez já esteja no seu computador), você pode ver como o código C # é convertido em metadados e IL. Incluí uma amostra na parte inferior desta resposta como exemplo.

Quando você executa o código .net de execução, o que normalmente acontece é que a máquina virtual .net está lendo essa IL e processando-a. Esse é o outro lado do .net e, novamente, você pode imaginar que isso poderia ser facilmente escrito em uma linguagem não gerenciada - "apenas" precisa ler as instruções da VM e executá-las (e integrar-se ao coletor de lixo, que também precisa não seja código .net).

O que eu descrevi é (novamente, mais ou menos) o que acontece quando você cria um executável no Visual Studio (para obter mais informações, eu recomendo o livro "CLR via C # de Jeffrey Richter" - é muito detalhado e excelentemente escrito).

No entanto, há momentos em que você pode escrever C # que não será executado em um ambiente .net - por exemplo, o Bridge.NET "compila" o código C # em JavaScript, que é executado no navegador (a equipe que o produziu foi para o esforço de escrever versões da biblioteca de tempo de execução .net que são escritas em JavaScript e, portanto, o poder e a flexibilidade da biblioteca .net estão disponíveis para o JavaScript gerado). Este é um exemplo perfeito da separação entre C # e .net - é possível escrever C # para diferentes "destinos"; você pode direcionar o ambiente de tempo de execução .net (ao criar um executável) ou o ambiente de navegador (ao usar o Bridge.NET).

Uma classe de exemplo (muito) simples:

using System;

namespace Example
{
    public class Class1
    {
        public void SayHello()
        {
            Console.WriteLine("Hello");
        }
    }
}

Os metadados e IL resultantes (recuperados via ildasm.exe):

// Metadata version: v4.0.30319
.assembly extern mscorlib
{
  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         // .z\V.4..
  .ver 4:0:0:0
}
.assembly Example
{
  .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) 
  .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78   // ....T..WrapNonEx
                                                                                                            63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 )       // ceptionThrows.

  // --- The following custom attribute is added automatically, do not uncomment -------
  //  .custom instance void [mscorlib]System.Diagnostics.DebuggableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggableAttribute/DebuggingModes) = ( 01 00 07 01 00 00 00 00 ) 

  .custom instance void [mscorlib]System.Reflection.AssemblyTitleAttribute::.ctor(string) = ( 01 00 0A 54 65 73 74 49 4C 44 41 53 4D 00 00 )    // ...TestILDASM..
  .custom instance void [mscorlib]System.Reflection.AssemblyDescriptionAttribute::.ctor(string) = ( 01 00 00 00 00 ) 
  .custom instance void [mscorlib]System.Reflection.AssemblyConfigurationAttribute::.ctor(string) = ( 01 00 00 00 00 ) 
  .custom instance void [mscorlib]System.Reflection.AssemblyCompanyAttribute::.ctor(string) = ( 01 00 00 00 00 ) 
  .custom instance void [mscorlib]System.Reflection.AssemblyProductAttribute::.ctor(string) = ( 01 00 0A 54 65 73 74 49 4C 44 41 53 4D 00 00 )    // ...TestILDASM..
  .custom instance void [mscorlib]System.Reflection.AssemblyCopyrightAttribute::.ctor(string) = ( 01 00 12 43 6F 70 79 72 69 67 68 74 20 C2 A9 20   // ...Copyright .. 
                                                                                                  20 32 30 31 36 00 00 )                            //  2016..
  .custom instance void [mscorlib]System.Reflection.AssemblyTrademarkAttribute::.ctor(string) = ( 01 00 00 00 00 ) 
  .custom instance void [mscorlib]System.Runtime.InteropServices.ComVisibleAttribute::.ctor(bool) = ( 01 00 00 00 00 ) 
  .custom instance void [mscorlib]System.Runtime.InteropServices.GuidAttribute::.ctor(string) = ( 01 00 24 31 39 33 32 61 32 30 65 2D 61 37 36 64   // ..$1932a20e-a76d
                                                                                                  2D 34 36 33 35 2D 62 36 38 66 2D 36 63 35 66 36   // -4635-b68f-6c5f6
                                                                                                  32 36 36 31 36 37 62 00 00 )                      // 266167b..
  .custom instance void [mscorlib]System.Reflection.AssemblyFileVersionAttribute::.ctor(string) = ( 01 00 07 31 2E 30 2E 30 2E 30 00 00 )             // ...1.0.0.0..
  .custom instance void [mscorlib]System.Runtime.Versioning.TargetFrameworkAttribute::.ctor(string) = ( 01 00 1C 2E 4E 45 54 46 72 61 6D 65 77 6F 72 6B   // ....NETFramework
                                                                                                        2C 56 65 72 73 69 6F 6E 3D 76 34 2E 35 2E 32 01   // ,Version=v4.5.2.
                                                                                                        00 54 0E 14 46 72 61 6D 65 77 6F 72 6B 44 69 73   // .T..FrameworkDis
                                                                                                        70 6C 61 79 4E 61 6D 65 14 2E 4E 45 54 20 46 72   // playName..NET Fr
                                                                                                        61 6D 65 77 6F 72 6B 20 34 2E 35 2E 32 )          // amework 4.5.2
  .hash algorithm 0x00008004
  .ver 1:0:0:0
}
.module Example.dll
// MVID: {80A91E4C-0994-4773-9B73-2C4977BB1F17}
.imagebase 0x10000000
.file alignment 0x00000200
.stackreserve 0x00100000
.subsystem 0x0003       // WINDOWS_CUI
.corflags 0x00000001    //  ILONLY
// Image base: 0x05DB0000

// =============== CLASS MEMBERS DECLARATION ===================

.class public auto ansi beforefieldinit Example.Class1
       extends [mscorlib]System.Object
{
  .method public hidebysig instance void 
          SayHello() cil managed
  {
    // Code size       13 (0xd)
    .maxstack  8
    IL_0000:  nop
    IL_0001:  ldstr      "Hello"
    IL_0006:  call       void [mscorlib]System.Console::WriteLine(string)
    IL_000b:  nop
    IL_000c:  ret
  } // end of method Class1::SayHello

  .method public hidebysig specialname rtspecialname 
          instance void  .ctor() cil managed
  {
    // Code size       8 (0x8)
    .maxstack  8
    IL_0000:  ldarg.0
    IL_0001:  call       instance void [mscorlib]System.Object::.ctor()
    IL_0006:  nop
    IL_0007:  ret
  } // end of method Class1::.ctor

} // end of class Example.Class1

// =============================================================

No .NET, você não encontra apenas C #. Você pode encontrar o Visual Basic, por exemplo. Se um trabalho exigir conhecimento do .NET, provavelmente precisará de um programador que conheça todo o conjunto de idiomas fornecido pela estrutura .NET.

C # é uma linguagem de programação.

.Net é uma estrutura usada para criar aplicativos no Windows.

A estrutura .Net não se limita ao C #. Idiomas diferentes podem direcionar a estrutura .Net e criar aplicativos usando essa estrutura. Exemplos são F # ou VB.Net

C#não possui uma biblioteca de tempo de execução separada. Ele usa .NETcomo uma biblioteca de tempo de execução.

Aqui forneci um link para explicar o que é a linguagem C # e a .NET Framework Platform Architecture . Lembre-se de que o C # é uma linguagem de programação orientada a objetos de uso geral e é executada no .NET Framework.

O .NET Framework inclui uma grande biblioteca de classes denominada Framework Class Library (FCL) e fornece interface do usuário, acesso a dados, conectividade de banco de dados, criptografia, desenvolvimento de aplicativos Web, algoritmos numéricos e comunicações de rede.

O .NET Framework foi desenvolvido pela Microsoft, executado principalmente no Microsoft Windows.

Introdução à linguagem C # e ao .NET Framework do Microsoft Docs