Um tour pela linguagem C#A tour of the C# language

O C# (pronuncia-se "Veja nítido") é uma linguagem de programação moderna, orientada a objeto e de tipo seguro.C# (pronounced "See Sharp") is a modern, object-oriented, and type-safe programming language. O C# permite que os desenvolvedores criem muitos tipos de aplicativos seguros e robustos que são executados no ecossistema do .NET.C# enables developers to build many types of secure and robust applications that run in the .NET ecosystem. O C# tem suas raízes na família de linguagens C e os programadores em C, C++, Java e JavaScript a reconhecerão imediatamente.C# has its roots in the C family of languages and will be immediately familiar to C, C++, Java, and JavaScript programmers. Este tour fornece uma visão geral dos principais componentes do idioma no C# 8 e versões anteriores.This tour provides an overview of the major components of the language in C# 8 and earlier. Se você quiser explorar a linguagem por meio de exemplos interativos, experimente a introdução aos tutoriais do C#.If you want to explore the language through interactive examples, try the introduction to C# tutorials.

O C# é uma linguagem de programação orientada a objetos e orientada a componentes.C# is an object-oriented, component-oriented programming language. O c# fornece construções de linguagem para dar suporte direto a esses conceitos, tornando o C# uma linguagem natural para criar e usar componentes de software.C# provides language constructs to directly support these concepts, making C# a natural language in which to create and use software components. Desde sua origem, o C# adicionou recursos para dar suporte a novas cargas de trabalho e práticas de design de software emergentes.Since its origin, C# has added features to support new workloads and emerging software design practices.

Vários recursos do C# ajudam a criar aplicativos robustos e duráveis.Several C# features help create robust and durable applications. A * coleta de lixo _ recupera automaticamente a memória ocupada por objetos não utilizados inacessíveis.*Garbage collection _ automatically reclaims memory occupied by unreachable unused objects. Os tipos anuláveis protegem contra variáveis que não se referem a objetos alocados.Nullable types guard against variables that don't refer to allocated objects. A manipulação de exceção fornece uma abordagem estruturada e extensível para detecção e recuperação de erros.Exception handling provides a structured and extensible approach to error detection and recovery. As expressões lambda dão suporte a técnicas de programação funcional.Lambda expressions support functional programming techniques. A sintaxe de linguagem de consulta integrada (LINQ) cria um padrão comum para trabalhar com dados de qualquer fonte.Language Integrated Query (LINQ) syntax creates a common pattern for working with data from any source. O suporte a idiomas para operações assíncronas fornece a sintaxe para a criação de sistemas distribuídos.Language support for asynchronous operations provides syntax for building distributed systems. O C# tem um sistema * de tipo _ unificado.C# has a _ unified type system*. Todos os tipos do C#, incluindo tipos primitivos, como int e double, herdam de um único tipo de object raiz.All C# types, including primitive types such as int and double, inherit from a single root object type. Todos os tipos compartilham um conjunto de operações comuns.All types share a set of common operations. Os valores de qualquer tipo podem ser armazenados, transportados e operados de maneira consistente.Values of any type can be stored, transported, and operated upon in a consistent manner. Além disso, o C# dá suporte a tipos de referência definidos pelo usuário e tipos de valor.Furthermore, C# supports both user-defined reference types and value types. O C# permite a alocação dinâmica de objetos e o armazenamento em linha de estruturas leves.C# allows dynamic allocation of objects and in-line storage of lightweight structures. O C# oferece suporte a tipos e métodos genéricos, que fornecem aumento na segurança e no desempenho do tipo.C# supports generic methods and types, which provide increased type safety and performance. O C# fornece iteradores, que habilitam implementadores de classes de coleção para definir comportamentos personalizados para o código do cliente.C# provides iterators, which enable implementers of collection classes to define custom behaviors for client code.

