Common Type SystemCommon type system

O Common Type System define como os tipos são declarados, usados e gerenciados no Common Language Runtime e também é uma parte importante do suporte do tempo de execução para a integração entre linguagens.The common type system defines how types are declared, used, and managed in the common language runtime, and is also an important part of the runtime's support for cross-language integration. O Common Type System executa as seguintes funções:The common type system performs the following functions:

  • Estabelece uma estrutura que ajuda a habilitar integração entre linguagens, segurança de tipos e execução de código de alto desempenho.Establishes a framework that helps enable cross-language integration, type safety, and high-performance code execution.

  • Fornece um modelo orientado a objetos que dá suporte à implementação completa de muitas linguagens de programação.Provides an object-oriented model that supports the complete implementation of many programming languages.

  • Define regras que as linguagens devem seguir, o que ajuda a assegurar que objetos escritos em linguagens diferentes possam interagir entre si.Defines rules that languages must follow, which helps ensure that objects written in different languages can interact with each other.

  • Fornece uma biblioteca que contém os tipos de dados primitivos (como Boolean, Byte, Char, Int32 e UInt64) usados no desenvolvimento de aplicativos.Provides a library that contains the primitive data types (such as Boolean, Byte, Char, Int32, and UInt64) used in application development.

Tipos no .NETTypes in .NET

Todos os tipos no .NET são tipos de valor ou tipos de referência.All types in .NET are either value types or reference types.

Tipos de valor são tipos de dados cujos objetos são representados pelo valor real do objeto.Value types are data types whose objects are represented by the object's actual value. Se uma instância de um tipo de valor é atribuída a uma variável, essa variável recebe uma nova cópia do valor.If an instance of a value type is assigned to a variable, that variable is given a fresh copy of the value.

Tipos de referência são tipos de dados cujos objetos são representados por uma referência (semelhante a um ponteiro) para o valor real do objeto.Reference types are data types whose objects are represented by a reference (similar to a pointer) to the object's actual value. Se um tipo de referência é atribuído a uma variável, essa variável referencia (aponta para) o valor original.If a reference type is assigned to a variable, that variable references (points to) the original value. Nenhuma cópia é feita.No copy is made.

O Common Type System no .NET dá suporte às seguintes cinco categorias de tipos:The common type system in .NET supports the following five categories of types:

ClassesClasses

Uma classe é um tipo de referência que pode ser derivada diretamente de outra classe e que é derivada implicitamente de System.Object.A class is a reference type that can be derived directly from another class and that is derived implicitly from System.Object. A classe define as operações que um objeto (que é uma instância da classe) pode executar (métodos, eventos ou propriedades) e os dados que o objeto contém (campos).The class defines the operations that an object (which is an instance of the class) can perform (methods, events, or properties) and the data that the object contains (fields). Embora uma classe geralmente inclua a definição e a implementação (diferente de interfaces, por exemplo, que contêm somente a definição sem implementação), ela pode ter um ou mais membros que não têm implementação.Although a class generally includes both definition and implementation (unlike interfaces, for example, which contain only definition without implementation), it can have one or more members that have no implementation.

A tabela a seguir descreve algumas das características que uma classe pode ter.The following table describes some of the characteristics that a class may have. Cada linguagem que dá suporte ao runtime fornece uma maneira para indicar que uma classe ou um membro da classe tem uma ou mais dessas características.Each language that supports the runtime provides a way to indicate that a class or class member has one or more of these characteristics. No entanto, as linguagens de programação individuais que segmentam o .NET não podem disponibilizar todas essas características.However, individual programming languages that target .NET may not make all these characteristics available.

CaracterísticaCharacteristic DescriçãoDescription
sealedsealed Especifica que outra classe não pode ser derivada desse tipo.Specifies that another class cannot be derived from this type.
implementaimplements Indica que a classe usa uma ou mais interfaces, fornecendo implementações de membros da interface.Indicates that the class uses one or more interfaces by providing implementations of interface members.
abstractabstract Indica que a classe não pode ser instanciada.Indicates that the class cannot be instantiated. Para usá-la, você deve derivar outra classe a partir dela.To use it, you must derive another class from it.
herdainherits Indica que as instâncias da classe podem ser usadas em qualquer lugar em que a classe base for especificada.Indicates that instances of the class can be used anywhere the base class is specified. Uma classe derivada que herda de uma classe base pode usar a implementação de todos os membros públicos fornecidos pela classe base ou a classe derivada pode substituir a implementação dos membros públicos com sua própria implementação.A derived class that inherits from a base class can use the implementation of any public members provided by the base class, or the derived class can override the implementation of the public members with its own implementation.
exportado ou não exportadoexported or not exported Indica se uma classe está visível fora do assembly em que ela está definida.Indicates whether a class is visible outside the assembly in which it is defined. Essa característica só se aplica a classes de nível superior e não a classes aninhadas.This characteristic applies only to top-level classes and not to nested classes.

Observação

Uma classe também pode ser aninhada em uma classe ou estrutura pai.A class can also be nested in a parent class or structure. Classes aninhadas também têm características de membro.Nested classes also have member characteristics. Para obter mais informações, consulte Tipos aninhados.For more information, see Nested Types.

Membros da classe que não tenham implementação são membros abstratos.Class members that have no implementation are abstract members. Uma classe que tenha um ou mais membros abstratos é ela própria abstrata. Não é possível criar novas instâncias dessa classe.A class that has one or more abstract members is itself abstract; new instances of it cannot be created. Algumas linguagens que segmentam o runtime permitem marcar uma classe como abstrata mesmo que nenhum de seus membros seja abstrato.Some languages that target the runtime let you mark a class as abstract even if none of its members are abstract. É possível usar uma classe abstrata quando você deseja encapsular um conjunto básico de funcionalidades que as classes derivadas podem herdar ou substituir quando apropriado.You can use an abstract class when you want to encapsulate a basic set of functionality that derived classes can inherit or override when appropriate. Classes que não são abstratas são chamadas de classes concretas.Classes that are not abstract are referred to as concrete classes.

