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 os programas em C# são compilados, eles são empacotados fisicamente em assemblies.When C# programs are compiled, they are 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.

O exemplo declara uma classe chamada Stack em um namespace chamado Acme.Collections:The example declares 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. Supondo que o código-fonte do exemplo seja armazenado no arquivo acme.cs, a linha de comandoAssuming that the source code of the example is stored in the file acme.cs, the command line

csc /t:library acme.cs

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.

Importante

Os exemplos acima usam csc como o compilador C# da linha de comando.The examples above use csc as the command line C# compiler. Esse compilador é um executável do Windows.This compiler is a Windows executable. Para usar C# em outras plataformas, você deve usar as ferramentas para o .NET Core.To use C# across other platforms, you should use the tools for .NET Core. O ecossistema do .NET Core usa o CLI dotnet para gerenciar as compilações de linha de comando.The .NET Core ecosystem uses the dotnet CLI to manage command line builds. Isso inclui gerenciamento de dependências e invocação do compilador C#.This includes managing dependencies, and invoking the C# compiler. Consulte este tutorial para obter uma descrição completa dessas ferramentas nas plataformas com suporte do .NET Core.See this tutorial for a full description of those tools on the platforms supported by .NET Core.

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 código de IL em um assembly é automaticamente convertido em código específico do processador pelo compilador JIT (Just-In-Time) do .NET Common Language Runtime.Before it is executed, the IL code in an assembly is automatically converted to processor-specific code by the Just-In-Time (JIT) compiler of .NET Common Language Runtime.

Como um assembly é uma unidade autodescritiva da funcionalidade que contém o código e os metadados, não é necessário de diretivas #include e arquivos de cabeçalho no C#.Because an assembly is a self-describing unit of functionality containing both code and metadata, there is 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());
    }
}

Se o programa é armazenado no arquivo example.cs, quando example.cs é compilado, o assembly acme.dll pode ser referenciado usando a opção de /r do compilador:If the program is stored in the file example.cs, when example.cs is compiled, the acme.dll assembly can be referenced using the compiler’s /r option:

csc /r:acme.dll example.cs

Isso cria um assembly executável denominado example.exe, que, quando executado, produz a saída:This 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 very 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.