Início » POO

Arquivo da categoria: POO

C# – Classes

As classes representam a personalidade da orientação a objetos, ou seja, sem elas não existiriam objetos. Com as classes, criamos entidades as quais serão instanciadas; chamamos de objetos as instâncias das classes. Elas contém membros e, a partir do conjunto deles, é formada a interface da classe. Uma classe tem como objetivo principal encapsular membros do tipo dado (como constantes e campos) e também do tipo comportamento (métodos, propriedades, indexers, eventos, operadores, construtores de instância, construtores estáticos e destrutores), além de suportar tipos aninhados. Também suporta herança, tanto de implementação quanto de interfaces.

A definição da classe é feita a partir do comando class, seguida do nome da classe e de seu código entre blocos {}.

class MinhaPrimeiraClasse
{ 
}

A instância de uma classe, ou a criação de um objeto, é feita com o operador new.

MinhaPrimeiraClasse c = new MinhaPrimeiraClasse();

Uma classe pode ter o seguinte conteúdo:

class ConteudoDaClasse
{
	//Para orientação a objetos
	campos
	constantes
	métodos
	construtores
	destrutores
	
	//Para orientação a componentes
	propriedades
	eventos
	
	//Para outros propósitos
	indexers
	sobrecarga de operadores
	tipos aninhados (classes, interfaces, estruturas, enumerações e delegates)
}

Abaixo tem-se a declaração de uma classe e seus itens, precedida das explicações:

[atributos]1 [modificador]2 [modificador de acesso]3 classNome4 : [base]5 {…6} [;]7

  1. Os atributos são opcionais e representam declarações informativas.

  2. O modificador é opcional e influencia o versionamento, o instanciamento e a herança da classe, respectivamente:
    a. new – sobrepõe uma classe base.
    b. abstract – não pode ser instanciado, apenas herdado.
    c. sealed – não pode ser herdado, apenas instanciado.

  3. O modificador de acesso é opcional e influência na visualização ou acessibilidade da classe:
    a. public – acesso, interno e externo, permitido sem restrições.
    b. protected – acesso interno (válido apenas na declaração de uma classe aninhada).
    c. private – acesso restrito (válido apenas na declaração de uma classe aninhada).
    d. internal – acesso permitido somente dentro do assembly.
    e. protected internal – acesso permitido dentro ou for a do assembly por classes derivadas.

  4. O nome da classe.

  5. A lista com a classe base (herança de implementação) e/ou as interfaces (herança de interfaces), as quais serão herdadas pela classe. Esta lista é separada por vírgulas.

  6. Os membros da classe são private se não especificados. Eles podem ser:
    a. Membros tipo dado – mantêm o estado da classe.
    b. Membros tipo função – executam operações.
    c. Tipos aninhados – tipicamente enumerações, delegates e classes.

  7. O finalizador.

As classes representam a principal característica da orientação a objetos. A partir delas, são criados os objetos, que residem na memória e são gerenciados pelo garbage collector.

Referências Bibliográficas:

ALBAHARI, Joseph; ALBAHARI, Ben. C# 3.0: Guia de Bolso. Rio de Janeiro: Alta Books, 2008.
GALUPPO, Fabio; MATHEUS, Vanclei; SANTOS, Wallace. Desenvolvendo com C#. Porto Alegre: Bookman, 2004.

C# – Namespaces

Em C#, um namespace é um mecanismo de controle da visibilidade de nomes dentro de um programa. Ele agrupa classes e tipos por semântica e é declarado com a palavra-chave namespace. O exemplo abaixo ilustra a criação de um agrupamento de classes utilizando um namespace.

namespace MinhaEmpresa
{
    public class Cliente
    {
        public string Nome;
        public string Telefone;
    }

    public class Fornecedor
    {
        public string Contato;
        public string Telefone;
    }
}

Para instanciar a classe Cliente, é necessário usar seu nome completo:

MinhaEmpresa.Cliente cliente = new MinhaEmpresa.Cliente();

No contexto de utilização de um namespace, a diretiva using tem o papel de simplificar o uso desses agrupamentos, seja encurtando o caminho para eles ou estabelecendo um alias, ou seja, importa um namespace.

Por exemplo, para instanciar uma classe Queue do .NET Framework, a qual representa uma fila, é necessário chama-la pelo seu nome completo, System.Collections.Queue. A diretiva using colocada no início do programa simplifica a forma de uso da classe. Uma ou mais diretivas podem ser colocadas no início do programa.

using System;
using System.Collections;

