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!