Uma classe pode implementar qualquer número de interfaces, mas pode herdar apenas de uma classe base além de System.Object, de que todas as classes herdam implicitamente.A class can implement any number of interfaces, but it can inherit from only one base class in addition to System.Object, from which all classes inherit implicitly. Todas as classes devem ter pelo menos um construtor, que inicializa novas instâncias da classe.All classes must have at least one constructor, which initializes new instances of the class. Se você não definir explicitamente um construtor, a maioria dos compiladores fornecerá automaticamente um construtor sem parâmetros.If you do not explicitly define a constructor, most compilers will automatically provide a parameterless constructor.

EstruturasStructures

Uma estrutura é um tipo de valor que é derivado implicitamente do System.ValueType que, por sua vez, é derivado de System.Object.A structure is a value type that derives implicitly from System.ValueType, which in turn is derived from System.Object. Uma estrutura é útil para representar valores cujos requisitos de memória são pequenos e para passar valores como parâmetros de valor para métodos que têm parâmetros com rigidez de tipos.A structure is useful for representing values whose memory requirements are small, and for passing values as by-value parameters to methods that have strongly typed parameters. No .NET Framework, todos os tipos de dados primitivos (Boolean, Byte, Char, DateTime, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32 e UInt64) são definidos como estruturas.In .NET, all primitive data types (Boolean, Byte, Char, DateTime, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, and UInt64) are defined as structures.

Assim como as classes, as estruturas definem os dados (os campos da estrutura) e as operações que podem ser executadas nesses dados (os métodos da estrutura).Like classes, structures define both data (the fields of the structure) and the operations that can be performed on that data (the methods of the structure). Isso significa que você pode chamar métodos em estruturas, incluindo os métodos virtuais definidos nas classes System.Object e System.ValueType e todos os métodos definidos no próprio tipo de valor.This means that you can call methods on structures, including the virtual methods defined on the System.Object and System.ValueType classes, and any methods defined on the value type itself. Em outras palavras, as estruturas podem ter campos, propriedades e eventos, bem como métodos estáticos e não estáticos.In other words, structures can have fields, properties, and events, as well as static and nonstatic methods. É possível criar instâncias de estruturas, passá-las como parâmetros, armazená-las como variáveis locais ou armazená-las em um campo de outro tipo de valor ou tipo de referência.You can create instances of structures, pass them as parameters, store them as local variables, or store them in a field of another value type or reference type. As estruturas também podem implementar interfaces.Structures can also implement interfaces.

Tipos de valor também são diferentes das classes em vários pontos.Value types also differ from classes in several respects. Primeiro, embora herdem implicitamente do System.ValueType, eles não podem herdar diretamente de qualquer tipo.First, although they implicitly inherit from System.ValueType, they cannot directly inherit from any type. Da mesma forma, todos os tipos de valor são lacrados, o que significa que nenhum outro tipo pode ser derivado deles.Similarly, all value types are sealed, which means that no other type can be derived from them. Eles também não exigem construtores.They also do not require constructors.

Para cada tipo de valor, o Common Language Runtime fornece um tipo disponível demarcado correspondente, que é uma classe com o mesmo estado e comportamento que o tipo de valor.For each value type, the common language runtime supplies a corresponding boxed type, which is a class that has the same state and behavior as the value type. Uma instância de um tipo de valor é demarcada quando é passada para um método que aceita um parâmetro de tipo System.Object.An instance of a value type is boxed when it is passed to a method that accepts a parameter of type System.Object. Ele é não demarcado (ou seja, convertido de uma instância de uma classe de volta para uma instância de um tipo de valor) quando o controle retorna de uma chamada de método que aceita um tipo de valor como um parâmetro por referência.It is unboxed (that is, converted from an instance of a class back to an instance of a value type) when control returns from a method call that accepts a value type as a by-reference parameter. Algumas linguagens exigem que você use sintaxe especial quando o tipo demarcado é necessário. Outras usam automaticamente o tipo demarcado quando necessário.Some languages require that you use special syntax when the boxed type is required; others automatically use the boxed type when it is needed. Ao definir um tipo de valor, você está definindo o tipo demarcado e não demarcado.When you define a value type, you are defining both the boxed and the unboxed type.

EnumeraçõesEnumerations

Uma enumeração é um tipo de valor que herda diretamente de System.Enum e que fornece nomes alternativos para os valores de um tipo primitivo subjacente.An enumeration is a value type that inherits directly from System.Enum and that supplies alternate names for the values of an underlying primitive type. Um tipo de enumeração tem um nome, um tipo subjacente que deve ser um dos tipos inteiros com ou sem sinal internos (como Byte, Int32 ou UInt64) e um conjunto de campos.An enumeration type has a name, an underlying type that must be one of the built-in signed or unsigned integer types (such as Byte, Int32, or UInt64), and a set of fields. Os campos são campos literais estáticos, cada um deles representa uma constante.The fields are static literal fields, each of which represents a constant. O mesmo valor pode ser atribuído a vários campos.The same value can be assigned to multiple fields. Quando isso ocorre, você deve marcar um dos valores como o valor de enumeração primário para reflexão e conversão da cadeia de caracteres.When this occurs, you must mark one of the values as the primary enumeration value for reflection and string conversion.

Você pode atribuir um valor de tipo subjacente a uma enumeração e vice-versa (nenhuma conversão é exigida pelo runtime).You can assign a value of the underlying type to an enumeration and vice versa (no cast is required by the runtime). É possível criar uma instância de uma enumeração e chamar os métodos de System.Enum, assim como qualquer método definido no tipo subjacente da enumeração.You can create an instance of an enumeration and call the methods of System.Enum, as well as any methods defined on the enumeration's underlying type. No entanto, algumas linguagens talvez não deixem passar uma enumeração como um parâmetro quando uma instância do tipo subjacente é necessária (ou vice-versa).However, some languages might not let you pass an enumeration as a parameter when an instance of the underlying type is required (or vice versa).