O C# enfatiza o controle de versão para garantir que programas e bibliotecas possam evoluir ao longo do tempo de maneira compatível.C# emphasizes versioning to ensure programs and libraries can evolve over time in a compatible manner. Aspectos do design do C# que foram influenciados diretamente pelas considerações de controle de versão incluem os virtual override modificadores and separados, as regras para resolução de sobrecarga de método e suporte para declarações de membro de interface explícitas.Aspects of C#'s design that were directly influenced by versioning considerations include the separate virtual and override modifiers, the rules for method overload resolution, and support for explicit interface member declarations.

Arquitetura do .NET.NET architecture

Os programas em C# são executados no .NET, um sistema de execução virtual chamado Common Language Runtime (CLR) e um conjunto de bibliotecas de classes.C# programs run on .NET, a virtual execution system called the common language runtime (CLR) and a set of class libraries. O CLR é a implementação da Microsoft da CLI (Common Language Infrastructure), um padrão internacional.The CLR is the implementation by Microsoft of the common language infrastructure (CLI), an international standard. A CLI é a base para a criação de ambientes de execução e desenvolvimento nos quais as linguagens e bibliotecas funcionam em conjunto diretamente.The CLI is the basis for creating execution and development environments in which languages and libraries work together seamlessly.

O código-fonte escrito em C# é compilado em uma Il (linguagem intermediária) que está de acordo com a especificação da CLI.Source code written in C# is compiled into an intermediate language (IL) that conforms to the CLI specification. O código de IL e os recursos, como bitmaps e cadeias de caracteres, são armazenados em um assembly, normalmente com uma extensão de . dll.The IL code and resources, such as bitmaps and strings, are stored in an assembly, typically with an extension of .dll. Um assembly contém um manifesto que fornece informações sobre os tipos, a versão e a cultura do assembly.An assembly contains a manifest that provides information about the assembly's types, version, and culture.

Quando o programa C# é executado, o assembly é carregado no CLR.When the C# program is executed, the assembly is loaded into the CLR. O CLR executa a compilação JIT (just-in-time) para converter o código IL em instruções de máquina nativa.The CLR performs Just-In-Time (JIT) compilation to convert the IL code to native machine instructions. O CLR fornece outros serviços relacionados à coleta de lixo, manipulação de exceções e gerenciamento de recursos automáticos.The CLR provides other services related to automatic garbage collection, exception handling, and resource management. O código executado pelo CLR, às vezes, é chamado de "código gerenciado", em oposição ao "código não gerenciado", que é compilado em linguagem de máquina nativa direcionada a uma plataforma específica.Code that's executed by the CLR is sometimes referred to as "managed code," in contrast to "unmanaged code," which is compiled into native machine language that targets a specific platform.

A interoperabilidade de linguagem é um recurso fundamental do .NET.Language interoperability is a key feature of .NET. O código de IL produzido pelo compilador C# está de acordo com a CTS (especificação de tipo comum).IL code produced by the C# compiler conforms to the Common Type Specification (CTS). O código IL gerado do C# pode interagir com o código gerado nas versões do .NET do F #, Visual Basic, C++ ou em qualquer um dos mais de 20 outros idiomas compatíveis com CTS.IL code generated from C# can interact with code that was generated from the .NET versions of F#, Visual Basic, C++, or any of more than 20 other CTS-compliant languages. Um único assembly pode conter vários módulos escritos em diferentes linguagens .NET, e os tipos podem referenciar um ao outro como se fossem escritos no mesmo idioma.A single assembly may contain multiple modules written in different .NET languages, and the types can reference each other as if they were written in the same language.

Além dos serviços de tempo de execução, o .NET também inclui bibliotecas extensivas.In addition to the run time services, .NET also includes extensive libraries. Essas bibliotecas dão suporte a várias cargas de trabalho diferentes.These libraries support many different workloads. Elas são organizadas em namespaces que fornecem uma ampla variedade de funcionalidades úteis para tudo, desde entrada e saída de arquivos até a manipulação de cadeia de caracteres até a análise XML até estruturas de aplicativos Web para Windows Forms controles.They're organized into namespaces that provide a wide variety of useful functionality for everything from file input and output to string manipulation to XML parsing, to web application frameworks to Windows Forms controls. O aplicativo C# típico usa a biblioteca de classes .NET extensivamente para lidar com tarefas comuns de "encanamento".The typical C# application uses the .NET class library extensively to handle common "plumbing" chores.