public class Fila
{
    public static void Main()
    {
        Queue fila = new Queue(5);

        //int
        fila.Enqueue(1);    
        //string
        fila.Enqueue("2");
        //char
        fila.Enqueue('3');
        //long
        fila.Enqueue(4L);
        //double
        fila.Enqueue(5F);

        Console.WriteLine("Esta fila possui {0} elementos", fila.Count);

        for (int a=0, 1=fila.Count; a < 1; ++a)
        {
            Console.WriteLine(fila.Dequeue().ToString());
        }
    }
}

O programa acima poderia ser escrito sem a utilização da diretiva using; porém, onde existem as classes Queue e Console, estas deveriam ser renomeadas para System.Collections.Queue e System.Console, respectivamente. A diretiva using elimina certas redundâncias, como a necessidade de usar o nome completo.

Nos namespaces aninhados, todos os nomes apresentados em namespaces externos são importados implicitamente para os namespaces internos. No exemplo abaixo, os nomes Middle e Class1 são importados implicitamente para Inner:

namespace Outer
{
    namespace Middle
    {
        class Class1 { }

        namespace Inner
        {
            class Class2 : Class1 { }
        }
    }
}

O namespace mais interno é chamado de inner namespace, e o mais externo é chamado de outer namespace.

Outra forma de escrever um namespace é simplificar o namespace aninhado para torna-lo longo. Isso é feito utilizando-se o operador ponto (.) para separar os nomes que comportarão o namespace.

namespace Terra.AmericaDoSul.Brasil.SaoPaulo
{
    class MinhaClasse { }
}

Para acessar a classe MinhaClasse, referencie o nome completo ou utilize a diretiva using para facilitar o acesso.

Terra.AmericaDoSul.Brasil.SaoPaulo.MinhaClasse classe;

Os namespaces longos e aninhados podem ser combinados.

Importar um namespace pode resultar em um choque com o nome de tipo. Em vez de importar o namespace inteiro, você pode importar apenas os tipos específicos de que necessita, atribuindo um alias (apelidos) a cada tipo. Por exemplo:

using PropertyInfo2 = System.Reflection.PropertyInfo;

class Program 
{
    PropertyInfo2 p;
}

Um namespace extenso pode ter um alias caractere, conforme abaixo:

using R = System.Reflection;

class Program
{
    R.PropertyInfo p;
}

Concluindo:

  • O namespace é um recurso que permite a organização por semântica e, se aplicado corretamente, evita a colisão de nomes.
  • Um namespace pode ser encontrado na forma simples, aninhado ou longo.
  • O principal objetivo de um namespace é criar um nome global único que o diferencie dos demais.
  • A diretiva using é usada em conjunto com um namespace para encurtar o caminho até os tipos contidos nele. Com using, é permitido a criação de alias.
  • Os namespaces podem ser agrupados e ter sua origem em diversos códigos, bibliotecas e módulos.

Referências Bibliográficas:

ALBAHARI, Joseph; ALBAHARI, Ben. C# 3.0: Guia de Bolso. Rio de Janeiro: Alta Books, 2008.
GALUPPO, Fabio; MATHEUS, Vanclei; SANTOS, Wallace. Desenvolvendo com C#. Porto Alegre: Bookman, 2004.

Estrutura de um Programa em C#

C# é uma linguagem de programação orientada a objetos de uso geral e com segurança de tipos, cujo objetivo é a produtividade do programador. Para este fim, a linguagem equaciona simplicidade, expressividade e desempenho.

Abaixo, temos o esquema de um programa em C#, apresentando alguns dos seus elementos mais comuns:


//Estrutura do programa C#

//Usando um namespace
using System;

//Namespace
namespace MeuNamespace                                      
{
    //Classe
    public class MinhaAplicacao                               
    {
        //Comentários de linhas múltiplas
        /*Este programa                                     
         exibe no prompt
         um cálculo de soma*/

        static void Main(string[] args)
        //Início de bloco
        {
            MinhaClasse m = new MinhaClasse();
            Console.WriteLine(m.Soma(100, 10));
        //Fim de bloco
        }

        //Comentário XML
        ///<summary>        
        ///Minha Classe Math                               
        ///</summary>

        public class MinhaClasse
        {
            //Método
            public int Soma(int a, int b) {return a + b;}   
        }
    }
}

