12 05 2009
Namespaces, Classes Parciais e Métodos Virtuais em C#
1. Introdução
Este artigo abordará, com exemplos práticos, alguns conceitos básicos do .Net Framework, que são os Namespaces, Classes Parciais e Métodos Virtuais.
Esses temas são básicos para quem está iniciando, mas muitas pessoas acabam ficando com dúvidas e até mesmo acabam utilizando-os de maneira errada. Iniciemos então com o primeiro tema – namespaces.
2. Namespaces
O conceito de namespace foi criado para nos ajudar a organizar melhor nossos códigos. Eles podem ser entendidos como “categorias” ou “blocos” que contêm trechos de código.
Um bom exemplo de utilização de namespaces é encontrado no próprio .Net Framework, que é todo separado em categorias – ou namespaces (System.Data, System.Collections, System.IO, etc.).
Quando criamos um projeto, o Visual Studio já cria um namespace utilizando o mesmo nome do projeto. Então, se criarmos uma Console Application em C# utilizando o nome NamespacesDemo, o Visual Studio nos criará o seguinte trecho de código:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace NamespacesDemo
{
class Program
{
static void Main(string[] args)
{
}
}
}
Pelo trecho de código acima, podemos notar que a declaração de namespaces em C# é feita através da palavra reservada namespace seguida do nome que desejamos associar ao namespace criado.
2.1. Aninhamento de Namespaces
Com o aninhamento de namespaces, podemos incluir namespaces dentro de outros.
Abaixo temos um exemplo de como poderia ser a estrutura de namespaces de um sistema relacionado à educação:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace NamespacesDemo
{
namespace Matematica
{
namespace Algebra
{
class MatematicaAlgebra
{
private int _codigo;
public int Codigo
{
get { return _codigo; }
set { _codigo = value; }
}
}
}
}
namespace Fisica
{
namespace Mecanica
{
}
}
}
Podemos notar que dentro do namespace “NapespacesDemo”, temos outros dois namespaces: “Matematica” e “Fisica”, e estes também contêm outros namespaces.
2.2. A cláusula “using”
Para utilizarmos as classes de outros namespaces que não o atual, podemos informar no código o caminho completo da classe (incluindo o namespace), como podemos verificar no código abaixo, que utiliza a classe MatematicaAlgebra do namespace NamespacesDemo.Matematica.Algebra:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace NamespacesDemo
{
class Cliente
{
private void UsaMatematica()
{
Matematica.Algebra.MatematicaAlgebra _meuObjeto = new Matematica.Algebra.MatematicaAlgebra();
}
}
}
Outra opção para acessarmos a mesma classe sem utilizar o caminho completo da mesma, seria definir seu namespace utilizando a palavra reservada using.
Com isso, nosso código ficaria o seguinte:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NamespacesDemo.Matematica.Algebra;
namespace NamespacesDemo
{
class Cliente
{
private void UsaMatematica()
{
MatematicaAlgebra _meuObjeto = new MatematicaAlgebra();
}
}
}
2.3. Apelidos de namespaces
Podemos criar apelidos para nossos namespaces, também chamados de aliases. Para isso, podemos utilizar a seguinte sintaxe:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using alg = NamespacesDemo.Matematica.Algebra;
namespace NamespacesDemo
{
class Cliente
{
private void UsaMatematica()
{
alg.MatematicaAlgebra _meuObjeto = new alg.MatematicaAlgebra();
}
}
}
3. Classes Parciais
O conceito de classes parciais presente no .Net Framework serve para dividir o código de nossas estruturas em dois ou mais arquivos fonte. As estruturas passíveis a essa divisão são classes, structs e interfaces.
As classes parciais nos possibilitam uma melhor organização do nosso código, visto que podemos distribuir o código de uma classe grande em vários arquivos (por exemplo, podemos escrever os atributos, propriedades e construtores da classe em um fonte e os métodos e funções em outro fonte).
Abaixo veremos um exemplo de uma classe chamada Coordenada que foi dividida em dois arquivos fonte: Coordenada.cs e CoordenadaMetodos.cs:
Coordenada.cs:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace NamespacesDemo
{
public partial class Coordenada
{
private int _x;
public int X
{
get { return _x; }
set { _x = value; }
}
private int _y;
public int Y
{
get { return _y; }
set { _y = value; }
}
}
}
CoordenadaMetodos.cs:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace NamespacesDemo
{
public partial class Coordenada
{
public void PrintCoordenadas()
{
Console.WriteLine(this._x.ToString() + " " + this._y);
}
}
}
Como podemos verificar nos códigos acima, separamos os atributos e propriedades da classe Coodenada no arquivo fonte Coordenada.cs e o método PrintCoordenadas no arquivo fonte CoordenadaMetodos.cs.
Para indicar que uma classe está dividida em mais de um arquivo fonte, utilizamos a palavra reservada partial.
Ao compilar o código, o .Net acaba juntando o conteúdo dos dois arquivos fonte em um só, para chegar ao código completo da classe Coordenada.
Se repararmos nos arquivos criados ao adicionarmos um form em um projeto Windows Forms, percebemos que o Visual Studio na verdade separa o código em dois arquivos: um fonte contém o código de design do form, que vai sendo criado pelo Visual Studio ao customizarmos suas propriedades pelo editor visual e outro fonte contém o restante do código do form (implementação de eventos, métodos, etc.).
4. Métodos Virtuais
Métodos virtuais foram criados para que as linguagens orientadas a objetos expressem o polimorfismo, ou seja, a permissão de escrevermos um método em uma classe derivada com a mesma assinatura da classe base. Em C#, para indicar que um método poderá ser escrito com a mesma assinatura em uma classe derivada, utilizamos a palavra reservada virtual na classe base e a palavra reservada override na classe derivada, como podemos verificar no código abaixo:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace NamespacesDemo
{
class FormaGeometrica
{
public virtual void ImprimeFormulaDaArea()
{
Console.WriteLine("Sem saber a forma, eu nao sei a formula da area.");
}
}
class Circulo : FormaGeometrica
{
public override void ImprimeFormulaDaArea()
{
base.ImprimeFormulaDaArea();
Console.WriteLine("A formula do Circulo é pi * r^2");
}
}
}
Como podemos observar, o exemplo acima implementa duas classes: FormaGeometrica e Circulo (que é uma especificação da classe FormaGeometrica).
O método ImprimeFormulaDaArea foi definido como virtual na classe base, o que indica que ele poderá ser sobreposto por um método nas classes que a herdarem.
Isso é o que pode ser verificado na implementação do mesmo método na classe derivada Circulo, onde utilizamos a palavra reservada override, para indicar que esse código é uma sobreposição do método com mesmo nome da classe base.
Se quisermos ainda executar também o código da classe base, além do código da classe derivada, podemos utilizar a palavra reservada base, como foi feito com a chamada base.ImprimeFormulaDaArea no código acima.
Bom, vamos ficando por aqui. Espero que tenham gostado e, até a próxima!
André Lima
Evitar expansão da TreeView ao clicar no "+" Munique / Alemanha
Muito legal!Reforçar e lembrar conceitos nunca é demai! :-)Para quem está começando, conceito importantes escritos de forma simples!Valeu André!