As seguintes restrições adicionais se aplicam a enumerações:The following additional restrictions apply to enumerations:

  • Elas não podem definir seus próprios métodos.They cannot define their own methods.

  • Elas não podem implementar interfaces.They cannot implement interfaces.

  • Elas não podem definir propriedades ou eventos.They cannot define properties or events.

  • Elas não podem ser genéricas, a menos que sejam genéricas apenas por estarem aninhadas dentro de um tipo genérico.They cannot be generic, unless they are generic only because they are nested within a generic type. Ou seja, uma enumeração não pode ter parâmetros de tipo próprios.That is, an enumeration cannot have type parameters of its own.

    Observação

    Tipos aninhados (incluindo enumerações) criados com o Visual Basic, C# e C++ incluem os parâmetros de tipo de todos os tipos genéricos e, portanto, serão genéricos mesmo se não tiverem parâmetros de tipo próprios.Nested types (including enumerations) created with Visual Basic, C#, and C++ include the type parameters of all enclosing generic types, and are therefore generic even if they do not have type parameters of their own. Para obter mais informações, consulte "Tipos Aninhados" no tópico de referência Type.MakeGenericType.For more information, see "Nested Types" in the Type.MakeGenericType reference topic.

O atributo FlagsAttribute denota um tipo especial de enumeração chamado campo de bits.The FlagsAttribute attribute denotes a special kind of enumeration called a bit field. O próprio runtime não faz distinção entre enumerações tradicionais e campos de bits, mas a linguagem pode fazer isso.The runtime itself does not distinguish between traditional enumerations and bit fields, but your language might do so. Quando é feita essa distinção, operadores bit a bit podem ser usados em campos de bits, mas não em enumerações, para gerar valores sem nome.When this distinction is made, bitwise operators can be used on bit fields, but not on enumerations, to generate unnamed values. Enumerações geralmente são usadas para listas de elementos exclusivos, como dias da semana, país ou nomes de região etc.Enumerations are generally used for lists of unique elements, such as days of the week, country or region names, and so on. Os campos de bits são geralmente usados para listas de qualidades ou quantidades que possam ocorrer em combinação, como Red And Big And Fast.Bit fields are generally used for lists of qualities or quantities that might occur in combination, such as Red And Big And Fast.

O exemplo a seguir mostra como usar campos de bit e enumerações tradicionais.The following example shows how to use both bit fields and traditional enumerations.

using System;
using System.Collections.Generic;

// A traditional enumeration of some root vegetables.
public enum SomeRootVegetables
{
    HorseRadish,
    Radish,
    Turnip
}

// A bit field or flag enumeration of harvesting seasons.
[Flags]
public enum Seasons
{
    None = 0,
    Summer = 1,
    Autumn = 2,
    Winter = 4,
    Spring = 8,
    All = Summer | Autumn | Winter | Spring
}

public class Example
{
   public static void Main()
   {
       // Hash table of when vegetables are available.
       Dictionary<SomeRootVegetables, Seasons> AvailableIn = new Dictionary<SomeRootVegetables, Seasons>();

       AvailableIn[SomeRootVegetables.HorseRadish] = Seasons.All;
       AvailableIn[SomeRootVegetables.Radish] = Seasons.Spring;
       AvailableIn[SomeRootVegetables.Turnip] = Seasons.Spring |
            Seasons.Autumn;

       // Array of the seasons, using the enumeration.
       Seasons[] theSeasons = new Seasons[] { Seasons.Summer, Seasons.Autumn,
            Seasons.Winter, Seasons.Spring };

       // Print information of what vegetables are available each season.
       foreach (Seasons season in theSeasons)
       {
          Console.Write(String.Format(
              "The following root vegetables are harvested in {0}:\n",
              season.ToString("G")));
          foreach (KeyValuePair<SomeRootVegetables, Seasons> item in AvailableIn)
          {
             // A bitwise comparison.
             if (((Seasons)item.Value & season) > 0)
                 Console.Write(String.Format("  {0:G}\n",
                      (SomeRootVegetables)item.Key));
          }
       }
   }
}
// The example displays the following output:
//    The following root vegetables are harvested in Summer:
//      HorseRadish
//    The following root vegetables are harvested in Autumn:
//      Turnip
//      HorseRadish
//    The following root vegetables are harvested in Winter:
//      HorseRadish
//    The following root vegetables are harvested in Spring:
//      Turnip
//      Radish
//      HorseRadish
Imports System.Collections.Generic

' A traditional enumeration of some root vegetables.
Public Enum SomeRootVegetables
    HorseRadish
    Radish
    Turnip
End Enum

' A bit field or flag enumeration of harvesting seasons.
<Flags()> Public Enum Seasons
    None = 0
    Summer = 1
    Autumn = 2
    Winter = 4
    Spring = 8
    All = Summer Or Autumn Or Winter Or Spring
End Enum

' Entry point.
Public Class Example
    Public Shared Sub Main()
        ' Hash table of when vegetables are available.
        Dim AvailableIn As New Dictionary(Of SomeRootVegetables, Seasons)()

        AvailableIn(SomeRootVegetables.HorseRadish) = Seasons.All
        AvailableIn(SomeRootVegetables.Radish) = Seasons.Spring
        AvailableIn(SomeRootVegetables.Turnip) = Seasons.Spring Or _
                                                 Seasons.Autumn

        ' Array of the seasons, using the enumeration.
        Dim theSeasons() As Seasons = {Seasons.Summer, Seasons.Autumn, _
                                       Seasons.Winter, Seasons.Spring}

        ' Print information of what vegetables are available each season.
        For Each season As Seasons In theSeasons
            Console.WriteLine(String.Format( _
                 "The following root vegetables are harvested in {0}:", _
                 season.ToString("G")))
            For Each item As KeyValuePair(Of SomeRootVegetables, Seasons) In AvailableIn
                ' A bitwise comparison.
                If (CType(item.Value, Seasons) And season) > 0 Then
                    Console.WriteLine("  " + _
                          CType(item.Key, SomeRootVegetables).ToString("G"))
                End If
            Next
        Next
    End Sub