A estrutura de um programa em C# pode ser dividida em um ou mais arquivos contendo os seguintes elementos:

  • Namespaces;
  • Tipos (classes, estruturas, interfaces, delegações, enums);
  • Membros (constantes, campos, métodos, propriedades, indexadores, eventos, operadores, construtores);
  • Outros (declarações, comentários, instruções).

No decorrer das semanas, postarei como cada elemento citado acima funciona num programa desenvolvido em C#.

Referências Bibliográficas:

ALBAHARI, Joseph; ALBAHARI, Ben. C# 3.0: Guia de Bolso. Rio de Janeiro: Alta Books, 2008.
GALUPPO, Fabio; MATHEUS, Vanclei; SANTOS, Wallace. Desenvolvendo com C#. Porto Alegre: Bookman, 2004.

Conceitos Básicos de POO (Programação Orientada a Objetos) para C# – Parte 2

Continuação do artigo Conceitos Básicos de POO (Programação Orientada a Objetos) para C# – Parte 1.

  • O que é herança?

– As classes podem ser especializadas (ou generalizadas).
– Base conceitual para permitir a estensibilidade e reusabilidade.
– Define um relacionamento “is-a” ou “a-kind-of”.
– Utiliza-se herança para:
-> Criar especialização de classes e objetos existentes.
-> Adicionar novos dados e comportamentos, conhecido como estender ou especial.

  • Herança no C#

– O caractere : é usado para indicar que uma classe herda de outra. Por exemplo: public class Elefante : Animal
– Modificadores de acesso fazem diferença na relação de herança: public, protected, internal, protected internal e private.
– Modificadores: abstract, virtual, override e sealed.

  • Modificadores de acesso

– Dada uma classe A, os campos e métodos podem ter os seguintes modificadores:
-> public: o aesso é ilimitado para qualquer classe ou qualquer assembly.
-> protected: o acesso é limitado aos métodos da própria classe ou os membros das classes derivadas, em qualquer assembly.
-> internal: o acesso é limitado a todas as classes no mesmo assembly.
-> protected internal: o acesso é limitado ao assembly ou aos membros das classes derivadas.
-> private: o acesso é limitado a própria classe.

  • Classes abstratas

– Definidas com propósito de herança.
– Uma classe abstrata não pode ser instanciada.
– Cria-se uma definição comum que será compartilhada pelas classes derivadas.
– Pode definir métodos abstratos (declarados com abstract), não tem implementação e terminam com ; .
– Uma classe sealed não pode ser abstract.

  • Overriding

– Mecanismo que permite uma classe derivada redefinir (sobrescrever) um comportamento (método) herdado da sua classe base.
– O modificador override é requerido para estender ou modificar a implementação abstrata ou virtual de um membro herdado: método, indexador, propriedade ou evento.
– O método da classe base que é sobrescrito deve ser virtual ou abstract ou override.
– O método da classe derivada que sobrescreve deve receber o modificador override.

  • Operador sealed

– Pode ser aplicado a classes, métodos de instância e propriedades.
– Uma classe sealed não pode ser herdada.
– Um método sealed pode sobrescrever um método de uma classe base mas ele não pode ser sobrescrito numa classe derivada.
– Quando aplicado a um método ou propriedade, deve sempre ser usado com override.
– É um erro usar uma classe sealed como classe base ou usar com o modificador abstract.

  • O que é polimorfismo?

– Quando comportamentos relacionados variam segundo o tipo (classe), atribuir responsabilidades pelo comportamento.
– Dar o mesmo nome a serviços executados por diferentes objetos, quando estes são similares ou relacionados.
– Os diferentes tipos de objetos são, normalmente, relacionados em uma hierarquia que tenha uma superclasse comum (não é obrigatório, pois pode ser obtido através de interfaces ou vinculação dinâmica).

Tratamento de exceções

  • Por que usar exceções?

– Uma forma ultrapassada e trabalhosa de manipular erros.

  • Blocos try-catch-finally

– Solução OO para tratamento de erros.
– Cada bloco try-catch trata um tipo de exceção.
– O try demarca a parte do código que pode ser afetada por uma exceção.
– O catch usado para filtrar os erros de acordo com o tipo da exceção, que pode ser Exception ou qualquer classe derivada.
– O finally pode ser usado para executar código que será executado independente de acontecer erro.
– Você pode capturar uma exceção e lançar outra mais específica.

Manipulação e formatação de strings, números, data/hora e moeda

  • O tipo Object

