Qual è la differenza tra C # e .NET?

Posso sapere qual è la differenza tra C # e .NET? Quando penso a C #, direi subito che è un linguaggio .NET, ma quando cerco posti di lavoro, richiedono candidati con esperienza in C # e .NET. Qualcuno può darmi una spiegazione?

Oltre a ciò che ha detto Andrew, vale la pena notare che:

• .NET non è solo una libreria , ma anche un runtime per l'esecuzione di applicazioni.
• La conoscenza di C # implica una certa conoscenza di .NET (perché il modello a oggetti C # corrisponde al modello a oggetti .NET e puoi fare qualcosa di interessante in C # semplicemente usando le librerie .NET). Il contrario non è necessariamente vero in quanto è possibile utilizzare altre lingue per scrivere applicazioni .NET.

La distinzione tra un linguaggio , un runtime e una libreria è più rigorosa in .NET / C # che ad esempio in C ++, dove la specifica del linguaggio include anche alcune funzioni di base della libreria. La specifica C # dice solo molto poco sull'ambiente (in sostanza, dovrebbe contenere alcuni tipi come int, ma questo è più o meno tutto).

C # è un linguaggio di programmazione, .NET è un termine generale che tende a comprendere sia .NET Framework (una libreria di framework dell'applicazione) sia Common Language Runtime che è il runtime in cui vengono eseguiti gli assembly .NET.

L'implementazione di Microsoft di C # è fortemente integrata con .NET Framework, quindi è comprensibile che i due concetti vengano confusi. Tuttavia è importante capire che sono due cose molto diverse.

Ecco una lezione scritta in C #:

class Example { }

Ecco una classe scritta in C # che utilizza esplicitamente un assembly, un tipo e un metodo di framework .NET:

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

Come accennato in precedenza, è molto difficile utilizzare l'implementazione Microsoft di C # senza utilizzare anche .NET framework. La mia prima Exampleimplementazione sopra usa persino il framework .NET (implicitamente, sì, ma lo usa comunque) perché Exampleeredita da System.Object.

Inoltre, il motivo per cui utilizzo la frase dell'implementazione Microsoft di C # è perché sono disponibili altre implementazioni di C # .

C # è un linguaggio di programmazione, .NET è il framework su cui è basato il linguaggio.

C # è un forte linguaggio di programmazione orientato agli oggetti che si basa principalmente sul framework .NET.

C # è l'aereo e .NET è la pista;)

C # è un linguaggio, .NET è un framework applicativo. Le librerie .NET possono essere eseguite sul CLR e quindi qualsiasi linguaggio che può essere eseguito sul CLR può utilizzare anche le librerie .NET.

Se hai familiarità con Java, questo è simile ... Java è un linguaggio costruito sopra JVM ... anche se una qualsiasi delle librerie Java pre-assemblate può essere usata da un altro linguaggio costruito sopra JVM.

Quando le persone parlano del "framework .net" tendono a combinare due aree principali: la libreria di runtime e la macchina virtuale che esegue effettivamente il codice .net.

Quando si crea una libreria di classi in Visual Studio in C #, la DLL segue un formato prescritto - molto approssimativamente, c'è una sezione che contiene metadati che descrivono quali classi sono incluse in esso e quali funzioni hanno, ecc. E che descrive dove nel binario esistono quegli oggetti. Questo comune formato .net consente di condividere facilmente le librerie tra i linguaggi .net (C #, VB.Net, F # e altri). Sebbene gran parte della "libreria di runtime" .net sia ora scritta in C # (credo), puoi immaginare quanti di loro avrebbero potuto essere scritti in lingue non gestite ma disposti in questo formato prescritto in modo tale da poter essere consumati da lingue .net .

La vera "carne" della libreria che costruisci consiste in CIL ("Common Intermediate Language") che è un po 'come il linguaggio assembly di .net - ancora una volta, questo linguaggio è l'output comune di tutti i linguaggi .net, che è ciò che rende le librerie .net utilizzabili da qualsiasi linguaggio .net.

Usando lo strumento "ildasm.exe", che è disponibile gratuitamente negli SDK di Microsoft (e potrebbe già essere sul tuo computer), puoi vedere come il codice C # viene convertito in metadati e IL. Ho incluso un esempio in fondo a questa risposta come esempio.

Quando si esegue il codice .net, ciò che accade comunemente è che la macchina virtuale .net sta leggendo quell'IL e lo sta elaborando. Questo è l'altro lato di .net e, di nuovo, si può probabilmente immaginare che questo potrebbe essere facilmente scritto in un linguaggio non gestito - "solo" deve leggere le istruzioni della VM ed eseguirle (e integrarsi con il Garbage Collector, che ha anche bisogno non essere codice .net).

Quello che ho descritto è (di nuovo, più o meno) ciò che accade quando si crea un eseguibile in Visual Studio (per ulteriori informazioni, consiglio vivamente il libro "CLR via C # di Jeffrey Richter" - è molto dettagliato e scritto in modo eccellente).

Tuttavia, ci sono volte in cui potresti scrivere C # che non verrà eseguito all'interno di un ambiente .net, ad esempio Bridge.NET "compila" il codice C # in JavaScript che viene quindi eseguito nel browser (il team che lo produce è passato a lo sforzo di scrivere versioni della libreria di runtime .net scritte in JavaScript e quindi la potenza e la flessibilità della libreria .net sono disponibili per il JavaScript generato). Questo è un esempio perfetto della separazione tra C # e .net: è possibile scrivere C # per diversi "target"; potresti scegliere come target l'ambiente di runtime .net (quando crei un eseguibile) o potresti scegliere come target l'ambiente del browser (quando usi Bridge.NET).

Una classe di esempio (molto) semplice:

using System;

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

I metadati e IL risultanti (recuperati tramite 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

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

In .NET non trovi solo C #. È possibile trovare Visual Basic per esempio. Se un lavoro richiede conoscenze .NET, probabilmente ha bisogno di un programmatore che conosca l'intero set di lingue fornito dal framework .NET.

C # è un linguaggio di programmazione.

.Net è un framework utilizzato per la creazione di applicazioni su Windows.

Il framework .Net non è limitato a C #. Lingue diverse possono scegliere come target .Net framework e creare applicazioni usando quel framework. Esempi sono F # o VB.Net

C#non ha una libreria di runtime separata. Utilizza .NETcome libreria di runtime.

Qui ti ho fornito un link dove spiegare cos'è il linguaggio C # e l' architettura della piattaforma .NET Framework . Ricorda che C # è un linguaggio di programmazione orientato agli oggetti per scopi generici e funziona su .NET Framework.

.NET Framework include una libreria di classi di grandi dimensioni denominata Framework Class Library (FCL) e fornisce interfaccia utente, accesso ai dati, connettività al database, crittografia, sviluppo di applicazioni Web, algoritmi numerici e comunicazioni di rete.

.NET Framework è stato sviluppato da Microsoft che funziona principalmente su Microsoft Windows.

Introduzione al linguaggio C # e .NET Framework da Microsoft Docs