End Class
' The example displays the following output:
'    The following root vegetables are harvested in Summer:
'      HorseRadish
'    The following root vegetables are harvested in Autumn:
'      Turnip
'      HorseRadish
'    The following root vegetables are harvested in Winter:
'      HorseRadish
'    The following root vegetables are harvested in Spring:
'      Turnip
'      Radish
'      HorseRadish

InterfacesInterfaces

Uma interface define um contrato que especifica um relacionamento "possível" ou um relacionamento de "propriedade".An interface defines a contract that specifies a "can do" relationship or a "has a" relationship. Interfaces são geralmente usadas para implementar a funcionalidade, como comparação e classificação (interfaces IComparable e IComparable<T>), testes de igualdade (a interface IEquatable<T>), ou a enumeração de itens em uma coleção (as interfaces IEnumerable e IEnumerable<T>).Interfaces are often used to implement functionality, such as comparing and sorting (the IComparable and IComparable<T> interfaces), testing for equality (the IEquatable<T> interface), or enumerating items in a collection (the IEnumerable and IEnumerable<T> interfaces). Interfaces podem ter propriedades, métodos, eventos e todos os que são membros abstratos; ou seja, embora a interface defina os membros e suas assinaturas, ela deixa para o tipo que implementa a interface para definir a funcionalidade de cada membro da interface.Interfaces can have properties, methods, and events, all of which are abstract members; that is, although the interface defines the members and their signatures, it leaves it to the type that implements the interface to define the functionality of each interface member. Isso significa que qualquer classe ou estrutura que implementa uma interface deve fornecer definições para os membros abstratos declarados na interface.This means that any class or structure that implements an interface must supply definitions for the abstract members declared in the interface. Uma interface pode exigir qualquer classe de implementação ou estrutura para também implementar uma ou mais outras interfaces.An interface can require any implementing class or structure to also implement one or more other interfaces.

As restrições a seguir se aplicam a interfaces:The following restrictions apply to interfaces:

  • Uma interface pode ser declarada com qualquer acessibilidade, mas membros da interface devem ter acessibilidade pública.An interface can be declared with any accessibility, but interface members must all have public accessibility.

  • Interfaces não podem definir construtores.Interfaces cannot define constructors.

  • Interfaces não podem definir campos.Interfaces cannot define fields.

  • Interfaces podem definir apenas membros de instância.Interfaces can define only instance members. Elas não podem definir membros estáticos.They cannot define static members.

Cada linguagem deve fornecer regras para mapear uma implementação para a interface que exija o membro, porque mais de uma interface pode declarar um membro com a mesma assinatura e esses membros podem ter implementações separadas.Each language must provide rules for mapping an implementation to the interface that requires the member, because more than one interface can declare a member with the same signature, and these members can have separate implementations.

DelegadosDelegates

Os delegados são tipos de referência que têm um propósito semelhante aos de ponteiros de função no C++.Delegates are reference types that serve a purpose similar to that of function pointers in C++. Eles são usados para manipuladores de eventos e funções de retorno de chamada no .NET.They are used for event handlers and callback functions in .NET. Diferentemente de ponteiros de função, delegados são seguros, verificáveis e fortemente tipados.Unlike function pointers, delegates are secure, verifiable, and type safe. Um tipo de delegado pode representar qualquer método de instância ou método estático que tenha uma assinatura compatível.A delegate type can represent any instance method or static method that has a compatible signature.

Um parâmetro de um delegado será compatível com o parâmetro correspondente de um método se o tipo do parâmetro de delegado for mais restritivo do que o tipo do parâmetro de método, porque isso garante que um argumento passado para o delegado possa ser passado com segurança para o método.A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

Da mesma forma, o tipo de retorno de um delegado será compatível com o tipo de retorno de um método se o tipo de retorno do método for mais restritivo do que o tipo de retorno do delegado, porque isso garante que o valor retornado do método possa ser convertido com segurança para o tipo retorno do delegado.Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

Por exemplo, um representante que tenha um parâmetro de tipo IEnumerable e um tipo de retorno de Object pode representar um método que tenha um parâmetro de tipo Object e um valor de retorno de tipo IEnumerable.For example, a delegate that has a parameter of type IEnumerable and a return type of Object can represent a method that has a parameter of type Object and a return value of type IEnumerable. Para obter mais informações e um código de exemplo, consulte Delegate.CreateDelegate(Type, Object, MethodInfo).For more information and example code, see Delegate.CreateDelegate(Type, Object, MethodInfo).

Diz-se que um delegado está associado ao método que representa.A delegate is said to be bound to the method it represents. Além de estar associado ao método, um delegado pode ser associado a um objeto.In addition to being bound to the method, a delegate can be bound to an object. O objeto representa o primeiro parâmetro do método e é passado para o método sempre que o delegado é invocado.The object represents the first parameter of the method, and is passed to the method every time the delegate is invoked. Se o método for um método de instância, o objeto associado será passado como parâmetro this implícito (Me no Visual Basic). Se o método for estático, o objeto será passado como o primeiro parâmetro formal do método e a assinatura do delegado deverá corresponder aos parâmetros restantes.If the method is an instance method, the bound object is passed as the implicit this parameter (Me in Visual Basic); if the method is static, the object is passed as the first formal parameter of the method, and the delegate signature must match the remaining parameters. Para obter mais informações e um código de exemplo, consulte System.Delegate.For more information and example code, see System.Delegate.

Todos os representantes herdam de System.MulticastDelegate, que herda de System.Delegate.All delegates inherit from System.MulticastDelegate, which inherits from System.Delegate. As linguagens C#, Visual Basic e C++ e não permitem a herança desses tipos.The C#, Visual Basic, and C++ languages do not allow inheritance from these types. Em vez disso, elas fornecem palavras-chave para declarar delegados.Instead, they provide keywords for declaring delegates.

Como representantes herdam de MulticastDelegate, um representante tem uma lista de invocação, que é uma lista dos métodos que o representante representa e que são executados quando o representante é invocado.Because delegates inherit from MulticastDelegate, a delegate has an invocation list, which is a list of methods that the delegate represents and that are executed when the delegate is invoked. Todos os métodos na lista recebem os argumentos fornecidos quando o delegado é invocado.All methods in the list receive the arguments supplied when the delegate is invoked.