– System.Object
– Classe base de todas as classes. Qualquer classe herda, direta ou indiretamente, de object.
– Métodos comuns para todos os tipos por referência:
-> ToString: converte objetos para string.
-> Equals: indica se duas referências são iguais.
-> GetType: retorna o tipo de instância.
-> Finalize: permite o objeto executar alguma limpeza ou liberação de recursos antes de ser removido pelo Garbage Collector.
->GetHashCode: função hash para tipo específico.

  • O tipo String

– System.String
– Representa um conjunto de caracteres Unicode (System.Char) que são usados para representar texto.
– O valor de uma string é o conteúdo de uma coleção seqüencial e é imutável (seu valor não é alterado).
– Os métodos oferecidos pela string não alteram a própria string, retornam uma nova string que contém a alteração.
– Fornece métodos para comparar objetos strings, retornar a posição de uma caractere ou um texto em uma string, copiar o valor da string, particionar uma string, formatação de número, data e hora (String.Format).

  • Concatenação de Strings

– A classe StringBuilder é adequada para concatenação de String quando não se conhece a quantidade de strings que serão concatenadas.
– Mantém um buffer para acomodar a concatenação de novos dados.
– Os caracteres individuais de um StringBuilder podem ser acessados através da propriedade Chars.
– Sempre aloca memória, diferente do StringBuilder que só aloca quando o buffer é pequeno para alocar a nova string.
– A classe String é recomendada quando se conhece o número de strings que serão concatenadas.

  • Data e hora com C#

– struct DateTime
– Cálculos numa variável DateTime não alteram o valor da variável, e sim retornam um novo DateTime com resultado do cálculo.
– TimeSpan representa um intervalo de tempo.
– Fornece várias propriedades e métodos para facilitar a manipulação de data e hora.
– DateTime.Now, DateTime.Year, DateTime.Month, DateTime.TimeOfDay, DateTime.Add, DateTime.AddDays, DateTime.DaysInMonth, DateTime.IsLeapYear, DateTime.ToString

Leitura e escrita de arquivos

  • Namespace System.IO

– Stream é uma classe abstrata para todos os tipos de streams, ou seja, uma abstração de uma seqüência de bytes (um arquivo), um dispositivo de entrada/saída, um fluxo de comunicação entre processos ou um socket TCP/IP.
– A classe Stream e suas derivadas fornecem uma visão genérica de diferentes tipos de entrada/saída, isolando o programador dos detalhes do SO e dispositivos em questão.
– Propriedades: CanRead, CanSeek e CanWrite.
– Read e Write: lê e escreve dados em varios formatos.
– O método Close libera os recursos do SO, tais como memória, conexões de rede e arquivos.

  • Arquivos

– Algumas classes usadas para manipular arquivos:
-> Directory: fornece métodos estáticos para criar, mover e listar diretórios e subdiretórios.
-> DriveInfo: acessa informações sobre discos.
-> File: fornece métodos estáticos para criar, mover, excluir, copiar e abrir arquivos.
-> FileStream: acesso randômico ao arquivo através do Seek.
-> GzipStream: método para compactação e descompactação.
-> SerialPort: métodos para controle da porta serial.

  • Stream

– BinaryReader/Writer: lê/escreve string codificadas e tipos primitivos.
– StreamReader/Writer: lê/escreve caracteres de um stream, usando a classe Encoding para converter para byte.
– StringReader/Writer: lê/escreve caracteres para uma string, permitindo tratar Strings com a mesma API, então a saída pode ser um Stream em qualquer codificação ou uma string.
– TextReader: classe abstrata para StreamReader e StringReader.
– TextWriter: classe abstrata para StreamWriter e StringWriter.

O conteúdo foi reproduzido do MSDN.

Andrielle Azevedo de Paula
MTAC – Microsoft Technical Audience Contributor

Conceitos Básicos de POO (Programação Orientada a Objetos) para C# – Parte 1

Olá. Primeiramente, quero dizer que resolvi postar esse artigo sobre conceitos básicos de POO aplicados em C# pela sua grande importância. Quem realmente está disposto a aprender programas em C# não pode simplesmente começar a trabalhar com linhas de código sem saber o que está usando nas mesmas. Sabe-se que a linguagem de programação C# é orientada a objetos e, sendo assim, é importante saber o que são classes, métodos, construtores dentre vários outros nomes e conceitos que teremos dentro da POO. Sendo assim, bons estudos!

  • O que são classes?