Para obter mais informações sobre o .NET, consulte visão geral do .net.For more information about .NET, see Overview of .NET.

Hello worldHello world

O programa "Hello, World" é usado tradicionalmente para introduzir uma linguagem de programação.The "Hello, World" program is traditionally used to introduce a programming language. Este é para C#:Here it is in C#:

using System;

class Hello
{
    static void Main()
    {
        Console.WriteLine("Hello, World");
    }
}

O programa "Hello, World" começa com uma diretiva using que faz referência ao namespace System.The "Hello, World" program starts with a using directive that references the System namespace. Namespaces fornecem um meio hierárquico de organizar bibliotecas e programas em C#.Namespaces provide a hierarchical means of organizing C# programs and libraries. Os namespaces contêm tipos e outros namespaces — por exemplo, o namespace System contém uma quantidade de tipos, como a classe Console referenciada no programa e diversos outros namespaces, como IO e Collections.Namespaces contain types and other namespaces—for example, the System namespace contains a number of types, such as the Console class referenced in the program, and a number of other namespaces, such as IO and Collections. A diretiva using que faz referência a um determinado namespace permite o uso não qualificado dos tipos que são membros desse namespace.A using directive that references a given namespace enables unqualified use of the types that are members of that namespace. Devido à diretiva using, o programa pode usar Console.WriteLine como um atalho para System.Console.WriteLine.Because of the using directive, the program can use Console.WriteLine as shorthand for System.Console.WriteLine.

A classe Hello declarada pelo programa "Hello, World" tem um único membro, o método chamado Main.The Hello class declared by the "Hello, World" program has a single member, the method named Main. O Main método é declarado com o static modificador.The Main method is declared with the static modifier. Embora os métodos de instância possam fazer referência a uma determinada instância de objeto delimitador usando a palavra-chave this, métodos estáticos operam sem referência a um objeto específico.While instance methods can reference a particular enclosing object instance using the keyword this, static methods operate without reference to a particular object. Por convenção, um método estático chamado Main serve como o ponto de entrada de um programa em C#.By convention, a static method named Main serves as the entry point of a C# program.

A saída do programa é produzida pelo método WriteLine da classe Console no namespace System.The output of the program is produced by the WriteLine method of the Console class in the System namespace. Essa classe é fornecida pelas bibliotecas de classe padrão, que, por padrão, são referenciadas automaticamente pelo compilador.This class is provided by the standard class libraries, which, by default, are automatically referenced by the compiler.

Tipos e variáveisTypes and variables

Há dois tipos em C#: tipos de referência e tipos de valor.There are two kinds of types in C#: value types and reference types. Variáveis de tipos de valor contêm diretamente seus dados.Variables of value types directly contain their data. Variáveis de tipos de referência armazenam referências a seus dados, o último é conhecido como objetos.Variables of reference types store references to their data, the latter being known as objects. Com os tipos de referência, é possível que duas variáveis referenciem o mesmo objeto e possíveis operações em uma variável afetem o objeto referenciado pela outra variável.With reference types, it's possible for two variables to reference the same object and possible for operations on one variable to affect the object referenced by the other variable. Com os tipos de valor, as variáveis têm sua própria cópia dos dados, e não é possível que as operações em um afetem a outra (exceto ref para out variáveis de parâmetro e).With value types, the variables each have their own copy of the data, and it isn't possible for operations on one to affect the other (except for ref and out parameter variables).

Um identificador é um nome de variável.An identifier is a variable name. Um identificador é uma sequência de caracteres Unicode sem qualquer espaço em branco.An identifier is a sequence of unicode characters without any whitespace. Um identificador pode ser uma palavra reservada em C#, se for prefixada por @ .An identifier may be a C# reserved word, if it's prefixed by @. Usar uma palavra reservada como um identificador pode ser útil ao interagir com outras linguagens.Using a reserved word as an identifier can be useful when interacting with other languages.