Observação

O valor retornado não é definido para um delegado que tenha mais de um método na lista de invocação, mesmo que o delegado tenha um tipo de retorno.The return value is not defined for a delegate that has more than one method in its invocation list, even if the delegate has a return type.

Em muitos casos, como acontece com métodos de retorno de chamada, um delegado representa apenas um método e as únicas ações que você precisa realizar são criar e invocar o delegado.In many cases, such as with callback methods, a delegate represents only one method, and the only actions you have to take are creating the delegate and invoking it.

Para representantes que representam vários métodos, o .NET fornece métodos das classes de representante Delegate e MulticastDelegate para dar suporte a operações como adicionar um método à lista de invocação de um representante (o método Delegate.Combine), remover um método (o método Delegate.Remove) e obter a lista de invocação (o método Delegate.GetInvocationList).For delegates that represent multiple methods, .NET provides methods of the Delegate and MulticastDelegate delegate classes to support operations such as adding a method to a delegate's invocation list (the Delegate.Combine method), removing a method (the Delegate.Remove method), and getting the invocation list (the Delegate.GetInvocationList method).

Observação

Não é necessário usar esses métodos para representantes de manipuladores de eventos em C#, C++ e Visual Basic, porque essas linguagens fornecem sintaxe para adicionar e remover manipuladores de eventos.It is not necessary to use these methods for event-handler delegates in C#, C++, and Visual Basic, because these languages provide syntax for adding and removing event handlers.

Definições de tipoType definitions

Uma definição de tipo inclui o seguinte:A type definition includes the following:

  • Qualquer atributo definido no tipo.Any attributes defined on the type.

  • A acessibilidade do tipo (visibilidade).The type's accessibility (visibility).

  • O nome do tipo.The type's name.

  • O tipo de base do tipo.The type's base type.

  • Qualquer interface implementada pelo tipo.Any interfaces implemented by the type.

  • Definições para cada um dos membros do tipo.Definitions for each of the type's members.

AtributosAttributes

Atributos fornecem metadados adicionais definidos pelo usuário.Attributes provide additional user-defined metadata. Com frequência, eles são usados para armazenar informações adicionais sobre um tipo em seu assembly ou para modificar o comportamento de um membro de tipo no ambiente do tempo de design ou do tempo de execução.Most commonly, they are used to store additional information about a type in its assembly, or to modify the behavior of a type member in either the design-time or run-time environment.

Os atributos são as próprias classe herdadas de System.Attribute.Attributes are themselves classes that inherit from System.Attribute. Linguagens que dão suporte ao uso de atributos têm sua própria sintaxe para aplicar atributos a um elemento de linguagem.Languages that support the use of attributes each have their own syntax for applying attributes to a language element. Os atributos podem ser aplicados a praticamente qualquer elemento de linguagem; os elementos específicos para os quais um atributo pode ser aplicado são definidos pelo AttributeUsageAttribute aplicado à classe de atributo.Attributes can be applied to almost any language element; the specific elements to which an attribute can be applied are defined by the AttributeUsageAttribute that is applied to that attribute class.

Acessibilidade de tipoType accessibility

Todos os tipos têm um modificador que rege sua acessibilidade de outros tipos.All types have a modifier that governs their accessibility from other types. A tabela a seguir descreve as acessibilidades de tipo que o runtime dá suporte.The following table describes the type accessibilities supported by the runtime.

AcessibilidadeAccessibility DescriçãoDescription
públicospublic O tipo é acessível por todos os assemblies.The type is accessible by all assemblies.
assemblyassembly O tipo é acessível somente dentro do assembly.The type is accessible only from within its assembly.

A acessibilidade de um tipo aninhado depende do domínio de acessibilidade, que é determinado pela acessibilidade declarada do membro e pelo domínio da acessibilidade do tipo imediatamente contido.The accessibility of a nested type depends on its accessibility domain, which is determined by both the declared accessibility of the member and the accessibility domain of the immediately containing type. Entretanto, o domínio de acessibilidade de um tipo aninhado não pode exceder o do tipo contido.However, the accessibility domain of a nested type cannot exceed that of the containing type.

O domínio de acessibilidade de um membro aninhado M declarado em um tipo T em um programa P é definido da seguinte forma (observe que M pode ser um tipo):The accessibility domain of a nested member M declared in a type T within a program P is defined as follows (noting that M might itself be a type):

  • Se a acessibilidade declarada de M for public, o domínio de acessibilidade de M será o domínio de acessibilidade de T.If the declared accessibility of M is public, the accessibility domain of M is the accessibility domain of T.

  • Se a acessibilidade declarada de M for protected internal, o domínio de acessibilidade de M será a interseção do domínio de acessibilidade de T com o texto de programa de P e o texto de programa de qualquer tipo derivado de T declarado fora de P.If the declared accessibility of M is protected internal, the accessibility domain of M is the intersection of the accessibility domain of T with the program text of P and the program text of any type derived from T declared outside P.

  • Se a acessibilidade declarada de M for protected, o domínio de acessibilidade de M será a interseção do domínio de acessibilidade de T com o texto do programa de T e qualquer tipo derivado de T.If the declared accessibility of M is protected, the accessibility domain of M is the intersection of the accessibility domain of T with the program text of T and any type derived from T.

  • Se a acessibilidade declarada de M for internal, o domínio de acessibilidade de M será a interseção do domínio de acessibilidade de T com o texto de programa de P.If the declared accessibility of M is internal, the accessibility domain of M is the intersection of the accessibility domain of T with the program text of P.

  • Se a acessibilidade declarada de M for private, o domínio de acessibilidade de M será o texto de programa de T.If the declared accessibility of M is private, the accessibility domain of M is the program text of T.

Nomes de tipoType Names

