Common Type System

Common type system define como tipos são declarados, usados e gerenciado no Common Language Runtime, e também é uma parte importante do suporte do tempo de execuçãoentre a integração de linguagens de-. The common type system performs the following functions:

• Estabelece uma estrutura que ajuda a habilitar entre-language integração, segurança de tipose alto -desempenho execução de código.

• Provides an object-oriented model that supports the complete implementation of many programming languages.

• 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) usado no desenvolvimento de aplicativo .

This topic contains the following sections:

• Digita o.NET Framework

• Type Definitions

• Type Members

• Características de membros de Tipo

Digita o.NET Framework

Tudo tipos de na.NET Framework são tipos de valor ou tipos de referência.

Tipos deValor são os tipos de dados cujos objetos são representados pelo valor real do objeto. 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.

Tipos de referência são os tipos de dados cujos objetos são representados por uma referência (semelhante a um ponteiro) do objetode valor real. Se um tipo de referência é atribuído a uma variável, essa variável referências (pontos) o valor original. Nenhuma cópia é feita.

Common type system na.NET Framework oferece suporte a cinco categorias de tipos a seguir:

• Classes

• Structures

• Enumerations

• Interfaces

• Delegates

Classes

Uma classe é um tipo de referência que pode ser derivado diretamente a partir de outra classe e que é derivado implicitamente 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). Embora uma classe geralmente inclui a definição e implementação (ao contrário de interfaces, por exemplo, que contêm apenas a definição sem implementação), ele pode ter um ou mais membros que não possuem implementação.

A tabela a seguir descreve algumas das características que uma classe pode ter. Cada idioma com suporte para o tempo de execução fornece uma maneira para indicar que uma classe ou membro de classe possui um ou mais dessas características. No entanto, individuais de destino de linguagens de programação do.NET Framework não pode fazer todas essas características disponíveis.

Characteristic	Description
sealed	Especifica que outra classe não pode ser derivado desse tipo.
implements	Indicates that the class uses one or more interfaces by providing implementations of interface members.
abstract	Indica que a classe não pode ser instanciada. To use it, you must derive another class from it.
inherits	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 quaisquer membros públicos fornecidos pela classe baseou classe derivada pode substituir a implementação de membros públicos com sua própria implementação.
exported or not exported	Indicates whether a class is visible outside the assembly in which it is defined. Essa característica se aplica somente para classes de nível superior-e não classes aninhadas.

Observação

Uma classe também pode ser aninhados em um pai de classe ou estrutura.Nested classes also have member characteristics.Para obter mais informações, consulte Tipos aninhados.

Class members that have no implementation are abstract members. A class that has one or more abstract members is itself abstract; new instances of it cannot be created. Alguns idiomas que destino o tempo de execução permite marcar uma classe como abstrata mesmo se nenhum dos seus membros abstratos. Você pode usar uma abstrata classe quando você deseja encapsular um conjunto básico de funcionalidade a classes derivadas pode herdar ou substituir quando for apropriado. Classes that are not abstract are referred to as concrete classes.

Uma classe pode implementar qualquer número de interfaces, mas ela pode herdar apenas um classe base além de System.Object, da qual todas as classes que herdam implicitamente. 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 do padrão (sem parâmetros) construtor.

Structures

Uma estrutura é um tipo de valor que deriva implicitamente System.ValueType, que por sua vez é derivada de System.Object. Uma estrutura é muito útil para representar valores cujos requisitos de memória são pequenos e para passar os valores como parâmetros de valor de-para métodos com rigidez de tipos parâmetros. No.NET Framework classe biblioteca, all primitive data types (Boolean, Byte, Char, DateTime, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, and UInt64) are defined as structures.

Como classes, estruturas definem os dados (os campos da estrutura) e as operações que podem ser realizadas em dados (os métodos da estrutura). Isso significa que você pode chamar métodos em estruturas, incluindo os métodos virtuais definidos no System.Object e System.ValueType classes e quaisquer métodos definidos no tipo de valor próprio. Em outras palavras, as estruturas podem ter campos, propriedades e eventos, bem como métodos estático e não estático. Você pode criar instâncias de estruturas, pass-los como parâmetros, armazená-los como variáveis locais ou armazená-los em um campo de tipo de referência. Estruturas também podem implementar interfaces.