Os tipos de valor do C# são divididos em tipos simples, tipos de enumeração, tipos de struct, tipos de valor anulável e tipos de valor de tupla.C#'s value types are further divided into simple types, enum types, struct types, nullable value types, and tuple value types. Os tipos de referência do C# são divididos em tipos de classe, tipos de interface, tipos de matriz e tipos delegados.C#'s reference types are further divided into class types, interface types, array types, and delegate types.

A seguinte estrutura de tópicos fornece uma visão geral do sistema de tipos do C#.The following outline provides an overview of C#'s type system.

Os programas em C# usam declarações de tipos para criar novos tipos.C# programs use type declarations to create new types. Uma declaração de tipo especifica o nome e os membros do novo tipo.A type declaration specifies the name and the members of the new type. Seis categorias de tipos do C# são definíveis pelo usuário: tipos de classe, tipos de struct, tipos de interface, tipos de enumeração, tipos de delegado e tipos de valor de tupla.Six of C#'s categories of types are user-definable: class types, struct types, interface types, enum types, delegate types, and tuple value types.

  • Um tipo class define uma estrutura de dados que contém membros de dados (campos) e membros de função (métodos, propriedades e outros).A class type defines a data structure that contains data members (fields) and function members (methods, properties, and others). Os tipos de classe dão suporte à herança única e ao polimorfismo, mecanismos nos quais as classes derivadas podem estender e especializar as classes base.Class types support single inheritance and polymorphism, mechanisms whereby derived classes can extend and specialize base classes.
  • Um tipo struct é semelhante a um tipo de classe que representa uma estrutura com membros de dados e membros da função.A struct type is similar to a class type in that it represents a structure with data members and function members. No entanto, ao contrário das classes, as structs são tipos de valor e normalmente não exigem alocação de heap.However, unlike classes, structs are value types and don't typically require heap allocation. Tipos de struct não dão suporte à herança especificada pelo usuário e todos os tipos de struct herdam implicitamente do tipo object .Struct types don't support user-specified inheritance, and all struct types implicitly inherit from type object.
  • Um interface tipo define um contrato como um conjunto nomeado de membros públicos.An interface type defines a contract as a named set of public members. Um class ou struct que implementa um interface deve fornecer implementações dos membros da interface.A class or struct that implements an interface must provide implementations of the interface's members. Um interface pode herdar de várias interfaces base e um class ou struct pode implementar várias interfaces.An interface may inherit from multiple base interfaces, and a class or struct may implement multiple interfaces.
  • Um tipo delegate representa referências aos métodos com uma lista de parâmetros e tipo de retorno específicos.A delegate type represents references to methods with a particular parameter list and return type. Delegados possibilitam o tratamento de métodos como entidades que podem ser atribuídos a variáveis e passadas como parâmetros.Delegates make it possible to treat methods as entities that can be assigned to variables and passed as parameters. Os delegados são análogos aos tipos de função fornecidos pelas linguagens funcionais.Delegates are analogous to function types provided by functional languages. Eles também são semelhantes ao conceito de ponteiros de função encontrados em algumas outras linguagens.They're also similar to the concept of function pointers found in some other languages. Diferentemente de ponteiros de função, os delegados são orientados a objeto e são de tipo seguro.Unlike function pointers, delegates are object-oriented and type-safe.

Os class struct tipos,, e interface delegate oferecem suporte a genéricos, no qual eles podem ser parametrizados com outros tipos.The class, struct, interface, and delegate types all support generics, whereby they can be parameterized with other types.

