Tipos e membrosTypes and members

Classes e objetosClasses and objects

As classes são as mais fundamentais para os tipos do C#.Classes are the most fundamental of C#’s types. Uma classe é uma estrutura de dados que combina ações (métodos e outros membros da função) e estado (campos) em uma única unidade.A class is a data structure that combines state (fields) and actions (methods and other function members) in a single unit. Uma classe fornece uma definição para instâncias da classe, também conhecida como objetos.A class provides a definition for instances of the class, also known as objects. As classes dão suporte à herança e polimorfismo, mecanismos nos quais classes derivadas podem estender e especializar classes base.Classes support inheritance and polymorphism, mechanisms whereby derived classes can extend and specialize base classes.

Novas classes são criadas usando declarações de classe.New classes are created using class declarations. Uma declaração de classe começa com um cabeçalho.A class declaration starts with a header. O cabeçalho especifica:The header specifies:

  • Os atributos e modificadores da classeThe attributes and modifiers of the class
  • O nome da classeThe name of the class
  • A classe base (ao herdar de uma classe base)The base class (when inheriting from a base class)
  • As interfaces implementadas pela classe.The interfaces implemented by the class.

O cabeçalho é seguido pelo corpo da classe, que consiste em uma lista de declarações de membro escrita entre os delimitadores { e }.The header is followed by the class body, which consists of a list of member declarations written between the delimiters { and }.

O código a seguir mostra uma declaração de uma classe simples chamada Point :The following code shows a declaration of a simple class named Point:

public class Point
{
    public int X { get; }
    public int Y { get; }
    
    public Point(int x, int y) => (X, Y) = (x, y);
}

Instâncias de classes são criadas usando o operador new, que aloca memória para uma nova instância, chama um construtor para inicializar a instância e retorna uma referência à instância.Instances of classes are created using the new operator, which allocates memory for a new instance, invokes a constructor to initialize the instance, and returns a reference to the instance. As instruções a seguir criam dois Point objetos e armazenam referências a esses objetos em duas variáveis:The following statements create two Point objects and store references to those objects in two variables:

var p1 = new Point(0, 0);
var p2 = new Point(10, 20);

A memória ocupada por um objeto é recuperada automaticamente quando o objeto não está mais acessível.The memory occupied by an object is automatically reclaimed when the object is no longer reachable. Não é necessário nem possível desalocar explicitamente objetos em C#.It's neither necessary nor possible to explicitly deallocate objects in C#.

Parâmetros de tipoType parameters

Classes genéricas definem * parâmetros de tipo _.Generic classes define *type parameters _. Parâmetros de tipo são uma lista de nomes de parâmetro de tipo entre colchetes angulares.Type parameters are a list of type parameter names enclosed in angle brackets. Os parâmetros de tipo seguem o nome da classe.Type parameters follow the class name. Em seguida, os parâmetros de tipo podem ser usados no corpo das declarações de classe para definir os membros da classe.The type parameters can then be used in the body of the class declarations to define the members of the class. No exemplo a seguir, os parâmetros de tipo de Pair são TFirst e TSecond:In the following example, the type parameters of Pair are TFirst and TSecond:

public class Pair<TFirst, TSecond>
{
    public TFirst First { get; }
    public TSecond Second { get; }
    
    public Pair(TFirst first, TSecond second) => 
        (First, Second) = (first, second);
}

Um tipo de classe declarado para pegar parâmetros de tipo é chamado de tipo de classe _generic *.A class type that is declared to take type parameters is called a _generic class type*. Os tipos struct, interface e delegate também podem ser genéricos.Struct, interface, and delegate types can also be generic. Quando a classe genérica é usada, os argumentos de tipo devem ser fornecidos para cada um dos parâmetros de tipo:When the generic class is used, type arguments must be provided for each of the type parameters:

var pair = new Pair<int, string>(1, "two");
int i = pair.First;     // TFirst int
string s = pair.Second; // TSecond string

Um tipo genérico com argumentos de tipo fornecidos, como Pair<int,string> acima, é chamado de tipo construído.A generic type with type arguments provided, like Pair<int,string> above, is called a constructed type.

Classes baseBase classes

