Structura unui program C#

Tradus din această pagină oficială de documentație Microsoft.

Conceptele cheie organizaționale în C# sunt programele, spațiile de nume, tipurile, membrii, și  ansamblele. Programele C# consistă într-unul sau mai multe fișiere sursă. Programele declară tipuri, care conțin membri și pot fi organizați în spații de nume. Clasele și interfețele sunt exemple de tipuri. Câmpurile, metodele, proprietățile, și evenimentele sunt exemple de membri. Când programele C# sunt compilate, ele sunt fizic împachetate în ansamble. Ansamblele au în mod obișnuit extensia de fișier .exe sau .dll, depinzând de faptul că ele implementează aplicații sau, respectiv, biblioteci.

Exemplul declară o clasă numită Stack (ro. stivă) într-un spațiu de nume numit Acme.Collections:

using System;
namespace Acme.Collections
{
    public class Stack
    {
        Entry top;
        public void Push(object data)
        {
            top = new Entry(top, data);
        }

        public object Pop()
        {
            if (top == null)
            {
                throw new InvalidOperationException();
            }
            object result = top.data;
            top = top.next;
            return result;
        }
       
        class Entry
        {
            public Entry next;
            public object data;
            public Entry(Entry next, object data)
            {
                this.next = next;
                this.data = data;
            }
        }
    }
}

Numele complet calificat al acestei clase este Acme.Collections.Stack. Clasa conține câțiva membri: un câmp numit top, două metode numite Push și Pop, și o clasă îmbricată numită Entry. Clasa Entry conține mai departe trei membri: un câmp numit next, un câmp numit data, și un constructor. Presupunând că codul sursă al exemplului este stocat în fișierul acme.cs, linia de comandă

csc /t:library acme.cs

compilează exemplul ca o bibliotecă (cod fără un punct de intrare Main) și produce un ansamblu numit acme.dll.

Important. Exemplele de mai sus folosesc csc ca și compilator C# în linie de comandă. Acest compilator este un executabil Windows. Pentru a folosi C# pe alte platforme, dvs. ar trebui să folosiți uneltele pentru .NET Core. Ecosistemul .NET Core folosește interfața în linie de comandă dotnet pentru a organiza construcțiile în linie de comandă. Aceasta include organizarea dependențelor, și invocarea compilatorului C#. Vedeți acest tutorial pentru o descriere completă a acelor unelte pe platformele suportate de .NET Core.

Ansamblele conțin cod executabil în formă de instrucțiuni în Intermediate Language (IL) (ro. limbaj intermediar). Înainte de a fi executat, codul IL dintr-un ansamblu este automat convertit în cod specific procesorului de către compilatorul Just-In-Time (JIT) (ro. Exact-la-timp) al .NET Common Language Runtime (en. mediului de execuție comun limbajelor .NET).

Deoarece un ansamblu este o unitate autodescrisă de funcționalitate conținând și cod și metadate, nu este nevoie de directive #include și fișiere antet în C#. Tipurile și membrii publici conținuți într-un ansamblu particular sunt făcute disponibile într-un program C# pur și simplu prin referirea acelui ansamblu când se compilează programul. De exemplu, acest program folosește clasa Acme.Collections.Stack din ansamblul acme.dll:

using System;
using Acme.Collections;
class Example
{
    static void Main()
    {
        Stack s = new Stack();
        s.Push(1);
        s.Push(10);
        s.Push(100);
        Console.WriteLine(s.Pop());
        Console.WriteLine(s.Pop());
        Console.WriteLine(s.Pop());
    }
}

Dacă programul este stocat în fișierul example.cs, când example.cs este compilat, ansamblul acme.dll poate fi referit folosind opțiunea /r a compilatorului:

csc /r:acme.dll example.cs

Aceasta creează un ansamblu executabil numit example.exe, care, când este rulat, produce ieșirea:

100
10
1

C# permite textul sursă al unui program să fie stocat în câteva fișiere sursă. Când un program C# alcătuit din mai multe fișiere este compilat, toate fișierele sursă sunt procesate împreună, și fișierele sursă pot să se refere unele la celelalte în mod liber—conceptual, este ca dacă toate fișierele sursă ar fi fost concatenate într-un singur fișier mare înainte de a fi procesate. Declarațiile forward nu sunt niciodată necesare în C# pentru că, cu foarte puține excepții, ordinea declarațiilor este nesemnificativă. C# nu limitează un fișier sursă la declararea unui singur tip public nici nu cere ca numele fișierului sursă să se potrivească cu tipul declarat în fișierul sursă.

Tradus din această pagină oficială de documentație Microsoft.