O C# dá suporte a matrizes unidimensionais e multidimensionais de qualquer tipo.C# supports single-dimensional and multi-dimensional arrays of any type. Ao contrário dos tipos listados acima, os tipos de matriz não precisam ser declarados antes que possam ser usados.Unlike the types listed above, array types don't have to be declared before they can be used. Em vez disso, os tipos de matriz são construídos seguindo um nome de tipo entre colchetes.Instead, array types are constructed by following a type name with square brackets. Por exemplo, int[] é uma matriz unidimensional de int , int[,] é uma matriz bidimensional de int e int[][] é uma matriz unidimensional de matrizes unidimensionais, ou uma matriz "denteada", de int .For example, int[] is a single-dimensional array of int, int[,] is a two-dimensional array of int, and int[][] is a single-dimensional array of single-dimensional arrays, or a "jagged" array, of int.

Tipos anuláveis não exigem uma definição separada.Nullable types don't require a separate definition. Para cada tipo não anulável T , há um tipo anulável correspondente T? , que pode conter um valor adicional, null .For each non-nullable type T, there's a corresponding nullable type T?, which can hold an additional value, null. Por exemplo, int? é um tipo que pode conter qualquer número inteiro de 32 bits ou o valor null e string? é um tipo que pode conter qualquer string ou o valor null .For instance, int? is a type that can hold any 32-bit integer or the value null, and string? is a type that can hold any string or the value null.

O sistema de tipos do C# é unificado, de modo que um valor de qualquer tipo pode ser tratado como um object .C#'s type system is unified such that a value of any type can be treated as an object. Cada tipo no C#, direta ou indiretamente, deriva do tipo de classe object, e object é a classe base definitiva de todos os tipos.Every type in C# directly or indirectly derives from the object class type, and object is the ultimate base class of all types. Os valores de tipos de referência são tratados como objetos simplesmente exibindo os valores como tipo object.Values of reference types are treated as objects simply by viewing the values as type object. Os valores de tipos de valor são tratados como objetos, executando conversão boxing e operações de conversão unboxing.Values of value types are treated as objects by performing boxing and unboxing operations. No exemplo a seguir, um valor int é convertido em object e volta novamente ao int.In the following example, an int value is converted to object and back again to int.

int i = 123;
object o = i;    // Boxing
int j = (int)o;  // Unboxing

Quando um valor de um tipo de valor é atribuído a uma object referência, uma "caixa" é alocada para conter o valor.When a value of a value type is assigned to an object reference, a "box" is allocated to hold the value. Essa caixa é uma instância de um tipo de referência, e o valor é copiado para essa caixa.That box is an instance of a reference type, and the value is copied into that box. Por outro lado, quando uma object referência é convertida em um tipo de valor, é feita uma verificação de que a referência object é uma caixa do tipo de valor correto.Conversely, when an object reference is cast to a value type, a check is made that the referenced object is a box of the correct value type. Se a verificação for realizada com sucesso, o valor na caixa será copiado para o tipo de valor.If the check succeeds, the value in the box is copied to the value type.

O sistema de tipos unificados do C# significa efetivamente que os tipos de valor são tratados como object referências "sob demanda".C#'s unified type system effectively means that value types are treated as object references "on demand." Devido à unificação, as bibliotecas de uso geral que usam object o tipo podem ser usadas com todos os tipos que derivam de object , incluindo tipos de referência e tipos de valor.Because of the unification, general-purpose libraries that use type object can be used with all types that derive from object, including both reference types and value types.