O Common Type System impõe apenas duas restrições de nomes:The common type system imposes only two restrictions on names:

  • Todos os nomes são codificados como cadeias de caracteres Unicode (16 bits).All names are encoded as strings of Unicode (16-bit) characters.

  • Não são permitidos nomes que tenham um valor (16 bits) inserido de 0x0000.Names are not permitted to have an embedded (16-bit) value of 0x0000.

No entanto, a maioria das linguagens impõe restrições adicionais em nomes de tipo.However, most languages impose additional restrictions on type names. Todas as comparações são feitas em uma base byte por byte e, assim, diferenciam maiúsculas de minúsculas e são independentes de localidade.All comparisons are done on a byte-by-byte basis, and are therefore case-sensitive and locale-independent.

Embora um tipo possa referenciar tipos de outros módulos e assemblies, um tipo deve ser totalmente definido em um módulo do .NET.Although a type might reference types from other modules and assemblies, a type must be fully defined within one .NET module. (Dependendo do suporte do compilador, no entanto, ele pode ser dividido em vários arquivos de código-fonte.) Os nomes de tipo precisam ser exclusivos somente dentro de um namespace.(Depending on compiler support, however, it can be divided into multiple source code files.) Type names need be unique only within a namespace. Para identificar totalmente um tipo, o nome de tipo deve ser qualificado pelo namespace que contém a implementação do tipo.To fully identify a type, the type name must be qualified by the namespace that contains the implementation of the type.

Tipos de base e interfacesBase types and interfaces

Um tipo pode herdar valores e comportamentos de outro tipo.A type can inherit values and behaviors from another type. O Common Type System não permite que tipos sejam herdados de mais de um tipo de base.The common type system does not allow types to inherit from more than one base type.

Um tipo pode implementar um número qualquer de interfaces.A type can implement any number of interfaces. Para implementar uma interface, um tipo deve implementar todos os membros virtuais dessa interface.To implement an interface, a type must implement all the virtual members of that interface. Um método virtual pode ser implementado por um tipo derivado e pode ser invocado estática ou dinamicamente.A virtual method can be implemented by a derived type and can be invoked either statically or dynamically.

Membros de tiposType members

O runtime permite que você defina os membros do tipo, o que especifica o comportamento e o estado de um tipo.The runtime enables you to define members of your type, which specifies the behavior and state of a type. Os membros de tipo incluem o seguinte:Type members include the following:

CamposFields

Um campo descreve e contém parte do estado do tipo.A field describes and contains part of the type's state. Campos podem ser de qualquer tipo com suporte pelo runtime.Fields can be of any type supported by the runtime. Geralmente, os campos são private ou protected, de forma que são acessíveis somente de dentro da classe ou de uma classe derivada.Most commonly, fields are either private or protected, so that they are accessible only from within the class or from a derived class. Se o valor de um campo puder ser modificado fora de seu tipo, um acessador do conjunto de propriedades normalmente será usado.If the value of a field can be modified from outside its type, a property set accessor is typically used. Os campos expostos publicamente geralmente são somente leitura e podem ser de dois tipos:Publicly exposed fields are usually read-only and can be of two types:

  • Constantes, cujo valor é atribuído no tempo de design.Constants, whose value is assigned at design time. Esses são membros estáticos de uma classe, embora eles não sejam definidos usando a palavra-chave static (Shared no Visual Basic).These are static members of a class, although they are not defined using the static (Shared in Visual Basic) keyword.

  • Variáveis somente leitura, cujos valores podem ser atribuídos no construtor da classe.Read-only variables, whose values can be assigned in the class constructor.

O exemplo a seguir ilustra esses dois usos de campos somente leitura.The following example illustrates these two usages of read-only fields.

using System;

public class Constants
{
   public const double Pi = 3.1416;
   public readonly DateTime BirthDate;

   public Constants(DateTime birthDate)
   {
      this.BirthDate = birthDate;
   }
}

public class Example
{
   public static void Main()
   {
      Constants con = new Constants(new DateTime(1974, 8, 18));
      Console.Write(Constants.Pi + "\n");
      Console.Write(con.BirthDate.ToString("d") + "\n");
   }
}
// The example displays the following output if run on a system whose current
// culture is en-US:
//    3.1416
//    8/18/1974
Public Class Constants
    Public Const Pi As Double = 3.1416
    Public ReadOnly BirthDate As Date

    Public Sub New(birthDate As Date)
        Me.BirthDate = birthDate
    End Sub
End Class