– Tipos mais importantes do C#.
– É uma estrutura de dados que combina estado (campos) e comportamentos (métodos e outros membros).
– Fornecem a definição da estrutura das instâncias que serão criadas dinamicamente, os objetos.
– Suportam os mecanismos de herança e polimorfismo, que permitem uma classe derivada estender e especializar uma classe base.
– A declaração de uma classe especifica os atributos e modificadores da classe, o nome da classe, a classe base (se herdar de alguma) e as interfaces implementadas (se existir).
– Instâncias da classe, objetos, são criadas usando o operador “new”.
– A criação de uma instância aloca memória para o objeto criado, invoca o construtor para inicializar o objeto e retorna a referência para a instância.
– O objeto alocado, quando não mais referenciado, será limpado da memória pelo objeto Garbage Collector.
– Tem-se: constantes, campos, métodos, propriedades, indexadores, eventos, operadores, construtores, destrutores e tipos.

Constantes: os valores constantes que são associados a classe.
Campos: as variáveis da classe.
Métodos: executados pela classe.
Propriedades: as ações para leitura e escrita de propriedades.
Indexadores: as ações associadas com instâncias indexadas da classe da mesma forma que um array.
Eventos: as notificações que podem ser geradas pela classe.
Operadores: os operadores de conversão e expressão suportados pela classe.
Construtores: as ações necessárias para inicializar as instâncias da classe ou ela mesma.
Destrutores: as ações executadas antes das instâncias da classe serem removidas.
Tipos: classes declaradas dentro de outra classe.

  • O que são objetos?

– Representa uma instância de uma classe.
– Identidade: todo objeto é único e pode ser distinguido de outros objetos.
– Estado: determinado pelos dados contidos no objeto.
– Comportamentos: representados pelos serviços / métodos / operações que o objeto disponibiliza.
– Representa alguma coisa do mundo real. Exemplo: aluno, cliente, computador, carro.

  • O que são construtores?

– Instância, privado e estático.
– Construtores de instância são utilizados para criar e inicializar instâncias de uma classe.
– O construtor sem parâmetros é o construtor padrão.
– Se a classe não define um construtor, o construtor padrão é gerado automaticamente e os campos são inicializados com valores padrão.
– É declarado da mesma forma que um método, exceto que não tem tipo de retorno (e nem void) e deve ter o mesmo nome da classe.
– Construtores de instância podem ser sobrecarregados e são invocados com o operador new.
– Construtores da classe derivada podem ser chamados pela classe base.

  • O que são interfaces?

– Define um contrato que pode ser implementado pelas classes e structs.
– Pode conter métodos, propriedades, eventos e indexadores.
– Não fornece implementação para os membros definidos.
– Basicamente, define os membros que devem ser implementados pelas classes e structs que a implementam.
– Classes e structs podem implementar mais de uma interface.
– Quando uma classe ou struct implementa uma interface, instâncias da classe ou struct podem ser implicitamente convertidas para o tipo da interface.

  • Visibilidade dos membros

– Cada membro da classe tem uma visibilidade associada e ele, que controla as áreas de código que podem acessá-lo.

Public: acesso ilimitado
Protected: acesso limitado ao this e as classes derivadas.
Internal: acesso limitado ao assembly.
Protected internal: acesso limitado ao assembly e as classes derivadas.
Private: acesso limitado a classe.

  • O que são métodos?

– É um membro da classe que implementa uma ação que pode ser executada por um objeto ou pela classe.
– Métodos estáticos são acessados através da classe.
– Métodos de instância (não estáticos) são acessados através das instâncias da classe.
– Pode ter uma lista de parâmetros, que representa os valores ou referências de variáveis que são passadas para o método; e um tipo de retorno, que indica o que é retornado pelo método.
– O método que tem como tipo de retorno void, indica que não retorna um valor.
– A assinatura do método deve ser única na classe, e é formada pelo nome e número, modificadores e tipos dos parâmetros.

  • Métodos: parâmetros

– São usados para passar valores ou variáveis por referência para os métodos.
– Os parâmetros obtém seus valores dos argumentos que são passados para os métodos no momento da execução.
– Existem 4 tipos de parâmetros: por valor, por referência, de saída e arrays.

  • Métodos: sobrecarga

– Permite que métodos numa mesma classe tenham o mesmo nome mas assinaturas diferentes.
– Quando sobrecarregados, os métodos são localizados pelo compilador de acordo com a sua lista de parâmetros.
– Um método específico pode ser selecionado através da conversão dos parâmetros esperados.

  • O que são propriedades?