Existem vários tipos de variáveis no C#, incluindo campos, elementos de matriz, variáveis locais e parâmetros.There are several kinds of variables in C#, including fields, array elements, local variables, and parameters. As variáveis representam locais de armazenamento.Variables represent storage locations. Cada variável tem um tipo que determina quais valores podem ser armazenados na variável, como mostrado abaixo.Every variable has a type that determines what values can be stored in the variable, as shown below.

  • Tipo de valor não nuloNon-nullable value type
    • Um valor de tipo exatoA value of that exact type
  • Tipos de valor anulávelNullable value type
    • Um valor null ou um valor do tipo exatoA null value or a value of that exact type
  • objetoobject
    • Uma referência null, uma referência a um objeto de qualquer tipo de referência ou uma referência a um valor de qualquer tipo de valor demarcadoA null reference, a reference to an object of any reference type, or a reference to a boxed value of any value type
  • Tipo de classeClass type
    • Uma referência null, uma referência a uma instância desse tipo de classe ou uma referência a uma instância de uma classe derivada desse tipo de classeA null reference, a reference to an instance of that class type, or a reference to an instance of a class derived from that class type
  • Tipo de interfaceInterface type
    • Uma referência null, uma referência a uma instância de um tipo de classe que implementa esse tipo de interface ou uma referência a um valor demarcado de um tipo de valor que implementa esse tipo de interfaceA null reference, a reference to an instance of a class type that implements that interface type, or a reference to a boxed value of a value type that implements that interface type
  • Tipo de matrizArray type
    • Uma referência null, uma referência a uma instância desse tipo de matriz ou uma referência a uma instância de um tipo de matriz compatívelA null reference, a reference to an instance of that array type, or a reference to an instance of a compatible array type
  • Tipo delegadoDelegate type
    • Uma referência null ou uma referência a uma instância de um tipo de delegado compatívelA null reference or a reference to an instance of a compatible delegate type

Estrutura do programaProgram structure

Os principais conceitos organizacionais do C# são os * programas _, namespaces, tipos, Membrose assemblies.The key organizational concepts in C# are *programs _, namespaces, types, members, and assemblies. 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, estruturas e interfaces são exemplos de tipos.Classes, structs, 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.

Como um pequeno exemplo, considere um assembly que contém o código a seguir:As a small example, consider an assembly that contains the following code:

using System;

namespace Acme.Collections
{
    public class Stack<T>
    {
        Entry _top;
        
        public void Push(T data)
        {
            _top = new Entry(_top, data);
        }

        public T Pop()
        {
            if (_top == null)
            {
                throw new InvalidOperationException();
            }
            T result = _top.Data;
            _top = _top.Next;
            
            return result;
        }

        class Entry
        {
            public Entry Next { get; set; }
            public T Data { get; set; }
            
            public Entry(Entry next, T data)
            {
                Next = next;
                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 Stack é uma classe genérica .The Stack is a generic class. Ele tem um parâmetro de tipo, T que é substituído por um tipo concreto quando usado.It has one type parameter, T that is replaced with a concrete type when it's used.

Observação

Uma pilha é uma coleção de "primeiro a entrar no final" (filo).A stack is a "first in - last out" (FILO) collection. Novos elementos são adicionados à parte superior da pilha.New elements are added to the top of the stack. Quando um elemento é removido, ele é removido da parte superior da pilha.When an element is removed, it is removed from the top of the stack.

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 de #include 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
{
    public static void Main()
    {
        var s = new Stack<int>();
        s.Push(1); // stack contains 1
        s.Push(10); // stack contains 1, 10
        s.Push(100); // stack contains 1, 10, 100
        Console.WriteLine(s.Pop()); // stack contains 1, 10
        Console.WriteLine(s.Pop()); // stack contains 1
        Console.WriteLine(s.Pop()); // stack is empty
    }
}

Para compilar esse programa, você precisa fazer referência ao assembly que contém a classe Stack definida no exemplo anterior.To compile this program, you would need to reference the assembly containing the stack class defined in the earlier example.

Os programas em C# podem ser armazenados em vários arquivos de origem.C# programs can be stored in several source files. Quando um programa em C# é compilado, todos os arquivos de origem são processados em conjunto e os arquivos de origem podem fazer referência livremente entre si.When a C# program is compiled, all of the source files are processed together, and the source files can freely reference each other. Conceitualmente, é como se todos os arquivos de origem fossem concatenados em um arquivo grande antes de serem processados.Conceptually, it's 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 apenas um tipo público, nem exige o nome do arquivo de origem para corresponder a um tipo declarado no arquivo de origem.C# doesn't 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.

Artigos adicionais neste Tour explicam esses blocos organizacionais.Further articles in this tour explain these organizational blocks.