Public Module Example
    Public Sub Main()
        Dim con As New Constants(#8/18/1974#)
        Console.WriteLine(Constants.Pi.ToString())
        Console.WriteLine(con.BirthDate.ToString("d"))
    End Sub
End Module
' The example displays the following output if run on a system whose current
' culture is en-US:
'    3.1416
'    8/18/1974

PropriedadesProperties

Uma propriedade nomeia um valor ou um estado do tipo e define métodos para obter ou definir o valor da propriedade.A property names a value or state of the type and defines methods for getting or setting the property's value. Propriedades podem ser tipos primitivos, coleções de tipos primitivos, tipos definidos pelo usuário ou coleções de tipos definidos pelo usuário.Properties can be primitive types, collections of primitive types, user-defined types, or collections of user-defined types. Propriedades são, frequentemente, usadas para manter a interface pública de um tipo independente da representação real do tipo.Properties are often used to keep the public interface of a type independent from the type's actual representation. Isso permite que as propriedades reflitam os valores que não estão armazenados diretamente na classe (por exemplo, quando uma propriedade retorna um valor computado) ou para realizar uma validação antes de os valores serem atribuídos a campos privados.This enables properties to reflect values that are not directly stored in the class (for example, when a property returns a computed value) or to perform validation before values are assigned to private fields. O exemplo a seguir ilustra o padrão mais recente.The following example illustrates the latter pattern.

using System;

public class Person
{
   private int m_Age;

   public int Age
   {
      get { return m_Age; }
      set {
         if (value < 0 || value > 125)
         {
            throw new ArgumentOutOfRangeException("The value of the Age property must be between 0 and 125.");
         }
         else
         {
            m_Age = value;
         }
      }
   }
}
Public Class Person
    Private m_Age As Integer

    Public Property Age As Integer
        Get
            Return m_Age
        End Get
        Set
            If value < 0 Or value > 125 Then
                Throw New ArgumentOutOfRangeException("The value of the Age property must be between 0 and 125.")
            Else
                m_Age = value
            End If
        End Set
    End Property
End Class

Além de incluir a propriedade em si, a MSIL (Microsoft Intermediate Language) para um tipo que contém uma propriedade legível inclui um get_ método PropertyName , e a MSIL para um tipo que contém uma propriedade gravável inclui um set_ método PropertyName .In addition to including the property itself, the Microsoft intermediate language (MSIL) for a type that contains a readable property includes a get_propertyname method, and the MSIL for a type that contains a writable property includes a set_propertyname method.

MétodosMethods

Um método descreve as operações disponíveis no tipo.A method describes operations that are available on the type. A assinatura do método especifica os tipos permitidos de todos seus parâmetros e o valor retornado.A method's signature specifies the allowable types of all its parameters and of its return value.

Embora a maioria dos métodos defina o número exato de parâmetros necessários para chamadas de método, alguns métodos dão suporte a um número variável de parâmetros.Although most methods define the precise number of parameters required for method calls, some methods support a variable number of parameters. O parâmetro final declarado desses métodos é marcado com o atributo ParamArrayAttribute.The final declared parameter of these methods is marked with the ParamArrayAttribute attribute. Compiladores de linguagem normalmente fornecem uma palavra-chave, como params no C# e ParamArray no Visual Basic, que tornam o uso explícito de ParamArrayAttribute desnecessário.Language compilers typically provide a keyword, such as params in C# and ParamArray in Visual Basic, that makes explicit use of ParamArrayAttribute unnecessary.

ConstrutoresConstructors

Um construtor é um tipo especial de método que cria novas instâncias de uma classe ou estrutura.A constructor is a special kind of method that creates new instances of a class or structure. Assim como qualquer outro método, um construtor pode incluir parâmetros. No entanto, os construtores não têm nenhum valor retornado (ou seja, eles retornam void).Like any other method, a constructor can include parameters; however, constructors have no return value (that is, they return void).

Se o código-fonte para uma classe não definir explicitamente um construtor, o compilador incluirá um construtor sem parâmetros.If the source code for a class does not explicitly define a constructor, the compiler includes a parameterless constructor. No entanto, se o código-fonte de uma classe definir apenas construtores com parâmetros, os compiladores do Visual Basic e do C# não gerarão um construtor sem parâmetros.However, if the source code for a class defines only parameterized constructors, the Visual Basic and C# compilers do not generate a parameterless constructor.

Se o código-fonte de uma estrutura definir construtores, eles deverão ser parametrizados. Uma estrutura não pode definir um construtor sem parâmetros e os compiladores não geram construtores sem parâmetros para estruturas ou outros tipos de valor.If the source code for a structure defines constructors, they must be parameterized; a structure cannot define a parameterless constructor, and compilers do not generate parameterless constructors for structures or other value types. Todos os tipos de valor têm um construtor sem parâmetros implícito.All value types do have an implicit parameterless constructor. Esse construtor é implementado pelo Common Language Runtime e inicializa todos os campos da estrutura com seus valores padrão.This constructor is implemented by the common language runtime and initializes all fields of the structure to their default values.

EventosEvents

Um evento define um incidente que pode ser respondido e define métodos para assinar, cancelar a assinatura e acionar o evento.An event defines an incident that can be responded to, and defines methods for subscribing to, unsubscribing from, and raising the event. Eventos são frequentemente usados para informar outros tipos de alterações de estado.Events are often used to inform other types of state changes. Para obter mais informações, consulte Eventos.For more information, see Events.

Tipos aninhadosNested types

Um tipo aninhado é um tipo membro de outros tipos.A nested type is a type that is a member of some other type. Os tipos aninhados devem ser unidos ao tipo de contenção e não devem ser utilizados como tipos de uso geral.Nested types should be tightly coupled to their containing type and must not be useful as a general-purpose type. Os tipos aninhados são úteis quando o tipo declarativo usa e cria instâncias do tipo aninhado e o uso do tipo aninhado não é exposto em membros públicos.Nested types are useful when the declaring type uses and creates instances of the nested type, and use of the nested type is not exposed in public members.

Os tipos aninhados são confusos para alguns desenvolvedores e não devem ficar publicamente visíveis, a menos que haja um motivo forte para a visibilidade.Nested types are confusing to some developers and should not be publicly visible unless there is a compelling reason for visibility. Em uma biblioteca bem projetada, os desenvolvedores raramente precisam usar tipos aninhados para instanciar objetos ou declarar variáveis.In a well-designed library, developers should rarely have to use nested types to instantiate objects or declare variables.

Características de membros de tipoCharacteristics of type members

O Common Type System permite que os membros de tipo tenham várias características. No entanto, as linguagens não necessariamente dão suporte a todas elas.The common type system allows type members to have a variety of characteristics; however, languages are not required to support all these characteristics. A tabela a seguir descreve as características de um membro.The following table describes member characteristics.

CaracterísticaCharacteristic Pode ser aplicado aCan apply to DescriçãoDescription
abstractabstract Métodos, propriedades e eventosMethods, properties, and events O tipo não fornece a implementação do método.The type does not supply the method's implementation. Tipos que herdam ou implementam métodos abstratos devem fornecer uma implementação para o método.Types that inherit or implement abstract methods must supply an implementation for the method. A única exceção é quando o tipo derivado é um tipo abstrato.The only exception is when the derived type is itself an abstract type. Todos os métodos abstratos são virtuais.All abstract methods are virtual.
privado, família, assembly, família e assembly, família ou assembly ou públicoprivate, family, assembly, family and assembly, family or assembly, or public TudoAll Define a acessibilidade de um membro:Defines the accessibility of the member:

particularesprivate
Acessível somente dentro do mesmo tipo que o membro ou de um tipo aninhado.Accessible only from within the same type as the member, or within a nested type.

famíliafamily
Acessível dentro do mesmo tipo que o membro e de tipos derivados herdados dele.Accessible from within the same type as the member, and from derived types that inherit from it.

assemblyassembly
Acessível somente no assembly no qual o tipo é definido.Accessible only in the assembly in which the type is defined.

família e assemblyfamily and assembly
Acessíveis somente em tipos qualificados para acesso de família e assembly.Accessible only from types that qualify for both family and assembly access.

família ou assemblyfamily or assembly
Acessíveis somente dentro de tipos qualificados para acesso de família ou assembly.Accessible only from types that qualify for either family or assembly access.

públicospublic
Acessíveis dentro de qualquer tipo.Accessible from any type.
finalfinal Métodos, propriedades e eventosMethods, properties, and events Um método virtual não pode ser substituído em um tipo derivado.The virtual method cannot be overridden in a derived type.
initialize-onlyinitialize-only CamposFields O valor pode apenas ser inicializado e não pode ser gravado após a inicialização.The value can only be initialized, and cannot be written after initialization.
instanceinstance Campos, métodos, propriedades e eventosFields, methods, properties, and events Se um membro não estiver marcado como static (C# e C++), Shared (Visual Basic), virtual (C# e C++) ou Overridable (Visual Basic), ele será um membro de instância (não há palavra-chave de instância).If a member is not marked as static (C# and C++), Shared (Visual Basic), virtual (C# and C++), or Overridable (Visual Basic), it is an instance member (there is no instance keyword). Haverá tantas cópias desses membros na memória quanto objetos que as usam.There will be as many copies of such members in memory as there are objects that use it.
literalliteral CamposFields O valor atribuído ao campo é um valor fixo, conhecido no tempo de compilação, de um tipo de valor interno.The value assigned to the field is a fixed value, known at compile time, of a built-in value type. Às vezes, campos literais são conhecidos como constantes.Literal fields are sometimes referred to as constants.
newslot ou overridenewslot or override TudoAll Define como o membro interage com os membros herdados que possuam a mesma assinatura:Defines how the member interacts with inherited members that have the same signature:

newslotnewslot
Oculta os membros herdados que possuam a mesma assinatura.Hides inherited members that have the same signature.

overrideoverride
Substitui a definição de um método virtual herdado.Replaces the definition of an inherited virtual method.

O padrão é newslot.The default is newslot.
staticstatic Campos, métodos, propriedades e eventosFields, methods, properties, and events O membro pertence ao tipo no qual está definido e não a uma instância particular do tipo; o membro existirá mesmo se uma instância do tipo não tiver sido criada e será compartilhado entre todas as instâncias do tipo.The member belongs to the type it is defined on, not to a particular instance of the type; the member exists even if an instance of the type is not created, and it is shared among all instances of the type.
virtualvirtual Métodos, propriedades e eventosMethods, properties, and events O método pode ser implementado por um tipo derivado e pode ser invocado estática ou dinamicamente.The method can be implemented by a derived type and can be invoked either statically or dynamically. Se a invocação dinâmica for usada, o tipo da instância que faz a chamada no tempo de execução (em vez do tipo conhecido no tempo de compilação) determinará qual implementação do método será chamada.If dynamic invocation is used, the type of the instance that makes the call at run time (rather than the type known at compile time) determines which implementation of the method is called. Para invocar um método virtual estaticamente, a variável precisará ser convertida em um tipo que usa a versão desejada do método.To invoke a virtual method statically, the variable might have to be cast to a type that uses the desired version of the method.

SobrecargaOverloading

Cada membro de tipo tem uma assinatura exclusiva.Each type member has a unique signature. Assinaturas de método consistem no nome de método e em uma lista de parâmetros (a ordem e os tipos dos argumentos do método).Method signatures consist of the method name and a parameter list (the order and types of the method's arguments). Os vários métodos com o mesmo nome podem ser definidos em um tipo desde que suas assinaturas sejam diferentes.Multiple methods with the same name can be defined within a type as long as their signatures differ. Quando dois ou mais métodos com o mesmo nome forem definidos, diz-se que o método está sobrecarregado.When two or more methods with the same name are defined, the method is said to be overloaded. Por exemplo, em System.Char, o método IsDigit está sobrecarregado.For example, in System.Char, the IsDigit method is overloaded. Um método utiliza um Char.One method takes a Char. O outro método utiliza um String e um Int32.The other method takes a String and an Int32.

Observação

O tipo de retorno não é considerado parte da assinatura do método.The return type is not considered part of a method's signature. Ou seja, os métodos não poderão ser sobrecarregados se diferirem somente pelo tipo de retorno.That is, methods cannot be overloaded if they differ only by return type.

Herdar, substituir e ocultar membrosInherit, override, and hide members

Um tipo derivado herda todos os membros de seu tipo de base; ou seja, esses membros são definidos e disponibilizados para o tipo derivado.A derived type inherits all members of its base type; that is, these members are defined on, and available to, the derived type. O comportamento, ou qualidades, de membros herdados pode ser modificado de duas maneiras:The behavior or qualities of inherited members can be modified in two ways:

  • Um tipo derivado pode ocultar um membro herdado definindo um novo membro com a mesma assinatura.A derived type can hide an inherited member by defining a new member with the same signature. Isso pode ser feito para fazer um membro privado anteriormente público ou para definir o novo comportamento de um método herdado marcado como final.This might be done to make a previously public member private or to define new behavior for an inherited method that is marked as final.

  • Um tipo derivado pode substituir um método virtual herdado.A derived type can override an inherited virtual method. O método de substituição fornece uma nova definição do método que será invocado com base no tipo do valor no tempo de execução em vez do tipo de variável conhecido no tempo de compilação.The overriding method provides a new definition of the method that will be invoked based on the type of the value at run time rather than the type of the variable known at compile time. Um método poderá substituir um método virtual somente se o método virtual não estiver marcado como final e o novo método for tão acessível quanto o método virtual.A method can override a virtual method only if the virtual method is not marked as final and the new method is at least as accessible as the virtual method.

Consulte tambémSee also