Uma declaração de classe pode especificar uma classe base.A class declaration may specify a base class. Siga o nome da classe e os parâmetros de tipo com dois-pontos e o nome da classe base.Follow the class name and type parameters with a colon and the name of the base class. Omitir uma especificação de classe base é o mesmo que derivar do object de tipo.Omitting a base class specification is the same as deriving from type object. No exemplo a seguir, a classe base de Point3D é Point .In the following example, the base class of Point3D is Point. No primeiro exemplo, a classe base de Point é object :From the first example, the base class of Point is object:

public class Point3D : Point
{
    public int Z { get; set; }
    
    public Point3D(int x, int y, int z) : base(x, y)
    {
        Z = z;
    }
}

Uma classe herda os membros de sua classe base.A class inherits the members of its base class. Herança significa que uma classe contém implicitamente quase todos os membros de sua classe base.Inheritance means that a class implicitly contains almost all members of its base class. Uma classe não herda a instância e construtores estáticos e o finalizador.A class doesn't inherit the instance and static constructors, and the finalizer. Uma classe derivada pode adicionar novos membros a esses membros que ele herda, mas não pode remover a definição de um membro herdado.A derived class can add new members to those members it inherits, but it can't remove the definition of an inherited member. No exemplo anterior, Point3D herda os X Membros e Y de Point , e cada Point3D instância contém três propriedades, X , Y e Z .In the previous example, Point3D inherits the X and Y members from Point, and every Point3D instance contains three properties, X, Y, and Z.

Existe uma conversão implícita de um tipo de classe para qualquer um de seus tipos de classe base.An implicit conversion exists from a class type to any of its base class types. Uma variável de um tipo de classe pode referenciar uma instância dessa classe ou uma instância de qualquer classe derivada.A variable of a class type can reference an instance of that class or an instance of any derived class. Por exemplo, dadas as declarações de classe anteriores, uma variável do tipo Point podem referenciar um Point ou um Point3D:For example, given the previous class declarations, a variable of type Point can reference either a Point or a Point3D:

Point a = new Point(10, 20);
Point b = new Point3D(10, 20, 30);

EstruturasStructs

Classes definem tipos que dão suporte a herança e polimorfismo.Classes define types that support inheritance and polymorphism. Eles permitem que você crie comportamentos sofisticados com base em hierarquias de classes derivadas.They enable you to create sophisticated behaviors based on hierarchies of derived classes. Por outro lado, os tipos * struct _ são tipos mais simples cujo objetivo principal é armazenar valores de dados.By contrast, *struct _ types are simpler types whose primary purpose is to store data values. Structs não podem declarar um tipo base; Eles derivam implicitamente de System.ValueType .Structs can't declare a base type; they implicitly derive from System.ValueType. Você não pode derivar outros struct tipos de um struct tipo.You can't derive other struct types from a struct type. Eles são lacrados implicitamente.They're implicitly sealed.

public struct Point
{
    public double X { get; }
    public double Y { get; }
    
    public Point(double x, double y) => (X, Y) = (x, y);
}

InterfacesInterfaces

Uma interface define um contrato que pode ser implementado por classes e estruturas.An interface defines a contract that can be implemented by classes and structs. Uma interface pode conter métodos, propriedades, eventos e indexadores.An interface can contain methods, properties, events, and indexers. Uma interface normalmente não fornece implementações dos membros que ele define — ela simplesmente especifica os membros que devem ser fornecidos por classes ou estruturas que implementam a interface.An interface typically doesn't provide implementations of the members it defines—it merely specifies the members that must be supplied by classes or structs that implement the interface.

As interfaces podem empregar várias heranças.Interfaces may employ multiple inheritance. No exemplo a seguir, a interface IComboBox herda de ITextBox e IListBox.In the following example, the interface IComboBox inherits from both ITextBox and IListBox.

interface IControl
{
    void Paint();
}

interface ITextBox : IControl
{
    void SetText(string text);
}

interface IListBox : IControl
{
    void SetItems(string[] items);
}

interface IComboBox : ITextBox, IListBox { }

Classes e structs podem implementar várias interfaces.Classes and structs can implement multiple interfaces. No exemplo a seguir, a classe EditBox implementa IControl e IDataBound.In the following example, the class EditBox implements both IControl and IDataBound.

interface IDataBound
{
    void Bind(Binder b);
}