Tipos deValor também diferem das classes em vários aspectos. Primeiro, embora eles herdam implicitamente System.ValueType, não podem herdar diretamente de qualquer tipo. Da mesma forma, todos os tipos de valor são selados, que significa que nenhum outro tipo pode ser derivado-los. Eles também não exigem construtores.

Para cada tipo de valor, Common Language Runtime fornece um tipo de processador in a box correspondente, o que é uma classe que tenha o mesmo estado e comportamento como o tipo de valor. Uma instância de um tipo de valor for in a box quando ele é passado para um método que aceita um parâmetro do tipo System.Object. É desemoldurado (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 a partir de uma chamada de método que aceita um tipo de valor como pela referência de- parâmetro. Alguns idiomas exigem que você use a sintaxe especial quando o tipo de processador in a box é necessário; outras pessoas usam o tipo de processador in a box automaticamente quando for necessário. When you define a value type, you are defining both the boxed and the unboxed type.

Enumerations

Uma enumeração (enum) é um tipo de valor que herda diretamente da System.Enum e que fornece nomes alternativos para os valores de um tipo primitivo subjacente. Um tipo de enumeração tem um nome, um tipo subjacente que deve ser a-criado em inteiro com sinal ou tipos (como Byte, Int32, ou UInt64) e um conjunto de campos. The fields are static literal fields, each of which represents a constant. The same value can be assigned to multiple fields. Quando isso ocorrer, você deve marcar um dos valores como o valor de enumeração do principal para conversão de reflexão e seqüência de caracteres.

You can assign a value of the underlying type to an enumeration and vice versa (no cast is required by the runtime). Você pode criar uma instância de uma enumeração e chamar os métodos de System.Enum, bem como quaisquer métodos definidos no tipo subjacente da enumeração. No entanto, alguns idiomas talvez não permitam passar uma enumeração como um parâmetro quando uma instância do tipo subjacente é necessária (ou vice-versa).

The following additional restrictions apply to enumerations:

• They cannot define their own methods.

• They cannot implement interfaces.

• They cannot define properties or events.

• Eles não podem ser genéricos, a menos que eles são genéricos, apenas porque elas são aninhadas dentro de um tipo genérico. That is, an enumeration cannot have type parameters of its own.

  Observação

  Tipos aninhados (incluindo as enumerações) criados com Visual Basic, C# e C++ incluem os parâmetros de tipo de delimitador de todos os tipos genéricos e são genéricos, portanto, mesmo que não tenham parâmetros de tipo de seus próprios.Para obter mais informações, consulte "Tipos aninhados" no Type.MakeGenericType tópico de referência.

O deFlagsAttributeatributo indica um tipo especial de enumeração chamado campobit. The runtime itself does not distinguish between traditional enumerations and bit fields, but your language might do so. When this distinction is made, bitwise operators can be used on bit fields, but not on enumerations, to generate unnamed values. Enumerations are generally used for lists of unique elements, such as days of the week, country or region names, and so on. Bit fields are generally used for lists of qualities or quantities that might occur in combination, such as Red And Big And Fast.

The following example shows how to use both bit fields and traditional enumerations.

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

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

Interfaces

A interface define um contrato que especifica um "pode fazer" relacionamento ou um "tem um" relacionamento. Interfaces geralmente são usados para implementar a funcionalidade, como, por exemplo, comparação e classificação (o IComparable e IComparable<T> interfaces), teste de igualdade (o IEquatable<T> interface), ou itens de uma coleção de enumeração (o IEnumerable e IEnumerable<T> interfaces). Interfaces podem ter propriedades, métodos e eventos, que são membros abstratos; Isto é, embora a interface define os membros e suas assinaturas, ele deixa para o tipo que implementa a interface para definir a funcionalidade de cada membro de interface . Isso significa que qualquer classe ou estrutura que implementa uma interface deve fornecer definições para os membros abstratos declarados na interface. Uma interface pode exigir que qualquer classe ou estrutura para implementar uma ou mais interfaces de implementação.

The following restrictions apply to interfaces:

• An interface can be declared with any accessibility, but interface members must all have public accessibility.

• Interfaces cannot define constructors.

• Interfaces cannot define fields.

• Interfaces podem definir somente os membros de instância. Elas não podem definir membros estático .

Cada linguagem deve fornecer regras para mapeamento uma implementação para a interface que requer o membro, porque mais de uma interface possa declarar um membro com a mesma assinaturae esses membros possam ter implementações separadas.

Delegates

Delegados são tipos de referência para servem um propósito semelhante de ponteiros de função em C++. Eles são usados para manipuladores de evento e funções callback na.NET Framework. Unlike function pointers, delegates are secure, verifiable, and type safe. Um tipo delegado pode representar qualquer método de instância ou estático método tem uma assinaturade compatíveis.

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.

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 delegado que tem um parâmetro do tipo IEnumerable e um tipo de retorno de Object pode representar um método que possui um parâmetro do tipo Object e um valor retornado do tipo IEnumerable. For more information and example code, see Delegate.CreateDelegate(Type, Object, MethodInfo).

Um delegado é considerado limite ao método que ele representa. Para além de ser limite ao método, um delegado pode ser limite a um objeto. O objeto representa o primeiro parâmetro do métodoe é passado para o método sempre que o delegado é chamado. Se o método é um métodode instância, limite objeto é passado como o implícito this parâmetro (Me em Visual Basic); Se o método for estático, o objeto é passado como o primeiro formal parâmetro do métodoe a assinatura do delegado deve coincidir com os parâmetros restantes. For more information and example code, see System.Delegate.

All delegates inherit from System.MulticastDelegate, which inherits from System.Delegate. Os idiomas C#, Visual Basic e C++ não permitem a herança desses tipos. Em vez disso, eles fornecem as palavras-chave para declarar delegados.

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. All methods in the list receive the arguments supplied when the delegate is invoked.

Observação

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, por exemplo, com métodos de retorno de chamada, um delegado representa apenas um método, as únicas ações que você precisa levar estão criando o delegado e invocar.

For delegates that represent multiple methods, the .NET Framework 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 o evento-manipulador delega em C++, C# e Visual Basic, porque essas linguagens fornecem sintaxe para adicionar e remover manipuladores de evento .

Back to top

Type Definitions

Uma definição de tipo inclui o seguinte:

• Any attributes defined on the type.

• Do tipo acessibilidade (visibilidade).

• The type's name.

• The type's base type.

• Any interfaces implemented by the type.

• Definitions for each of the type's members.

Attributes

Attributes provide additional user-defined metadata. Normalmente, 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 tempo de design-ou executar o ambienteem tempo de-.

Atributos são classes que herdam de System.Attribute. Idiomas que suportam o uso de atributos cada têm sua própria sintaxe para aplicar atributos a um elemento de linguagem. Atributos podem ser aplicados a praticamente qualquer elemento de linguagem; os elementos específicos aos quais um atributo pode ser aplicado são definidos pelo AttributeUsageAttribute que é aplicado a essaclassede atributo.

Type Accessibility

Tudo tipos têm um modificador que rege sua acessibilidade de outros tipos. The following table describes the type accessibilities supported by the runtime.

Accessibility	Description
pública	The type is accessible by all assemblies.
assembly	O tipo é acessível somente dentro de seu assembly.

A acessibilidade de um tipo aninhado depende de sua o domínio de acessibilidade, que é determinado pela acessibilidade declarada do membro e o domínio de acessibilidade do tipo imediatamente 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 dentro de um programade P é definido como segue (observando que M si pode ser um tipo):

• Se a acessibilidade declarada de M é public, o domínio de acessibilidade de M é o domínio de acessibilidade de T.

• Se a acessibilidade declarada de M é protected internal, o domínio de acessibilidade de M é a interseção do domínio de acessibilidade da T com o texto do programa de P e o texto do programa de qualquer tipo derivado de T declarada fora de P.

• Se a acessibilidade declarada de M é protected, o domínio de acessibilidade de M é a interseção do domínio de acessibilidade da T com o texto do programa de T e qualquer tipo derivado de T.

• Se a acessibilidade declarada de M é internal, o domínio de acessibilidade de M é a interseção do domínio de acessibilidade da T com o texto do programa de P.

• Se a acessibilidade declarada de M é private, o domínio de acessibilidade de M é o texto do programa de T.

Type Names

The common type system imposes only two restrictions on names:

• All names are encoded as strings of Unicode (16-bit) characters.

• Names are not permitted to have an embedded (16-bit) value of 0x0000.

No entanto, a maioria das linguagens impõem restrições adicionais nos nomes de tipo. Tudo comparações são feitas em um byte- by -byte base e, portanto-de diferenciar maiúsculas de minúsculas e localidade-independentes.

Embora um tipo pode fazer referência a tipos de outros módulos e assemblies, um tipo deve ser totalmente definido dentro de uma.NET Framework módulo. (Dependendo do suporte do compilador, no entanto, ele pode ser dividido em vários arquivos de código fonte .) Nomes deTipo precisam ser exclusivos dentro de um namespace. Para identificar totalmente um tipo, o nome do tipo deve ser qualificado pelo namespace que contém a implementação do tipo.

Base Types and Interfaces

A type can inherit values and behaviors from another type. The common type system does not allow types to inherit from more than one base type.

A type can implement any number of interfaces. To implement an interface, a type must implement all the virtual members of that interface. A virtual method can be implemented by a derived type and can be invoked either statically or dynamically.

Back to top

Type Members

O tempo de execução permite que você definir os membros de seu tipo, especifica o comportamento e estado de um tipo. Os membros doTipo incluem o seguinte:

• Fields

• Properties

• Methods

• Constructors

• Events

• Nested types

Fields

Um campo descreve e contém parte do estado do tipo. Fields can be of any type supported by the runtime. Normalmente, os campos são private ou protected, para que eles sejam acessíveis somente dentro da classe ou de classederivada. Se o valor de um campo pode ser modificado de fora de seu tipo, um assessor set de propriedade normalmente é usado. Campos expostos publicamente são geralmente somente leitura e podem ser de dois tipos:

• Constantes, cujo valor é atribuído em tempo de design. Estes são os membros estático de uma classe, embora eles não são definidos usando o static (Shared em Visual Basic) palavra-chave.

• -De leitura somente variáveis, cujos valores podem ser atribuídos noconstrutorde classe.

O exemplo a seguir ilustra esses dois usos de campos de somente leitura .

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.1417
'    8/18/1974

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.1417
//    8/18/1974

Properties

Uma propriedade nomeia um valor ou o estado do tipo e define métodos para obter ou configuração valor da propriedade. Properties can be primitive types, collections of primitive types, user-defined types, or collections of user-defined types. Properties are often used to keep the public interface of a type independent from the type's actual representation. Isso permite que propriedades para refletir os valores que não são armazenados diretamente na classe (por exemplo, quando uma propriedade retorna um valor calculado) ou para executar a validação antes dos valores são atribuídos a campos particulares. O exemplo a seguir ilustra o último padrão.

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

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

Além de incluindo a propriedade própria, o Microsoft Intermediate Language (MSIL) para um tipo que contém uma propriedade de leitura inclui um get_propertyname métodoe o MSIL para um tipo de uma propriedade de gravável inclui um set_propertyname método.

Methods

Um método descreve operações disponíveis no tipo. Um métodode assinatura Especifica os tipos de todos os seus parâmetros e de seu valor retornado.

Embora a maioria dos métodos de definir o número exato de parâmetros necessária para chamadas de método , alguns métodos oferecem suporte a um número variável de parâmetros. O final é declarado como parâmetro um desses métodos é marcado com o ParamArrayAttribute atributo. Compiladores de linguagem geralmente fornecem uma palavra-chave, como params em C# e ParamArray Visual Basic, que faz uso explícito das ParamArrayAttribute desnecessárias.

Constructors

Um construtor é um tipo especial de método que cria novas instâncias de uma classe ou estrutura. Como qualquer outro método, um construtor pode incluir parâmetros; No entanto, construtores não possuem um valor retornado (ou seja, retornar void).

Se o código fonte para uma classe não definir explicitamente um construtor, o compilador inclui um do padrão (sem parâmetros) construtor. No entanto, se o código fonte para uma classe define apenas os construtores parametrizados, os compiladores de Visual Basic e C# não geram um sem parâmetros do construtor.

Se o código de fonte para uma estrutura define construtores, eles devem ser parametrizados; uma estrutura não é possível definir um construtordo (sem parâmetros) de padrão e compiladores não geram construtores sem parâmetros para estruturas ou outros tipos de valor. Tudo tipos de valor tem um construtorde padrão implícitos. Esse construtor é implementada pelo Common Language Runtime e o inicializa todos os campos da estrutura para seus valores padrão.

Events

Um evento define um incidente que pode ser respondido e define métodos para assinar, cancelar a inscrição em e disparar o evento. Events are often used to inform other types of state changes. For more information, see Tratamento e disparada de eventos.

Nested Types

Um tipo aninhado é um tipo que é um membro de algum outro tipo. Tipos aninhados devem ser rigidamente ligados ao seu tipo de recipiente e não pode ser útil como geral-tipo de finalidade. Tipos aninhados são úteis quando o tipo declarativo usa e cria instâncias do tipo aninhado e uso do tipo aninhado não é exposto na membros públicos.

Tipos aninhados são confusos para alguns desenvolvedores e não devem ser visíveis publicamente a menos que haja uma razão convincente para visibilidade. Em uma biblioteca bem projetada, os desenvolvedores devem ter raramente usar tipos aninhados para instanciar objetos ou declarar variáveis.

Back to top

Características de membros de Tipo

Common type system permite que os membros possuam uma variedade de características; No entanto, idiomas não são necessários para oferecer suporte a todas essas características. A tabela a seguir descreve as características do membro.

Characteristic	Can apply to	Description
abstract	Methods, properties, and events	The type does not supply the method's implementation. Tipos que herdam ou implementam métodos abstratos devem fornecer uma implementação do método. The only exception is when the derived type is itself an abstract type. All abstract methods are virtual.
private, family, assembly, family and assembly, family or assembly, or public	All	Defines the accessibility of the member: private Acessível somente dentro do tipo do membro, ou dentro de um tipo aninhado. family Acessível dentro do mesmo tipo, como o membro e um tipo derivado que herdam dele. assembly Accessible only in the assembly in which the type is defined. family and assembly Accessible only from types that qualify for both family and assembly access. family or assembly Accessible only from types that qualify for either family or assembly access. pública Accessible from any type.
final	Methods, properties, and events	The virtual method cannot be overridden in a derived type.
initialize-only	Fields	The value can only be initialized, and cannot be written after initialization.
instance	Fields, methods, properties, and events	Se um membro não está marcado como static (C# e C++), Shared (Visual Basic), virtual (C# e C++), ou Overridable (Visual Basic), é um membro de instância (não há nenhuma palavra-chavede instância). There will be as many copies of such members in memory as there are objects that use it.
literal	Fields	The value assigned to the field is a fixed value, known at compile time, of a built-in value type. Literal fields are sometimes referred to as constants.
newslot or override	All	Define como o membro interage com os membros herdados que possuem a mesma assinatura: newslot Oculta herdado membros que têm a mesma assinatura. override Replaces the definition of an inherited virtual method. The default is newslot.
static	Fields, methods, properties, and events	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.
virtual	Methods, properties, and events	The method can be implemented by a derived type and can be invoked either statically or dynamically. Se for usada a chamada dinâmica, o tipo da instância que torna a chamada em tempo de execução (em vez do tipo conhecido em tempo de compilar ) determina qual implementação do método é chamada. Para chamar um método de virtual estaticamente, a variável pode ter que ser convertido para um tipo que usa a versão desejada do método.

Overloading

Each type member has a unique signature. Method signatures consist of the method name and a parameter list (the order and types of the method's arguments). Vários métodos com o mesmo nome podem ser definidos dentro de um tipo como diferem de suas assinaturas. When two or more methods with the same name are defined, the method is said to be overloaded. Por exemplo, em System.Char, o IsDigit método está sobrecarregado. Um método terá uma Char. O outro método leva uma String e um Int32.

Observação

O tipo de retorno não é considerado parte de um métodode assinatura.Ou seja, os métodos não podem ser sobrecarregados se diferem somente por tipo de retorno.

Inheriting, Overriding, and Hiding Members

Um tipo derivado herda todos os membros do seu tipo de base; ou seja, esses membros são definidos no e disponíveis para o tipo derivado. The behavior or qualities of inherited members can be modified in two ways:

• A derived type can hide an inherited member by defining a new member with the same signature. Isso pode ser feito para tornar um membro público em privado ou para definir o novo comportamento para um método herdado que está marcado como final.

• A derived type can override an inherited virtual method. 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 pode substituir um método de virtual somente se o método virtual não está marcado como final e o novo método é pelo menos, tão acessível quanto o métodovirtual.

Back to top

Consulte também

Referência

Biblioteca de classes .NET Framework

Conceitos

Common Language Runtime (CLR)