– Representam uma extensão dos campos. A propriedade tem o mesmo tipo de campo, e a sintaxe para acessá-la é a mesma do campo.
– Diferentemente dos campos, as propriedades não representam um local de armazenamento, e têm comando específico para leitura (get) e escrita (set).
– Declaradas da mesma forma que um campo, exceto que a declaração termina com get e/ou set.
– C# suporta propriedades com instância (sem static) e propriedades estáticas (com static).
– Podem ser declaradas com virtual, abstract ou override.

  • O que são enum e struct?

– Enum
-> Define uma lista de constantes nomeadas.
-> Pode ser definido como qualquer tipo integral, exceção char. O tipo padrão é o int.
– Struct
-> Uma struct compartilha quase todas as mesmas características de uma classe, mas com algumas restrições.
-> Objetos do tipo struct são destruídos automaticamente pelo compilador, até porque é um Tipo por Valor.
-> Structs não podem herdar de outra classe ou outra struct.

  • O que é um namespace?

– É um mecanismo que permite declarar um escopo, onde você organiza os tipos e declara tipos únicos.
– São declarados: outro namespace, class, interface, struct, enum e delegate.
– O nome de um namespace pode ser qualquer identificador e conter . no nome.
– Mesmo se não for declarado um namespace, um padrão será criado.
– É possível declarar um ou mais namespaces numa mesma declaração.

Manipulando vários objetos

  • O que são arrays?

– É uma seqüência de elementos.
– Todos os elementos são do mesmo tipo.
– Structs podem ter elementos de tipos diferentes.
– Cada elemento do array é acesso através de um número inteiro que representa o índice.

  • Arrays: dimensões

long [] linha;
– Uma dimensão. Um índice associado a cada elemento long do array.

int [,] matriz;
– Duas dimensões. Dois índices associados a cada elemento int.

  • Arrays: criação e inicialização

– A declaração da variável array não cria o array.
– Você deve usar o operador new para criar a instância do array.

long [] linha = new long [4];
int [,] matriz = new int [2,3];

//Listando array com duas dimensões
public static void ArrayMultiDim() {
//Declara e inicializa um array de duas dimensões
int [,] arrayMulti = new int [,] {{1,2}, {3,4}, {5,6}, {7,8}};
//Navegando por todos os elementos usando for
Console.WriteLine(“\nListando um array de duas dimensões”);
       for (int i=0;i<arrayMulti.GetLength(0);i++) {
            for (int j=0;j<arrayMulti.GetLength(1);j++) {
                 Console.Write(“{0}”, arrayMulti[i,j]);
                 }
            Console.WriteLine();
            }
}
  • O que são coleções?

– São classes especializadas para armazenamento e busca de objetos, com suporte a listas, filas, pilhas e tabelas hash.
– Permitem manipular vários objetos ao mesmo tempo, com métodos para adicionar, remover, modificar um elemento ou um intervalo.
– São definidas nos namespaces System.Collections e System.Collections.Generic.
– Coleções genéricas sao fortemente tipadas e melhoram a performance com tipos por valor.

  • Coleções genéricas

– São classes e métodos que combinam reusabilidade, tipagem forte e eficiência que não são oferecidos pelas coleções não genéricas.
– Suportam tipos por valor sem a necessidade de boxing e unboxing.
– Algumas coleções genéricas:
List : a classe genérica que corresponde a ArrayList.
Dictionary : corresponde a HashTable.
Collection : corresponde a CollectionBase.
Queue , Stack e SortedList : correspondem as não genéricas de mesmo nome.
LinkedList , SortedDictionary e KeyedCollection .

Delegates e eventos

  • O que são delegates?

– Representa uma referência para métodos com uma lista de parâmetros e retorno específicos.
– Permite tratar métodos como entidades que podem ser atribuídas a uma variável ou passadas como parâmetros.
– É um conceito similar ao conceito de ponteiro de função em algumas linguagens, mas diferem porque são OO e tipados.
– Para o delegate só importa o método que ele referencia, e não a classe.

  • O que são eventos?

– É um membro que permite uma classe ou objeto fornecer notificações.
– É declarado da mesma forma que um campo, exceto que deve ter event na declaração e ser do tipo delegate.
– O campo do tipo evento armazena uma referência a um delegate que representa o manipulador do evento (event handler) que foi adicionado. Se não existir, o campo é null.
– Event handlers são atachados usando o operador += e removidos usando ==.
– O objeto que tem o evento (publicador) lança um evento, ou seja, uma mensagem aos objetos interessados (assinantes).

O conteúdo foi reproduzido do MSDN.

Andrielle Azevedo de Paula
MTAC – Microsoft Technical Audience Contributor