public class EditBox : IControl, IDataBound
{
    public void Paint() { }
    public void Bind(Binder b) { }
}

Quando uma classe ou struct implementa uma interface específica, as instâncias dessa classe ou struct podem ser convertidas implicitamente para esse tipo de interface.When a class or struct implements a particular interface, instances of that class or struct can be implicitly converted to that interface type. Por exemploFor example

EditBox editBox = new EditBox();
IControl control = editBox;
IDataBound dataBound = editBox;

EnumeraçõesEnums

Um tipo de Enumeração define um conjunto de valores constantes.An Enum type defines a set of constant values. A seguir, as seguintes enum constantes declarações que definem um ou diferente de raiz:The following enum declares constants that define different root vegetables:

public enum SomeRootVegetable
{
    HorseRadish,
    Radish,
    Turnip
}

Você também pode definir um enum para ser usado em combinação como sinalizadores.You can also define an enum to be used in combination as flags. A declaração a seguir declara um conjunto de sinalizadores para as quatro estações.The following declaration declares a set of flags for the four seasons. Qualquer combinação das estações pode ser aplicada, incluindo um All valor que inclui todas as estações:Any combination of the seasons may be applied, including an All value that includes all seasons:

[Flags]
public enum Seasons
{
    None = 0,
    Summer = 1,
    Autumn = 2,
    Winter = 4,
    Spring = 8,
    All = Summer | Autumn | Winter | Spring
}

O exemplo a seguir mostra declarações de ambas as enumerações anteriores:The following example shows declarations of both the preceding enums:

var turnip = SomeRootVegetable.Turnip;

var spring = Seasons.Spring;
var startingOnEquinox = Seasons.Spring | Seasons.Autumn;
var theYear = Seasons.All;

Tipos anuláveisNullable types

Variáveis de qualquer tipo podem ser declaradas como não anuláveis ou anuláveis.Variables of any type may be declared as non-nullable or nullable. Uma variável anulável pode conter um null valor adicional, indicando que não há valor.A nullable variable can hold an additional null value, indicating no value. Tipos de valores anuláveis (structs ou enums) são representados por System.Nullable<T> .Nullable Value types (structs or enums) are represented by System.Nullable<T>. Os tipos de referência não anuláveis e anuláveis são representados pelo tipo de referência subjacente.Non-nullable and Nullable Reference types are both represented by the underlying reference type. A distinção é representada por metadados lidos pelo compilador e por algumas bibliotecas.The distinction is represented by metadata read by the compiler and some libraries. O compilador fornece avisos quando referências anuláveis são desreferenciadas sem primeiro verificar seu valor null .The compiler provides warnings when nullable references are dereferenced without first checking their value against null. O compilador também fornece avisos quando referências não anuláveis são atribuídas a um valor que pode ser null .The compiler also provides warnings when non-nullable references are assigned a value that may be null. O exemplo a seguir declara um int anulável, inicializando-o para null .The following example declares a nullable int, initializing it to null. Em seguida, ele define o valor como 5 .Then, it sets the value to 5. Ele demonstra o mesmo conceito com uma cadeia de caracteres anulável.It demonstrates the same concept with a nullable string. Para obter mais informações, consulte tipos de valor anulável e tipos de referência anuláveis.For more information, see nullable value types and nullable reference types.

int? optionalInt = default; 
optionalInt = 5;
string? optionalText = default;
optionalText = "Hello World.";

TuplasTuples

O C# dá suporte a _ tuplas *, que fornece sintaxe concisa para agrupar vários elementos de dados em uma estrutura de dados leve.C# supports _ tuples*, which provides concise syntax to group multiple data elements in a lightweight data structure. Você cria uma instância de uma tupla declarando os tipos e os nomes dos membros entre ( e ) , conforme mostrado no exemplo a seguir:You instantiate a tuple by declaring the types and names of the members between ( and ), as shown in the following example:

(double Sum, int Count) t2 = (4.5, 3);
Console.WriteLine($"Sum of {t2.Count} elements is {t2.Sum}.");
// Output:
// Sum of 3 elements is 4.5.

As tuplas fornecem uma alternativa para a estrutura de dados com vários membros, sem usar os blocos de construção descritos no próximo artigo.Tuples provide an alternative for data structure with multiple members, without using the building blocks described in the next article.