Estrutura do programaProgram Structure

Os principais conceitos organizacionais em C# são programas, namespaces, tipos, membros e assemblies.The key organizational concepts in C# are programs, namespaces, types, members, and assemblies. Os programas C# consistem em um ou mais arquivos de origem.C# programs consist of one or more source files. Os programas declaram tipos que contêm membros e podem ser organizados em namespaces.Programs declare types, which contain members and can be organized into namespaces. Classes e interfaces são exemplos de tipos.Classes and interfaces are examples of types. Campos, métodos, propriedades e eventos são exemplos de membros.Fields, methods, properties, and events are examples of members. Quando programas C# são compilados, eles são fisicamente empacotados em assemblies.When C# programs are compiled, they're physically packaged into assemblies. Os assemblies normalmente têm a extensão de arquivo .exe ou .dll, dependendo se eles implementam aplicativos ou bibliotecas, respectivamente.Assemblies typically have the file extension .exe or .dll, depending on whether they implement applications or libraries, respectively.

Você pode criar um projeto de biblioteca chamado Acme usando dotnet new o comando:You can create a library project named acme using the dotnet new command:

dotnet new classlib -o acme

Nesse projeto, declare uma classe chamada Stack em um namespace chamado: Acme.CollectionsIn that project, declare a class named Stack in a namespace called 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;
            }
        }
    }
}

O nome totalmente qualificado dessa classe é Acme.Collections.Stack.The fully qualified name of this class is Acme.Collections.Stack. A classe contém vários membros: um campo chamado top, dois métodos chamados Push e Pop e uma classe aninhada chamada Entry.The class contains several members: a field named top, two methods named Push and Pop, and a nested class named Entry. A classe Entry ainda contém três membros: um campo chamado next, um campo chamado datae um construtor.The Entry class further contains three members: a field named next, a field named data, and a constructor. O comando:The command:

dotnet build

compila o exemplo como uma biblioteca (o código sem um ponto de entrada Main) e produz um assembly denominado acme.dll.compiles the example as a library (code without a Main entry point) and produces an assembly named acme.dll.

Os assemblies contêm código executável na forma de instruções de IL (Linguagem Intermediária) e informações simbólicas na forma de metadados.Assemblies contain executable code in the form of Intermediate Language (IL) instructions, and symbolic information in the form of metadata. Antes de ser executado, o compilador JIT (just-in-time) do .NET Common Language Runtime converte o código IL em um assembly para o código específico do processador.Before it's executed, the Just-In-Time (JIT) compiler of .NET Common Language Runtime converts the IL code in an assembly to processor-specific code.

Como um assembly é uma unidade de funcionalidade autodescreveda que contém o código e os metadados, não há necessidade #include de diretivas e arquivos de cabeçalho em C#.Because an assembly is a self-describing unit of functionality containing both code and metadata, there's no need for #include directives and header files in C#. Os tipos públicos e os membros contidos em um assembly específico são disponibilizados em um programa C# simplesmente fazendo referência a esse assembly ao compilar o programa.The public types and members contained in a particular assembly are made available in a C# program simply by referencing that assembly when compiling the program. Por exemplo, esse programa usa a classe Acme.Collections.Stack do assembly acme.dll:For example, this program uses the Acme.Collections.Stack class from the acme.dll assembly:

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());
    }
}

O arquivo csproj do projeto do programa anterior deve incluir um nó de referência para que o compilador C# resolva as referências às classes no acme.dll assembly:The csproj file for the preceding program's project must include a reference node for the C# compiler to resolve references to the classes in the acme.dll assembly:

  <ItemGroup>
    <ProjectReference Include="..\acme\acme.csproj" />
  </ItemGroup>

Após essa adição, dotnet build cria um assembly executável chamado example.exe, que, quando executado, produz a saída:After that addition, dotnet build creates an executable assembly named example.exe, which, when run, produces the output:

100
10
1

O C# permite que o texto de origem de um programa seja armazenado em vários arquivos de origem.C# permits the source text of a program to be stored in several source files. Quando um programa em C# com vários arquivo é compilado, todos os arquivos de origem são processados juntos e os arquivos de origem podem referenciar livremente uns aos outros. Conceitualmente, é como se todos os arquivos de origem fossem concatenados em um arquivo grande antes de serem processados.When a multi-file C# program is compiled, all of the source files are processed together, and the source files can freely reference each other—conceptually, it is as if all the source files were concatenated into one large file before being processed. Declarações de encaminhamento nunca são necessárias em C# porque, com poucas exceções, a ordem de declaração é insignificante.Forward declarations are never needed in C# because, with few exceptions, declaration order is insignificant. O C# não limita um arquivo de origem para declarar somente um tipo público nem requer o nome do arquivo de origem para corresponder a um tipo declarado no arquivo de origem.C# does not limit a source file to declaring only one public type nor does it require the name of the source file to match a type declared in the source file.