Programação orientada a objeto (C# e Visual Basic)

  • Artigo

Tudo gerenciado em idiomas do.NET Framework, como, por exemplo, Visual Basic e C# oferecem suporte completo para programação orientada a objeto, incluindo o encapsulamento, herança e polimorfismo.

Encapsulamento significa que um grupo de propriedades, métodos e outros membros relacionados são tratados como unidade ou um objeto único.

Herança descreve a habilidade de se criarem novas classes baseadas em uma classe pré-existente.

Polimorfismo significa que você pode ter múltiplas classes que podem ser usadas intercambiavelmente, mesmo que cada classe implemente as mesmas propriedades e métodos de modos diferentes.

Esta seção descreve os seguintes conceitos:

  • Classes e Objetos

    • Membros de classe

      Propriedades e campos

      Métodos

      Construtores

      Destructors

      Eventos

      Classes aninhadas

    • Modificadores de acesso e níveis de acesso

    • Instanciação de Classes

    • Estático (compartilhado) Classes e membros

    • Tipos Anônimos

  • Herança

    • Substituindo membros

  • Interfaces

  • Genéricos

  • Delegados

Classes e Objetos

Os termos classe e objeto algumas vezes são usados alternadamente, mas na verdade, as classes descrevem o tipo de de objetos, enquanto objetos são utilizáveis instâncias de classes. Portanto, o ato de criar um objeto é chamado de instanciação. Usando a analogia da planta, a classe é a planta, e o objeto é a construção feita daquela planta.

Para definir uma classe:

Class SampleClass
End Class

class SampleClass
{
}

Visual Basic e C# também fornecem uma versão light de classes chamado estruturas que são úteis quando você precisa criar uma matriz grande de objetos e não deseja consumir muita memória para que.

Para definir uma estrutura:

Structure SampleStructure
End Structure

struct SampleStruct
{
}

Para obter mais informações, consulte:

Membros de classe

Cada classe pode ter diferentes membros da classe que incluem propriedades que descrevem os dados de classe, métodos que definem o comportamento da classe e eventos que fornecem comunicação entre diferentes classes e objetos.

Propriedades e campos

Campos e propriedades representam informações que um objeto contém. Campos são como variáveis, porque eles podem ser lidos ou alterados diretamente.

Para definir um campo:

Class SampleClass
    Public SampleField As String
End Class

Class SampleClass
{
    public string sampleField;
}

Propriedades tem get e set procedimentos, que oferecem mais controle sobre como os valores são definidos ou retornados.

C# e Visual Basic permitem que você criar um campo privado para armazenar o valor da propriedade ou usar propriedades implementado para auto supostas que criar esse campo automaticamente em segundo plano e fornecem a lógica básica para os procedimentos de propriedade.

Para definir uma propriedade de auto-implementada:

Class SampleClass
    Public Property SampleProperty as String
End Class

class SampleClass
{
    public int SampleProperty { get; set; }
}

Se você precisar executar algumas operações adicionais para ler e gravar o valor de propriedade, definir um campo para armazenar o valor da propriedade e fornecer a lógica básica para armazenar e recuperar a ele:

Class Samplelass
    Private m_Sample As String
    Public Property Sample() As String
        Get
            ' Return the value stored in the field.
            Return m_Sample
        End Get
        Set(ByVal Value As String)
            ' Store the value in the field.
            m_Sample = Value
        End Set
    End Property
End Class

class SampleClass
{
    private int _sample;
    public int Sample
    {
        // Return the value stored in a field.
        get { return _sample; }
        // Store the value in the field.
        set { _sample = value; }
    }
}

A maioria das propriedades têm métodos ou procedimentos para definir e obter o valor da propriedade. No entanto, você pode criar propriedades somente leitura ou somente gravação restringi-los contra modificação ou ler. Visual Basic você pode usar ReadOnly e WriteOnly palavras-chave. No C#, você pode omitir o get ou set método de propriedade. No entanto, em Visual Basic e C#, implementado em auto propriedades não podem ser somente leitura ou somente para gravação.

Para obter mais informações, consulte:

Métodos

A método é uma ação que um objeto pode executar.

ObservaçãoObservação

Em Visual Basic, há duas maneiras para criar um método: o Sub declaração é usada se o método não retornar um valor; o Function declaração é usada se um método retorna um valor.

Para definir um método de uma classe:

Class SampleClass
    Public Function SampleFunc(ByVal SampleParam As String)
        ' Add code here
    End Function
End Class

class SampleClass
{
    public int sampleMethod(string sampleParam)
    {
        // Insert code here
    }
}

Uma classe pode ter várias implementações, ou sobrecargas, do mesmo método que diferem no número de parâmetros ou tipos de parâmetro.

Para sobrecarregar um método:

Overloads Sub Display(ByVal theChar As Char)
    ' Add code that displays Char data.
End Sub
Overloads Sub Display(ByVal theInteger As Integer)
    ' Add code that displays Integer data.
End Sub

public int sampleMethod(string sampleParam) {};
public int sampleMethod(int sampleParam) {}

Na maioria dos casos, você declara um método dentro de uma definição de classe. No entanto, Visual Basic e C# também suportam métodos de extensão que permitem que você adicione métodos para uma classe existente fora da definição real da classe.

Para obter mais informações, consulte:

Construtores

Construtores são os métodos de classe que são executados automaticamente quando um objeto de um determinado tipo é criado. Construtores geralmente inicializar os membros de dados do novo objeto. Um construtor pode ser executado apenas uma vez que uma classe é criada. Além disso, o código no construtor é executado sempre antes de qualquer outro código em uma classe. No entanto, você pode criar várias sobrecargas do construtor da mesma maneira que qualquer outro método.

Para definir um construtor para uma classe:

Class SampleClass
    Sub New(ByVal s As String)
        // Add code here.
    End Sub
End Class

public class SampleClass
{
    public SampleClass()
    {
        // Add code here
    }
}

Para obter mais informações, consulte:

Destructors

Destruidores são usadas para instâncias de classes de destruct. No.NET Framework, o coletor de lixo gerencia automaticamente a alocação e liberação de memória para os objetos gerenciados no seu aplicativo. No entanto, talvez ainda seja necessário usar destruidores para limpar os recursos não gerenciados que seu aplicativo cria. Pode haver apenas um destruidor de uma classe.

Para obter mais informações sobre destruidores e coleta de lixo na.NET Framework, consulte Coleta de Lixo.

Eventos

Eventos permitem uma classe ou objeto para notificar outras classes ou objetos quando algo interessante ocorre. A classe que envia o evento (ou gera uma) é chamada de publisher e as classes que recebem (ou manipulam) os eventos são chamadas de assinantes. Para obter mais informações sobre eventos, como eles são disparados e manipulados, consulte Tratamento e disparada de eventos.

Classes aninhadas

Uma classe definida dentro de outra classe é chamada de aninhadas. Por padrão, a classe aninhada é particular.

Class Container
    Class Nested
    ' Add code here.
    End Class
End Class

class Container
{
    class Nested
    {
        // Add code here.
    }
}

Para criar uma instância da classe aninhada, use o nome da classe de contêiner, seguido do ponto e, em seguida, seguido pelo nome da classe aninhada:

Dim nestedInstance As Container.Nested = New Container.Nested()

Container.Nested nestedInstance = new Container.Nested()

Modificadores de acesso e níveis de acesso

Todas as classes e membros de classe podem especificar qual nível de acesso que eles fornecem a outras classes usando modificadores de acesso.

Os modificadores de acesso a seguir estão disponíveis:

Modificador de Visual Basic

Modificador de C#

Definição

Público (Visual Basic)

Público

O tipo ou membro pode ser acessado por qualquer outro código no mesmo assembly ou outro conjunto que faz referência a ele.

Private (Visual Basic)

Particular

O tipo ou membro só pode ser acessado pelo código na mesma classe.

Protegido (Visual Basic)

Protegido

O tipo ou membro só pode ser acessado pelo código na mesma classe ou em uma classe derivada.

Friend (Visual Basic)

interno

O tipo ou membro pode ser acessado por qualquer código no mesmo assembly, mas não a partir de outro assembly.

Protected Friend

protected internal

O tipo ou membro pode ser acessado por qualquer código no mesmo assembly, ou por qualquer classe derivada em outro assembly.

Para obter mais informações, consulte Níveis de acesso em Visual Basic e Modificadores de acesso (guia de programação C#).

Instanciação de Classes

Para criar um objeto, você precisará criar uma instância de uma classe ou criar uma instância de classe.

Dim sampleObject as New SampleClass()

SampleClass sampleObject = new SampleClass();

Após instanciar uma classe, você pode atribuir valores aos campos e as propriedades da instância e chamar métodos da classe.

' Set a property value.
sampleObject.SampleProperty = "Sample String"
' Call a method.
sampleObject.SampleMethod()

// Set a property value.
sampleObject.sampleProperty = "Sample String";
// Call a method.
sampleObject.sampleMethod();

Para atribuir valores a propriedades durante o processo de instanciação de classe, use os inicializadores de objeto:

Dim sampleObject = New SampleClass With 
    {.FirstProperty = "A", .SecondProperty = "B"}

// Set a property value.
SampleClass sampleObject = new SampleClass 
    { FirstProperty = "A", SecondProperty = "B" };

Para obter mais informações, consulte:

Estático (compartilhado) Classes e membros

Um membro estático (compartilhado no de Visual Basic) da classe é uma propriedade, procedimento ou campo que é compartilhado por todas as instâncias de uma classe.

Para definir o membro estático (compartilhado):

Class SampleClass
    Public Shared SampleString As String = "Sample String"
End Class

static class SampleClass
{
    public static string SampleString = "Sample String";
}

Para acessar o membro estático (compartilhado), use o nome da classe sem criar um objeto desta classe:

MsgBox(SampleClass.SampleString)

Console.WriteLine(SampleClass.SampleString);

Estáticos (compartilhados) classes C# e módulos de Visual Basic possuem membros (compartilhados) estáticos somente e não podem ser instanciados. Membros (compartilhados) estáticos também não é possível acessar métodos, campos ou propriedades do non-static (não compartilhado)

Para obter mais informações, consulte:

Tipos Anônimos

Tipos anônimos permitem que você crie objetos sem escrever uma definição de classe para o tipo de dados. Em vez disso, o compilador gera uma classe para você. A classe sem nome utilizável e contém as propriedades que você especificar no declarando o objeto.

Para criar uma instância de um tipo anônimo:

' sampleObject is an instance of a simple anonymous type.
Dim sampleObject = 
    New With {Key .FirstProperty = "A", .SecondProperty = "B"}

// sampleObject is an instance of a simple anonymous type.
var sampleObject = 
    new { FirstProperty = "A", SecondProperty = "B" };

Para obter mais informações, consulte:

Herança

A herança permite que você crie uma nova classe que reutiliza, amplia e modifica o comportamento que é definido em outra classe. A classe cujos membros são herdados é chamada a classe base, e a classe que herda esses membros é chamada a classe derivada. No entanto, todas as classes C# e Visual Basic implicitamente herdam o classeObject que ofereça suporte.NET a hierarquia de classe e fornece serviços de baixo nível para todas as classes.

ObservaçãoObservação

Gerenciado em idiomas do.NET Framework não oferecem suporte a herança múltipla, isto é Você pode especificar somente uma classe base para uma classe derivada.

Para herdar de uma classe base:

Class DerivedClass
    Inherits BaseClass
End Class

class DerivedClass:BaseClass{}

Por padrão, todas as classes podem ser herdadas. No entanto, você pode especificar se uma classe não deve ser usada como uma classe base ou cria uma classe que pode ser usada como uma classe base somente.

Para especificar que uma classe não pode ser usada como uma classe base:

NotInheritable Class SampleClass
End Class

public sealed class A { }

Para especificar que uma classe pode ser usada como uma classe base somente e não pode ser instanciada:

MustInherit Class BaseClass
End Class

public abstract class B { }

Para obter mais informações, consulte:

Substituindo membros

Por padrão, uma classe derivada herda todos os membros da sua classe base. Para alterar o comportamento do membro herdado, você precisará substituí-la. Ou seja, você pode definir uma nova implementação do método, propriedade ou evento na classe derivada.

Seguintes modificadores são usados para controlar como os métodos e propriedades são ignorados:

Modificador de Visual Basic

Modificador de C#

Definição

Overridable (Visual Basic)

(referência C#) virtual

Permite que um membro de classe para ser substituído em uma classe derivada.

Overrides (Visual Basic)

Substituir (referência C#)

Substitui (substituível) membro virtual definido na classe base.

NotOverridable (Visual Basic)

Sem suporte

Impede que um membro que está sendo substituído em uma classe herdada.

MustOverride (Visual Basic)

abstract (referência C#) 

Requer que um membro de classe para ser substituído na classe derivada.

Shadows (Visual Basic)

novo Modificador (referência de TRANSLATION FROM VPE FOR CSHARP)

Oculta um membro herdado de uma classe base

Interfaces

Interfaces, como classes, definem um conjunto de propriedades, métodos e eventos. Mas, diferentemente das classes, interfaces não fornecem implementação. Eles são implementados pelas classes e definidos como entidades separadas das classes. Uma interface representa um contrato em que uma classe que implementa uma interface deve implementar todos os aspectos da interface exatamente como ela está definida.

Para definir uma interface:

Public Interface ISampleInterface
    Sub DoSomething()
End Interface

interface ISampleInterface
{
    void doSomething();
}

Para implementar uma interface em uma classe:

Class SampleClass
    Implements ISampleInterface
    Sub doSomething
        ' Method implementation.
    End Sub
End Class

class SampleClass : ISampleInterface
{
    void ISampleInterface.SampleMethod()
    {
        // Method implementation.
    }
}

Para obter mais informações, consulte:

Genéricos

Classes, estruturas, interfaces e métodos do.NET Framework pode parâmetros de tipo que definem os tipos de objetos que podem armazenar ou usar. O exemplo mais comum de genéricos é uma coleção, onde você pode especificar o tipo de objetos sejam armazenados em uma coleção.

Para definir uma classe genérica:

Class SampleGeneric(Of T)
    Public Field As T
End Class

Public class SampleGeneric<T> 
{
    public T Field;
}

Para criar uma instância de uma classe genérica:

Dim sampleObject As New SampleGeneric(Of String)
sampleObject.Field = "Sample string"

SampleGeneric<string> sampleObject = new SampleGeneric<string>();
sampleObject.Field = "Sample string";

Para obter mais informações, consulte:

Delegados

A delegar é um tipo que define uma assinatura de método e pode fornecer uma referência a qualquer método com uma assinatura compatível. Você pode chamar (ou ligue) o método através do delegado. Delegados são usados para passar de métodos como argumentos para outros métodos.

ObservaçãoObservação

Manipuladores de eventos são nada mais do que os métodos que são chamados por meio de representantes. Para obter mais informações sobre como usar delegados na manipulação de eventos, consulte Eventos e representantes.

Para criar um delegado:

Delegate Sub SampleDelegate(ByVal str As String)

public delegate void SampleDelegate(string str);

Para criar uma referência a um método que corresponde à assinatura especificada pelo delegado:

Class SampleClass
    ' Method that matches the SampleDelegate signature.
    Sub SampleSub(ByVal str As String)
        ' Add code here.
    End Sub
    ' Method that instantiates the delegate.
    Sub SampleDelegateSub()
        Dim sd As SampleDelegate = AddressOf SampleSub
        sd("Sample string")
    End Sub
End Class

class SampleClass
{
    // Method that matches the SampleDelegate signature.
    public static void sampleMethod(string message)
    {
        // Add code here.
    }
    // Method that instantiates the delegate.
    void SampleDelegate()
    {
        SampleDelegate sd = sampleMethod;
        sd("Sample string");
    }
}

Para obter mais informações, consulte:

Consulte também

Conceitos

Guia de Programação C#

Outros recursos

Guia de programação Visual Basic