Marcelo « Desenvolvedores.Net

Para um melhor entendimento deste Artigo veja o Índice (Programação Orientada a Objetos)

Esta imagem não tem muito a ver com informática.
mas gostei dela por se tratar de uma imagem abstrata.

Abstração e Interface

Abstração
Para entendermos o que é abstração e interface em programação, vamos entender primeiro o conceito.Abstração quer dizer que devemos considerar as qualidades e comportamentos independentes dos objetos a que pertencem, isolamos seus atributos considerando o que certo grupo de objetos têm em comum.

Vamos imaginar uma mesa, todos nós iremos imaginar uma mesa que tenha pés, uma base e uma finalidade. Mas não importa quantos pés, ou tipo de base ou a finalidade da mesa. Isso não fará com que a mesa que eu imaginei, deixe de ser uma mesa. Ela sempre será uma mesa.

Em programação iremos dizer ao computador para ser um objeto mesa. Mas antes disso precisamos dizer a este objeto qual seria a sua estrutura inicial. Neste caso teremos uma classe abstrata Mesa.

Classes abstratas como vocês já devem ter percebido servem como base para outras classes que queiram ser do mesmo grupo de objetos.

Uma classe abstrata não pode ser criada, quer dizer que não pode ser instanciada. Não podemos usar o new para criar um novo objeto de uma classe abstrata. Uma classe abstrata só pode ser herdada, e todo método, propriedade, evento que for abstrato deverá ser implementado pela classe filha.
Vamos declarar a nossa classe Mesa, que irá servir de base para as outras mesas.

namespace Desenvolvedores.Net.AbstracaoInterface
{
public enum TipoMesa
{
Redonda,
Quadrada,
Retangular
}

public enum TipoBase
{
Vidro,
Madeira,
Aluminio
}

/*
* aqui declaramos a nossa classe
* como abstrata
*/
public abstract class Mesa : IMesa
{

public Mesa()
{
Pes = 4;
}

/*
* reparem que as propriedades não são abstratas,
* não é obrigatório.
* Declare como asbtrato apenas o que você deseja
* que seja implementado nas classes filhas
*/
public TipoBase Base { get; set; }
public TipoMesa Tipo { get; set; }
public int Pes { get; set; }

/*
* aqui irei ter propriedades abstratas para servir de exemplo
*/
public abstract bool Quebrada { get; set; }
public abstract string Finalidade { get; }

/*
* Aqui teremos um método abstrato, onde a classe filha
* será obrigatória a implementar
*/
public abstract void Quebrar();

public virtual void Consertar()
{
Quebrada = false;
}

public override string ToString()
{
return "Olá. Eu sou uma mesa do tipo " +
Tipo.ToString() + " e minha base é de " +
Base.ToString() + ".\nEu tenho " + Pes.ToString() + " pés. " +
"E minha finalidade é " + Finalidade.Trim() + "\n" +
"*".PadLeft(80, '*');
}

}
}

Agora temos uma classe abstrata que será nossa base para todas as nossas mesas.

Antes de continuar, vamos falar sobre interfaces.

Interfaces
Interfaces são como as classes abstratas, mas nelas não podemos implementar nenhum método, apenas declarar suas assinaturas.
Uma classe ao herdar uma interface deverá escrever todos os seus métodos (iremos ver isso em Herança de Interface nos próximos artigos), ao contrário da classe abstrata que só iremos escrever os métodos abstratos.
Com o tempo você aprenderá a ver qual é mais útil dependendo da situação é mais vantajoso usar uma classe abstrata ou uma interface. Não existe uma regra para definir isso, mas sim a necessidade de uma ou de outra.

Por boas práticas, todas as interfaces começa com I, vamos declarar nossa interface IMesa.

namespace Desenvolvedores.Net.AbstracaoInterface
{
interface IMesa
{
TipoBase Base { get; set; }
string Finalidade { get; }
bool Quebrada { get; set; }
TipoMesa Tipo { get; set; }
int Pes { get; set; }

void Consertar();
void Quebrar();
}
}

Percebam que a nossa interface IMesa tem todos os métodos e propriedades para fazer de outra classe uma Mesa, e vejam também que eu não escrevi nenhum código nela, apenas declarei as assinaturas dos métodos e propriedades. 🙂

Exemplo de Uso
Agora como exemplo de uso iremos criar alguns tipos de mesas.
Crie uma aplicação console em C#.

Copie os códigos abaixo.

Uma mesa redonda. Estamos herdando aqui a classe abstrata Mesa.

namespace Desenvolvedores.Net.AbstracaoInterface
{
/*
* repare que ao herdarmos a classe
* abstrata Mesa. Só escrevemos os métodos e propriedades
* que foram definidos como abstrato na classe pai Mesa.
*/
public class MesaRedonda : Mesa
{
public override bool Quebrada { get; set; }
public override string Finalidade
{
get { return "para discutir futebol."; }
}

public override void Quebrar()
{
Quebrada = true;
}
}
}

Agora aqui uma mesa de jantar, que também herda a classe abstrata Mesa.

namespace Desenvolvedores.Net.AbstracaoInterface
{
/*
* repare que ao herdarmos a classe
* abstrata Mesa. Só escrevemos os métodos e propriedades
* que foram definidos como abstrato na classe pai Mesa.
*/
class MesaDeJantar : Mesa
{
public override bool Quebrada { get; set; }

public override string Finalidade
{
get { return "para jantares em família."; }
}

public override void Quebrar()
{
Quebrada = true;
}
}
}

Agora aqui uma mesa de escritório. Nela herdamos a interface, reparem que tive que desenvolver todo o código para a classe filha, a interface apenas trouxe a assinatura dos métodos.

namespace Desenvolvedores.Net.AbstracaoInterface
{
/*
* Nesta classe herdamos apenas a interface IMesa.
* Vejam que tive que escrever todo o código para a classe.
* A interface trouxe apenas as assinaturas dos métodos.
*(herança de interface)
* No caso de uma classe abstrata não há a necessidade
* de se fazer todos os métodos (herança de implementação)
*/
class MesaEscritorio : IMesa
{
public MesaEscritorio()
{
Pes = 4;
}

public TipoBase Base { get; set; }

public string Finalidade
{
get { return "para trabalhar."; }
}

public bool Quebrada { get; set; }

public TipoMesa Tipo { get; set; }

public int Pes { get; set; }

public void Consertar()
{
Quebrada = false;
}

public void Quebrar()
{
Quebrada = true;
}

public override string ToString()
{
return "Olá. Eu sou uma mesa do tipo " +
Tipo.ToString() + " e minha base é de " +
Base.ToString() + ".\nEu tenho " + Pes.ToString() + " pés. " +
"E minha finalidade é " + Finalidade.Trim() + "\n" +
"*".PadLeft(80, '*');
}
}
}

E finalmente. A aplicação de exemplo:

namespace Desenvolvedores.Net.AbstracaoInterface
{
class Program
{
static void Main(string[] args)
{
//aqui criamos os nossos objetos da forma tradicional
MesaRedonda mesaRedonda = new MesaRedonda();
mesaRedonda.Base = TipoBase.Madeira;
Console.WriteLine(mesaRedonda.ToString());

MesaDeJantar mesaJantar = new MesaDeJantar();
mesaJantar.Tipo = TipoMesa.Retangular;
Console.WriteLine(mesaJantar.ToString());

MesaEscritorio mesaEscritorio = new MesaEscritorio();
mesaEscritorio.Tipo = TipoMesa.Quadrada;
Console.WriteLine(mesaEscritorio.ToString());
Console.WriteLine("Usando a interface e a classe abstrata " +
"para criar novas mesas\n" + "*".PadLeft(80,'*'));

//aqui iremos usar um pouco de polimorfismo
//que iremos discutir tambem em nossos próximos artigos
//logo, não se preocupe em saber a definição
//apenas atente para o uso da interface e da classe abstrata
//como tipo de variável

//a minha mesa pode ser de escitório.
IMesa iMesa = new MesaEscritorio();
iMesa.Tipo = TipoMesa.Redonda;
iMesa.Base = TipoBase.Madeira;

Console.WriteLine(iMesa.ToString());

//de jantar
iMesa = new MesaDeJantar();
iMesa.Base = TipoBase.Aluminio;
Console.WriteLine(iMesa.ToString());

//ou redonda
iMesa = new MesaRedonda();
Console.WriteLine(iMesa.ToString());

//e alem da interface eu posso usar a própria classe
//abstrata para definir o meu tipo de mesa
Mesa mesa = new MesaDeJantar();
Console.WriteLine(mesa.ToString());

mesa = new MesaRedonda();
mesa.Tipo = TipoMesa.Quadrada;
mesa.Base = TipoBase.Vidro;
Console.WriteLine(mesa.ToString());

Console.ReadKey();
}
}
}

Bom. espero ter respondido às dúvidas sobre abstração.
Só para reforçar, é simples. Deixe nas classes abstratas ou interfaces, todos os métodos que serão comuns aos seus objetos do mesmo grupo. Assim sendo, sempre que você declarar uma variável de um tipo Interface ou classe Abstrata poderá criar qualquer tipo de objeto que implemente uma das duas.

É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

: Abstração, abstract, abstrata, Instância de um objeto, interface, Object-Oriented, Objetos, OOP, Orientada, POO, Programação, Programming

About Marcelo

Tipos Genéricos (Generics) (POO)

(2 votos, média: 5,00 de 5)

8 de janeiro de 2011

Para um melhor entendimento deste Artigo veja o Índice (Programação Orientada a Objetos)

Tipos Genéricos (Generics)
Tipos genéricos ou programação genérica é simples de entender.
Imagine que você não saiba o tipo de objeto que a sua classe, método ou propriedade vai receber como parâmetro ou retorno, neste caso você pode usar Generics.
Vamos pegar como exemplo uma Janela, eu não sei o tipo de janela que irei ter, ela pode ser uma veneziana, uma janela basculante ou uma janela de correr, logo vou declarar a minha classe como “Generics” vejamos como fazer isso:

namespace Desenvolvedores.Net.ExemploGenerics
{
class Janela<T>
{
public Janela()
{
/*
* aqui temos que instanciar a nossa propriedade
* Tipo com um valor default.
* para que ao acessarmos a mesma não retorne erro.
*/

Tipo = (T)Activator.CreateInstance<T>();
}

//podemos usar no construtor
public Janela(T _tipo)
{
/*
* aqui não precisamos fazer como foi feito no construtor acima,
* pois já estamos passando o tipo
*/
Tipo = _tipo;
}

//na propriedade
public T Tipo { get; set; }

public bool Aberta { get; set; }

public bool Quebrada { get; set; }

public void Quebrar()
{
Quebrada = true;
}

public void Consertar()
{
Quebrada = false;
}

public void Abrir()
{
Aberta = true;
}

public void Fechar()
{
Aberta = false;
}

//como tipo de parâmetro em métodos
public void SetTipo(T value)
{
Tipo = value;
}

//como retorno em métodos
public T GetTipo()
{
return Tipo;
}

}
}

No código acima, reparem na linha selecionada a declaração está assim:
class Janela<T> , este <T> identifica que iremos ter um tipo genérico para a classe, logo, se usramos em uma herança as classes filhas terão que informar qual o tipo que iremos usar.

Janela do tipo Euroglass.

namespace Desenvolvedores.Net.ExemploGenerics
{
class Euroglass : Janela<Euroglass>
{
}
}

Percebam também que podemos usar o tipo <T> em qualquer lugar da nossa classe, Métodos, Propriedades, Construtores.

Vejamos abaixo as declarações de nossas classes de janelas que iremos usar para testes.

Janela Basculante:

namespace Desenvolvedores.Net.ExemploGenerics
{
public enum TipoEixo
{
Horizontal,
Vertical
}

class Basculante
{
public TipoEixo Eixo { get; set; }
}
}

Janela Veneziana:

namespace Desenvolvedores.Net.ExemploGenerics
{
public enum TipoLamina
{
Fixa,
Movel
}
class Veneziana
{
public TipoLamina Lamina { get; set; }
}
}

Janela de Correr:

namespace Desenvolvedores.Net.ExemploGenerics
{
class DeCorrer
{
public void Correr()
{
Console.WriteLine("A Janela correu");
}
}
}

Agora vamos a um exemplo de uso:
Crie uma aplicação console em C#.
e cole o código abaixo:

namespace Desenvolvedores.Net.ExemploGenerics
{
class Program
{
static void Main(string[] args)
{
//Aqui iremos declarar uma janela basculante
Janela<Basculante> basculante = new Janela<Basculante>();

//veja que ao acessar a propriedade Tipo,
            //teremos a propriedade Eixo, que vem do tipo Basculante
if (basculante.Tipo.Eixo == TipoEixo.Horizontal)
Console.WriteLine("Janela basculante com eixo horizontal");
else
Console.WriteLine("Janela basculante com eixo vertical");

//vamos agora a outro tipo de janela, janela de correr
Janela<DeCorrer> correr = new Janela<DeCorrer>();

//chamaremos o método que existe no tipo de janela Correr
correr.Tipo.Correr();

//aqui modificaremos um pouco a chamada
            //para ver o uso do construtor
Veneziana venez = new Veneziana();
venez.Lamina = TipoLamina.Movel;
Janela<Veneziana> veneziana = new Janela<Veneziana>(venez);

if (veneziana.Tipo.Lamina == TipoLamina.Fixa)
Console.WriteLine("Janela veneziana com lâminas fixas");
else
Console.WriteLine("Janela veneziana com lâminas móveis");

//modificaremos o tipo de lâmina para teste
veneziana.Tipo.Lamina = TipoLamina.Fixa;
if (veneziana.Tipo.Lamina == TipoLamina.Fixa)
Console.WriteLine("Janela veneziana com lâminas fixas");
else
Console.WriteLine("Janela veneziana com lâminas móveis");

Console.ReadKey();
}
}
}

Terminamos aqui a explicação básica do tipo genérico, vamos agora ver alguns tópicos avançados. Do jeito que nossa classe janela foi declarada ela aceita qualquer tipo de objeto, ou seja, podemos declarar a nossa janela assim:

Janela<Porta> porta = new Janela<Porta>();

Mas eu não quero permitir que a nossa Janela seja uma porta, logo temos que restringir o tipo de objetos que <T> irá aceitar, deste modo podemos usar a declaração where, que irá nos ajudar a restringir o tipo que irá ser usado em <T>.
Para isso, primeiro temos que criar uma interface, é ela que iremos usar como filtro para os tipos.

namespace Desenvolvedores.Net.ExemploGenerics
{
interface IJanela
{
}
}

Após criado a interface, modificamos a nossa classe Janela para restringir o uso de de tipos em <T>. Veja:

namespace Desenvolvedores.Net.ExemploGenerics
{
class Janela<T> where T : IJanela
{
public Janela()
{
/*
* aqui temos que instanciar a nossa propriedade
* Tipo com um valor default.
* para que ao acessarmos a mesma não retorne erro.
*/

Tipo = (T)Activator.CreateInstance<T>();
}

//podemos usar no construtor
public Janela(T _tipo)
{
/*
* aqui não precisamos fazer como foi feito no construtor acima,
* pois já estamos passando o tipo
*/
Tipo = _tipo;
}

//na propriedade
public T Tipo { get; set; }

public bool Aberta { get; set; }

public bool Quebrada { get; set; }

public void Quebrar()
{
Quebrada = true;
}

public void Consertar()
{
Quebrada = false;
}

public void Abrir()
{
Aberta = true;
}

public void Fechar()
{
Aberta = false;
}

//como tipo de parâmetro em métodos
public void SetTipo(T value)
{
Tipo = value;
}

//como retorno em métodos
public T GetTipo()
{
return Tipo;
}

}
}

Veja na linha selecionada a declaração class Janela<T> where T : IJanela o uso de where T : IJanela, onde usamos o where, isso indica que só iremos aceitar objetos que implementem a interface IJanela.
Logo se compilarmos o código de exemplo iremos ter erros do tipo:

The type ‘Desenvolvedores.Net.ExemploGenerics.Basculante’ cannot be used as type parameter ‘T’ in the generic type or method ‘Desenvolvedores.Net.ExemploGenerics.Janela<T>’. There is no implicit reference conversion from ‘Desenvolvedores.Net.ExemploGenerics.Basculante’ to ‘Desenvolvedores.Net.ExemploGenerics.IJanela’.

E assim para todos os outros tipos, para isso temos que corrigir as declarações de nossas classes. Veja:

Janela Basculante:

namespace Desenvolvedores.Net.ExemploGenerics
{
public enum TipoEixo
{
Horizontal,
Vertical
}

class Basculante: IJanela
{
public TipoEixo Eixo { get; set; }
}
}

Janela Veneziana:

namespace Desenvolvedores.Net.ExemploGenerics
{
public enum TipoLamina
{
Fixa,
Movel
}
class Veneziana: IJanela
{
public TipoLamina Lamina { get; set; }
}
}

Janela de Correr:

namespace Desenvolvedores.Net.ExemploGenerics
{
class DeCorrer: IJanela
{
public void Correr()
{
Console.WriteLine("A Janela correu");
}
}
}

Pronto. Isso fará com que as nossas classes de tipo de Janelas possam ser usadas em nossa Janela<T>, e não permitirá mais o uso do tipo Porta.
Repare que todas elas implementam a interface IJanela. Podemos também usar generics para determinar o tipo de retorno em um método ou para determinar o tipo de parâmetro.
Veja:

namespace Desenvolvedores.Net.ExemploGenerics
{
class Generics
{
//retorno com um tipo Genérico
public T RetornarTipoGenerico<T>()
{
int x = 10;
int y = 10;
object ret = x + y;

ret = Convert.ChangeType(ret, typeof(T));
return (T)ret;
}

//tipo de parâmetro genérico
public void ParametroGenerico<T>(T _Param1)
{
Console.WriteLine("O parâmetro 1 e do tipo " +
_Param1.GetType().ToString() +
". E seu valor é de " + _Param1.ToString());
}
}
}

Reparem que aqui eu não declarei na classe, e sim no declaração do método. Exemplo de uso:

static void Main(string[] args)
{
Generics g = new Generics();

Console.WriteLine(g.RetornarTipoGenerico<string>());

g.ParametroGenerico<double>(4);

Console.ReadKey();
}

Podemos ter múltiplas declaracões de genéricos, veja:

class Janela<T, K>
{
}

E podemos também restringir seus tipos:

class Janela<T, K>
where T : IJanela
where K : ICloneable
{
}

E isto vale para os métodos também.

/// <summary>
/// Exemplo de múltiplos genéricos
/// </summary>
/// <typeparam name="R">define o retorno do método</typeparam>
/// <typeparam name="P">define o tipo de parâmetro para o método
/// </typeparam>
/// <param name="param1">parâmetro 1</param>
/// <returns>R</returns>
public R MultiplosGenericos<R, P>(P param1)
{
return (R)new object();
}

O intuito deste artigo foi introduzir o conceito de generics, com o tempo você ira descobrir que seu uso é bastante útil.

É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

: Generics, Objetos, OOP, Orientada, POO, Programação, Programming, Tipo Genérico

About Marcelo

Definições – Avançado (POO)

(4 votos, média: 4,50 de 5)

7 de janeiro de 2011

Para um melhor entendimento deste Artigo veja o Índice (Programação Orientada a Objetos)

Generalização
Generalização é o ato de tornar um objeto geral, agrupar características comuns para objetos dentro de um mesmo contexto, abstrair.
Eu tenho, por hábito e não por regra, a minha classe “Pai de Todas”(superclass) ser sempre abstrata.Veja o diagrama:
Neste caso a minha classe “Pai de Todas”(superclass) é a classe “Pessoa”

Se olharmos de cima para baixo podemos ver todos os objetos gerais, no topo temos a Pessoa, que pode ser um Cliente, um Usuário. O Usuário por sua vez pode ser um Administrador, que tem poderes especiais, o mesmo pode Excluir ou Inserir novos usuários.
E se olharmos de baixo para cima? Aí teremos o próximo tópico Especialização. 🙂

Especialização
A especialização nada mais é do que a parte que “especializa” o objeto vindo de uma Generalização, trazer características próprias para o objeto. Seria o mesmo que olhar o diagrama acima de baixo para cima.
Veja:
O objeto Administrador especializa o objeto Usuario que por sua vez especializa o objeto Pessoa.

Delagates
Os delegates são ponteiros para funções (métodos).

O que são ponteiros?
Ponteiro é um valor atribuído em memória que aponta para outro valor em memória através de seu endereço. (não gostei, técnico demais pro meu gosto).

Quando há a necessidade de usarmos métodos, e ainda não sabemos qual método chamar, pois dependemos de algumas condições, podemos deixar o nosso código mais bonito usando um delegate.

O delegate irá chamar o método definido de acordo com a nossa necessidade ou condição.

Veja exemplo:
Abaixo temos um exemplo de uma aplicação Console em C#.

static class Program
    {
        //declara a assinatura do delegate.
        //os métodos deverão ter a mesma assinatura
        //para que possam ser utilizados pelo delegate
        delegate int Calular(int a, int b);

        static void Main()
        {

            //declara a variável do tipo delegate
            Calular calc;

            //uma condição qualquer
            if (DateTime.Now.Second % 2 == 0)
                //define o método dividir para ser usado no delegate
                calc = new Calular(Dividir);
            else
                //define o método somar para ser usado no delegate
                calc = new Calular(Somar);

            //chama o método
            Console.WriteLine(calc.Invoke(DateTime.Now.Millisecond,
DateTime.Now.Second));

            Console.ReadKey();
        }

        //declara o método somar
        private static int Somar(int a, int b)
        {
            return a + b;
        }

        private static int Dividir(int x, int y)
        {
            return x / y;
        }
    }

Eventos
Eventos são mensagens trocadas pelos sistemas, métodos e objetos para informar um acontecimento, uma ação que se inicia, que termina dentro da aplicação, como o próprio nome diz, um evento ocorrido.
Vejamos, ao chamar o nosso método Andar() em Pessoa podemos informar que a Pessoa está Andando até que pare de andar , ou podemos informar que a pessoa vai parar de Andar antes de realmente ela parar de Andar. (AntesPararAndar), assim sendo o objeto chamante pode executar alguma ação antes de a Pessoa realmente parar de Andar.

Exemplo de eventos em C#:
Para usar eventos em C# temos que fazer uso de delegates como foi visto acima o delegate e um ponteiro para uma função (método), e eventos usam delegates para apontar a qual método o mesmo deverá chamar.

Declaração de Pessoa

public class Pessoa
    {  
        //declaração da assinatura do delegate
        //que irá tratar os eventos
        public delegate void AndarHandler();

        //este evento irá mostrar que podemos esperar
        //retorno do objeto que chamou
        //o parâmetro pararAndar irá retornar true or false
        //dependendo do caso se for ou não para parar de andar
        public delegate void AndandoHandler(out bool pararAndar);

        //declaração dos eventos
        public event AndarHandler AntesAndar;
        public event AndarHandler AntesPararAndar;

        //repare aqui que iremos usar o segundo delegate
        public event AndandoHandler Andando;
       
        //declaração do método andar
        public void Andar()
        {
            //aqui iremos chamar o evento AntesAndar e avisar
            //o objeto chamante que iremos começar a Andar.
            AntesAndar();

            DateTime pararAs = DateTime.Now.AddSeconds(30);

            //aqui iremos andar por 30 segundos
            while (pararAs > DateTime.Now)
            {
                bool pararAgora = false;
                //aqui iremos notificar que a
                //pessoa continua Andando
                Andando(out pararAgora);

                if (pararAgora)
                {
                    //antes de parar, notificar que vou parar
                    AntesPararAndar();
                    break;
                }

                //aqui apenas iremos parar por um segundo.
                //não se preocupem com esta linha
                System.Threading.Thread.Sleep(1000);
            }
        }
    }

Declaração do objeto para testes.
É uma aplicação do tipo Console.

static void Main()
        {
            //cria uma pessoa
            Pessoa marcelo = new Pessoa();

            //define os métodos que irão tratar os nossos eventos
            marcelo.Andando +=
new Pessoa.AndandoHandler(marcelo_Andando);
            marcelo.AntesAndar +=
new Pessoa.AndarHandler(marcelo_AntesAndar);
            marcelo.AntesPararAndar +=
new Pessoa.AndarHandler(marcelo_AntesPararAndar);

            //chamar o método para que marcelo possa Andar
            marcelo.Andar();

            Console.WriteLine("Marcelo parou de andar.");

            Console.ReadKey();

        }

        static void marcelo_AntesPararAndar()
        {
            Console.WriteLine("Marcelo irá parar de andar.");
        }

        static void marcelo_AntesAndar()
        {
            Console.WriteLine("Marcelo irá começar a andar.");
        }

        static void marcelo_Andando(out bool pararAndar)
        {
            pararAndar = false;
            //a pessoa marcelo só vai parar se a condição for verdadeira
            if (DateTime.Now.Second % 7 == 0)
                pararAndar = true;

            Console.WriteLine("Marcelo está andando.");
        }

Para saber mais sobre delegates.

Foi escrito um novo artigo com tópicos avançados sobre delegates.

Delegates

Com isso terminamos a definição de POO. Aguardem agora os próximos artigos que vamos abordar nesse assunto, ainda temos muita coisa para ver.

É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

About Marcelo

Definições – Intermediário (POO)

(7 votos, média: 4,71 de 5)

19 de dezembro de 2010

Para um melhor entendimento deste Artigo veja o Índice (Programação Orientada a Objetos)

Mensagens:
As mensagens são bem simples de entender, mensagens são informações trocadas entre um objeto e outro.
Estas mensagens podem modificar o comportamento do objeto a quem a mensagem foi direcionada,
ou retornar um valor a quem pediu.
A interação dos objetos é feito através de mensagens.Ex: É uma chamada para invocar um de seus métodos.

Pessoa pessoa = new Pessoa();
pessoa.Comer("Maçã");

Neste caso a chamada do método Comer(string alimento) em pessoa gerou uma mensagem,
e indicou ao objeto pessoa para comer uma maçã.

Vejamos outro exemplo:

Pessoa pessoa = new Pessoa();
//aqui Sonhar() retorna true
if (pessoa.Sonhar())
Console.WriteLine("A pessoa está sonhando");

Neste caso o objeto retornou uma informação a quem o chamou, o método retornou que a pessoa esta sonhando.

Overriding:
Override nada mais que é que sobrescrever, substituir o método da classe pai por um método escrito na classe filha.
Você só pode usar o override em métodos que permitam serem sobrescritos.
Ex:
A classe Marcelo (sou eu … rs) herda de pessoa seu comportamento, atributos e todo o mais.
Mas Marcelo não gosta de maçãs, logo a classe Marcelo vai sobrescrever o método Comer(string alimento).
Vejamos como fica:

class Marcelo : Pessoa
{

public override void Comer(string alimento)
{
if (alimento == "Maçã")
Console.WriteLine("Eu não gosto de maçãs. Não vou comer.");
else
base.Comer(alimento);
}
}

Overload:
Ao pé da letra sobrecarga de métodos, significa ter métodos com o mesmo nome e assinatura* diferente.
*Assinatura:
Assinatura de um método é como ele foi declarado, seu nome completo, nome e sobrenome (parâmetros).
Ex: Veja o método Comer(string alimento) podemos dizer que Comer é seu nome e string alimento
é seu sobrenome (parâmetros) que podem ser um ou mais.
Veja o método Comer na classe Pessoa.

public class Pessoa
{

public string Nome { get; set; }

public void Andar()
{ }

public virtual void Comer()
{ }

public virtual void Comer(string alimento)
{
Console.WriteLine("Comendo " + alimento);
}

public void Falar()
{ }

public Boolean Sonhar()
{
return true;
}
}

Persistência:
É a capacidade de um objeto de salvar seus dados para uso em outro momento.
Este termo é muito utilizado quando falamos de banco de dados, onde um objeto salva os dados em uma tabela.
Imaginamos que no objeto pessoa temos as propriedades, Nome, Telefone e CPF e precisamos salvar
estes dados para que quando o aplicativo for fechado possamos recuperar o mesmo ao abrir o aplicativo novamente.

Existem dois tipos de dados, transientes ou persistentes:

Para reforçar:
Dados Transientes: São dados que são válidos apenas dentro do programa ou transação.
Quando o programa é fechado ou a transação termina os dados se perdem
Dados Persistentes: São armazenados fora do contexto do programa,
existem mesmo quando o programa for fechado e
podem ser recuperados a qualquer momento.

Exemplo em CSharp de como persistir (serializar) um objeto

Declaração da classe Pessoa:

public class Pessoa
{
public string Nome { get; set; }

public string Telefone { get; set; }

public string CPF { get; set; }
}

Exemplo da serialização:

//popular o objeto pessoa
Pessoa pessoa = new Pessoa();
pessoa.Nome = "Marcelo";
pessoa.CPF = "000.000.000-00";
pessoa.Telefone = "(00) 0000-0000";

//criar o objeto que irá serializar a pessoa em XML
System.Xml.Serialization.XmlSerializer x =
new System.Xml.Serialization.XmlSerializer
(pessoa.GetType());

//salvar no arquivo XML pessoa.xml
System.Xml.XmlTextWriter xmlWriter =
new System.Xml.XmlTextWriter("pessoa.xml", Encoding.UTF8);

//serializar para pessoa.xml
x.Serialize(xmlWriter, pessoa);

//liberamos o arquivo xml
xmlWriter.Flush();
xmlWriter.Close();

//Neste momento se você abrir o arquivo pessoa.xml
//em algum editor
//verá os dados do objeto pessoa
System.Xml.XmlTextReader xmlReader =
new System.Xml.XmlTextReader("pessoa.xml");

//recuperar os dados e popular o objeto pessoa.
pessoa = (Pessoa)x.Deserialize(xmlReader);

//como teste, iremos passar o nome para uma variável string
string nomePessoa = pessoa.Nome;

Esta ilustração mostra o processo geral de serialização.

É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

: Mensagens, Object-Oriented, Objetos, OOP, Orientada, Overload, Overriding, Persistência, POO, Programação, Recuperação, Serialização, Serializar

About Marcelo

Definições – Básico (POO)

(10 votos, média: 5,00 de 5)

17 de dezembro de 2010

Para um melhor entendimento deste Artigo veja o Índice (Programação Orientada a Objetos)

Nós, como seres humanos distinguimos estes objetos em três formas de pensamento:

Diferenciação;
Distinção entre o todo e a parte;
Classificação;

Vemos nestas três formas, dentro da orientação a objetos, uma forma de diminuir a diferença semântica entre o que é real e o que é modelo.

O “homenzinho” acima é chamado de stickman.
É a representação dentro de um UseCase (UML)

O que é um objeto?
Podemos dizer que um objeto é algo quem tem características, ações, possui comportamento, uma identidade, distingui-se um do outro.
Os objetos podem ser físicos:
Um carro, uma casa, um pessoa, um cachorro …
Um conceito:
Um organograma, uma idéia …
Uma entidade:
Um botão, uma combobox, uma planilha Excel® …

O conjunto de ações, qualidades, as mudanças deste objeto influenciam no seu comportamento..
Podemos traduzir para a OO os termos, ações, qualidades, mudanças e comportamento da seguinte forma:

Ações:
- O que o objeto faz, o verbo. Estes serão nossos Métodos.
  - Ex: Andar, Falar, Comer, Quebrar, Salvar.
Qualidades:
- Serão nossos adjetivos, qualificam nossos objetos. Estes serão nossas Propriedades.
  - Ex: Cor, Tipo, Inquebrável, Esfomeado.
Mudanças:
- Estas serão responsáveis por definir o Estado do nosso objeto.
- Estes por sua vez podem se modificar ao longo do tempo.
  - Ex: Com fome, Andando, Quebrando, Comendo.
Comportamento:
- O comportamento determina como este objeto responde às mudanças de suas qualidades e as ações que ele pode realizar.
  - Ex: João está com fome* porque é esfomeado**, logo ele tem que comer***.
    * com fome: Mudança de estado;
    ** esfomeado: Qualidade, adjetivo;
    *** comer: Ação, verbo
    Logo o comportamento do João pode modificar-se pelo fato de estar com fome.

Instância de um Objeto:
Imagine que temos o objeto Pessoa, este objeto apenas representa uma pessoa, mas se quisermos dar uma identidade a este objeto temos que instanciá-lo, seria como dizer, trazer esta pessoa à vida, criar um novo objeto, um novo carro, um novo botão, uma nova planilha.

Classes:
Uma classe é a descrição (código) de um grupo de objetos com propriedades, comportamento, relacionamentos com outros objetos (associações e agregações).
Um objeto é uma instância de uma classe.

Modificadores deAcesso e Visibilidade:
Os modificadores, como o próprio nome diz, modificam as declarações de propriedades, métodos e classes, eles podem ser:

C#	Java	Descrição
Public	Public	Declaram queo método, propriedade ou classe é publica. Isso quer dizer que está acessível a todos. //declaração daclasse public class Pessoa { //em uma propriedade public string Nome { get; set; } //em um método public void Comer() { } }
Private	Private	Declaram que o método, propriedade ou classe é privativo. Isso quer dizer que está acessível apenas localmente. Dentro do mesmo objeto. //declaração daclasse private class Pessoa { //em umapropriedade private string Nome { get; set; } //em um método private void Comer() { } }
Static	Static	Declaram quea classe não precisa ser instanciada. Isso quer dizer que não é preciso criar um “novo” objeto, podemos simplesmente chamar seus métodos e propriedades. //declaração daclasse public static class Pessoa { //em uma propriedade public static string Nome { get; set; } //em um método public static void Comer() { } }
Const	Final	Declara um variável constante. Isso quer dizer que seuvalor não pode ser modificado. public class Pessoa { public const string CPF = "000.000.000-00"; }
Sealed	Final	Uma classe “selada” não pode ser modificada nem herdada. //declaração daclasse public sealed class Pessoa { public string Nome { get; set; } public void Comer() { } }
Internal	Package	Apenas as classes que fazem parte do mesmo assembly (executável, DLL) podem acessar esta classe ou método. No caso do Java as que fazem parte do mesmo “Pacote”. //na declaração daclasse internal class Pessoa { //na declaração de uma propriedade internal string Nome { get; set; } //na declaração deum método internal void Comer() { } }
Protected	Protected	Apenas as classes filhas podem herdar estes métodos. É visível apenas na classe pai e nas filhas. Não são visíveis publicamente. public class Pessoa { //na declaração de uma propriedade protected string Nome { get; set; } //na declaração deum método protected void Comer() { } }
Internal Protected	–	É a junção de Internal e Protected. Isso quer dizer que apenas as classes do mesmo assembly podemver seus métodos e herdar suas características. class Pessoa { //na declaração de uma propriedade internal protected string Nome { get; set; } //na declaração deum método internal protected void Comer() { } }
Abstract	Abstract	Declaram quea classe ou método será abstrato. Isso quer dizer que o método deverá ser implementado na classe filha. Classes abstratas não podem ser criados como “novo objeto” só podem ser herdadas. //na declaração daclasse abstract class Pessoa { //na declaração de uma propriedade public abstract string Nome { get; set; } //na declaração de um método public abstract void Comer(); }
Interface	Interface	Declara quea classe possui apenas a assinatura dos métodos e propriedades. Todos os seus métodos e propriedades deverão ser implementados. //na declaração da interface public interface Pessoa { //interface apenas implementam a //assinatura da propriedade string Nome { get; set; } //interface apenas implementam a //assinatura dos métodos void Comer(); }
Virtual	Virtual	Declara que o método/ propriedade pode ser sobrescrito (override) //na declaração daclasse public class Pessoa { //na declaração da propriedade public virtual string Nome { get; set; } //na declaração do método public virtual void Comer() { } }
Void	Void	Indica que o método não tem retorno. public class Pessoa { //na declaração do método indica que //não tem retorno public virtual void Comer() { } //Este método tem retorno não podemos //usar o VOID e sim o tipo de retorno public virtual Boolean Sonhar() { //retorna true se foi possível sonhar return true; } }

Com isso temos uma visão geral dos modificadores mais comuns. Claro. Posso ter esquecido de alguns. 🙂
Estes modificadores podem ser combinados de acordo com a necessidade. Mas isso você irá aprender com o tempo, aqui o intuito é explicar o que são eles e para que servem.

Construtores e Destrutores:
O construtor é um método utilizado para inicializar os objetos da classe quando estes são criados.
Este método possui o mesmo nome da Classe e não tem nenhum tipo de retorno, nem mesmo void.
No construtor podemos iniciar todos os outros objetos e propriedades, ele será sempre chamada ao iniciar o objeto.

O destrutor é chamado quando o objeto é descarregado da memória.
Neste método podemos descarregar todos os outros objetos que usamos durante o tempo de vida da classe em memória

public class Pessoa
{
//o Nome da pessoa será iniciado quando construtor for chamado
public string Nome { get; set; }

//construtor sem parâmetros
public Pessoa()
{
//aqui o nome da pessoa é vazio
Nome = "";
}

//construtor com parâmetros
public Pessoa(string _nome)
{
//aqui o nome da pessoa é o mesmo do parâmetro _nome
Nome = _nome;
}

//aqui o destrutor
~Pessoa()
{
//podemos limpar os nossos objetos
Nome = null;
}
}

Atributo e Propriedade:
Muitas pessoas dizem que atributos e propriedades são às mesmas coisas. Eu costumo dizer que não.
Atributos são variáveis que guardam os valores das propriedades, e as propriedades são as qualidades de nossas classes visíveis ao mundo externo.
Veja:

public class Pessoa
{
//esta declaração é um atributo, pois armazena o valor da propriedade Nome
//normalmente são visíveis apenas local.
private string mNome = "";

//o Nome é uma propriedade.
//normalmente são públicas
public string Nome
{
// aqui usamos o atributo mNome para retornar o valor da propriedade
get { return mNome; }

// aqui usamos o atributo mNome para salvar o valor da propriedade
set { mNome = value; }
}
}

Métodos:
Os métodos serão os “verbos”, as ações que nossos objetos podem executar.

public class Pessoa
{
public void Andar()
{ }

public void Comer()
{ }

public void Falar()
{ }

public Boolean Sonhar()
{
return true;
}
}

É isso aí pessoal 🙂
Até o próximo
♦ Marcelo

: Atributos, Classes, Construtores e Destrutores, Instância de um objeto, Métodos, Modificadores de Acesso, Object-Oriented, Objetos, OOP, Orientada, POO, Programação, Programming, Propriedades, Visibilidade

About Marcelo

Um pouco de história (POO)

(3 votos, média: 4,33 de 5)

15 de dezembro de 2010

Para um melhor entendimento deste Artigo veja o Índice (Programação Orientada a Objetos)

1967: Simula – introduz os primeiros conceitos de OO
1972: Smalltalk – Xerox
1980: C++ – linguagem híbrida, derivada da linguagem C.
1983: Ada – criada para uso militar nos EUA
1984: Eilffel – primeiras características formais de OO
1986: Object pascal
1995: JAVA – Linguagem puramente orientada a objetos
1995: Várias linguagens agregando conceitos de OO
2000: Plataforma .NET

A Programação Orientada ao Objeto (Object-Oriented Programming) foi concebida há muito tempo atrás (no inicio da década de 70), a sua origem vem da linguagem Simula (Simula Language), concebida na Noruega na década de 60, e como o nome indica, foi criada para fazer simulações; entretanto, seu uso alavancou um conceito que até então passava desapercebido pela maioria dos projetistas: a similaridade com o mundo real.
A primeira linguagem de programação a implementar os conceitos de OOP foi a linguagem SIMULA-68; em seguida surgiu a linguagem Smalltalk; criada pela Xerox, que pode ser considerada a linguagem que popularizou e incentivou o emprego da OOP.
O resultado foi uma linguagem de pura linhagem OO, poderosíssima, que implementa todos os conceitos de OO, o que não acontece com as chamadas linguagens OO híbridas que implementam apenas alguns conceitos de orientação ao objeto.
Fundamentalmente o que se deseja com esta metodologia são basicamente duas características: reutilização de código e modularidade de escrita.
Formalmente, para ser considerada uma linguagem OO, esta precisa implementar quatro conceitos básicos: abstração, encapsulamento, herança e polimorfismo.

Um pouco de história das linguagens

Simula

A primeira linguagem a incorporar facilidades para definir classes de objetos genéricos na forma de uma hierarquia de classes e subclasses.
Foi idealizada em 1966, na Noruega, como uma extensão da linguagem ALGOL 60.
Uma classe em Simula é um módulo englobando a definição da estrutura e do comportamento comuns a todas as suas instâncias (objetos).

Smalltalk

Smalltalk foi desenvolvida no Centro de Pesquisas da Xerox durante a década de 70 e incorporou idéias de Simula.
Criou o princípio de objetos ativos, prontos a reagir a mensagens que ativam comportamentos específicos do objeto.

C++

Questões no projeto de C++

Ser melhor do que C
Suportar abstração de dados
Suportar programação orientada a objetos

C++ foi projetada para dar suporte a abstração de dados e programação orientada a objetos

C++ não impõe um paradigma

Ada

Ada é uma linguagem de programação criada através de um concurso realizado pelo U.S. Departament of Defense (DoD)
O principal projetista da equipe foi o francês Jean Ichbiah.
Esse concurso foi feito para por ordem na situação, o DoD em 1974 usava cerca de 450 linguagens ou dialetos de programação.
A linguagem foi primeiramente padronizada em 1983 pelo ANSI e em 1985 a Organização Internacional de Padronização (ISO).

Eiffel

Eiffel é uma Linguagem de Programação avançada, puramente orientada a objeto que enfatiza o projeto e construção de software reutilizável e de alta qualidade.
Eiffel foi criada por Bertrand Meyer que tinha uma extensa experiência com programação orientada a objeto, particularmente com SIMULA.

Object Pascal

O Object Pascal é uma linguagem orientada a objetos, isto é, todas as informações são tratadas como objetos e todos estes objetos pertencem a uma classe, que são categorias de objetos.
Delphi / Kylix / Lazarus são exemplos de ferramentas que utilizam esta linguagem.

Java

O Java é ao mesmo tempo um ambiente e uma linguagem de programação desenvolvida pela Sun Microsystems Inc.
Trata-se de mais um representante da geração de linguagens orientadas a objetos e foi projetado para resolver os problemas da área de programação cliente/servidor.
Os aplicativos em Java são compilados em um código de bytes (“bytecodes”) independente de arquitetura.
Esse código de bytes pode então ser executado em qualquer plataforma que suporte um interpretador Java.
O Java requer somente uma fonte e um binário e, mesmo assim, é capaz de funcionar em diversas plataformas, o que faz dele um sonho de todos os que realizam manutenção em programas.

Plataforma .NET

A plataforma .NET baseia-se em um dos princípios utilizados na tecnologia Java (Just In Time Compiler – JIT), os programas desenvolvidos para ela são duplo-compilados (compilados duas vezes), uma na distribuição (gerando um código que é conhecido como “bytecodes”) e outra na execução.
Um programa é escrito em qualquer das mais de vinte linguagens de programação disponíveis para a plataforma, o código fonte gerado pelo programador é então compilado pela linguagem escolhida gerando um código intermediário em uma linguagem chamada MSIL (Microsoft Intermediate Language).
Este novo código fonte gera um arquivo na linguagem de baixo nível Assembly, de acordo com o tipo de projeto.

É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

: história, Object-Oriented, Objetos, OOP, Orientada, POO, Programação, Programming

About Marcelo

Programação Orientada a Objetos (POO)

(13 votos, média: 5,00 de 5)

13 de dezembro de 2010

Olá Pessoal.Agora vou iniciar uma série de artigos sobre Programação Orientada a Objetos (POO) ou Object-Oriented Programming (OOP).Na medida do possível irei mostrar como programar cada explicação em alguma linguagem.Este primeiro artigo irá servir como um índice para os outros, sempre que eu postar um item deste índice, irei modificar este artigo fazendo um link daqui para a explicação e vice-versa.Então vamos lá, mãos à obra e vamos ver o que teremos 🙂

Um pouco de história
Definições
- Básico
  - Objetos
  - Instância de um objeto
  - Classes
  - Modificadores
  - Visibilidade
  - Construtores
  - Atributos
  - Propriedades
  - Métodos
- Intermediário
  - Mensagens
  - Overriding
  - Overload
  - Persistência
- Avançado
  - Generalização
  - Especialização
  - Delagates
  - Eventos
Abstração e Interface
- Definição
- Abstrato x Interface
- Exemplos de uso
Encapsulamento
- Definição
- Exemplos de uso
Herança e Hierarquia
- Definição
- Hierarquia
- Herança de Implementação
- Herança de Interface
- Agregação
- Composição
- Exemplos de uso
Polimorfismo
- Definição
- Exemplos de uso
S.O.L.I.D
- Definição e Conceitos
Apêndice
- Tipos Genéricos (Generics)
Para descontrair
- POG (Programação Orientada a Gambiarras)

É isso ai pessoal 🙂

Até o próximo

♦ Marcelo

About Marcelo

Recuperação de dados do HD

(Sem votação.)

11 de dezembro de 2010

Olá pessoal.
Eu aqui mais uma vez com uma dica muito útil para quem trabalha com hardware de computador.

Abaixo um vídeo ensinando como recuperar os dados de um HD caso o software de recuperação não funcione.
Muito útil e interessante.

[tubepress video=”9cQeZ4m8PvI”]

É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

: Humor

: dados, hardware, HD, humor, Recuperação

About Marcelo

InputBox em CSharp

(Sem votação.)

10 de dezembro de 2010

Ola Pessoal.

Neste artigo eu vou falar de uma carência que o C# tem. O InputBox.

O C# não possui um InputBox, logo temos que criar um, aqui vai um código que facilita a vida.

Com este inputBox você pode tratar as teclas pressionadas pelo usuário, bem como modificar o título, o valor inicial, exibir uma mensagem ao usuário.

Bom, vamos deixar de falatório (ou seria escrevetório, nossa forcei agora). E vamos ao que interessa.
Vou assumir que você tem conhecimento em C#.

Crie um novo projeto to tipo Class Lybrary, isso irá criar para você uma DLL.

Na classe que veio como padrão, renomeie para InputBox.cs e utilize o código abaixo para fazer a sua DLL.

Copiar e colar amigável: http://desenvolvedores.net.pastebin.com/raw.php?i=czRKYN7F

Código:

/*
 * Exemplo de inpuBox em C#.
 * By http://desenvolvedores.net
 */
using System;
using System.Windows.Forms;

/*
 * definimos o namespace como System.Windows.Forms apenas
 * para manter no mesmo local que a MessageBox
 */
namespace System.Windows.Forms
{
    #region Formulário
    internal sealed class _InputBox : System.Windows.Forms.Form
    {
        #region Locais
        internal System.Windows.Forms.TextBox txtInput;
        private Button cmdOK;
        private Button cmdCancel;
        internal Label lblUserInfo;
        private System.ComponentModel.Container components = null;

        /// <summary>
        /// tratar os eventos de pressionamento de teclas e develver ao usuário
        /// </summary>
        internal KeyPressEventHandler keyPress = null;
        #endregion

        #region Construtor
        public _InputBox()
        {
            InitializeComponent();
            lblUserInfo.Text = "";
            txtInput.Text = "";
        }
        #endregion

        #region Métodos de criação e dipose do form
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }
            base.Dispose(disposing);
        }

        private void InitializeComponent()
        {
            this.txtInput = new System.Windows.Forms.TextBox();
            this.cmdOK = new System.Windows.Forms.Button();
            this.cmdCancel = new System.Windows.Forms.Button();
            this.lblUserInfo = new System.Windows.Forms.Label();
            this.SuspendLayout();
            //
            // txtInput
            //
            this.txtInput.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.txtInput.Location = new System.Drawing.Point(16, 16);
            this.txtInput.Name = "txtInput";
            this.txtInput.Size = new System.Drawing.Size(256, 20);
            this.txtInput.TabIndex = 0;
            this.txtInput.KeyDown += new System.Windows.Forms.KeyEventHandler(this.txtInput_KeyDown);
            this.txtInput.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.txtInput_KeyPress);
            //
            // cmdOK
            //
            this.cmdOK.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
            this.cmdOK.Location = new System.Drawing.Point(124, 46);
            this.cmdOK.Name = "cmdOK";
            this.cmdOK.Size = new System.Drawing.Size(71, 26);
            this.cmdOK.TabIndex = 1;
            this.cmdOK.Text = "OK";
            this.cmdOK.UseVisualStyleBackColor = true;
            this.cmdOK.Click += new System.EventHandler(this.cmdOK_Click);
            //
            // cmdCancel
            //
            this.cmdCancel.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
            this.cmdCancel.Location = new System.Drawing.Point(201, 46);
            this.cmdCancel.Name = "cmdCancel";
            this.cmdCancel.Size = new System.Drawing.Size(71, 26);
            this.cmdCancel.TabIndex = 2;
            this.cmdCancel.Text = "Cancelar";
            this.cmdCancel.UseVisualStyleBackColor = true;
            this.cmdCancel.Click += new System.EventHandler(this.cmdCancel_Click);
            //
            // lblUserInfo
            //
            this.lblUserInfo.AutoSize = true;
            this.lblUserInfo.Location = new System.Drawing.Point(16, 0);
            this.lblUserInfo.MaximumSize = new System.Drawing.Size(256, 0);
            this.lblUserInfo.Name = "lblUserInfo";
            this.lblUserInfo.Size = new System.Drawing.Size(140, 13);
            this.lblUserInfo.TabIndex = 3;
            this.lblUserInfo.Text = "XXXXXXXXXXXXXXXXXXX";
            //
            // _InputBox
            //
            this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
            this.ClientSize = new System.Drawing.Size(292, 73);
            this.ControlBox = false;
            this.Controls.Add(this.lblUserInfo);
            this.Controls.Add(this.cmdCancel);
            this.Controls.Add(this.cmdOK);
            this.Controls.Add(this.txtInput);
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
            this.Name = "_InputBox";
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            this.Text = "InputBox";
            this.TopMost = true;
            this.Shown += new System.EventHandler(this._InputBox_Shown);
            this.ResumeLayout(false);
            this.PerformLayout();

        }
        #endregion

        #region Método Show
        public new string Show()
        {
            base.ShowDialog();
            return this.txtInput.Text;
        }
        #endregion

        #region Tratamento das ações do usuário
        private void txtInput_KeyDown(object sender, System.Windows.Forms.KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
                cmdOK.PerformClick();
            else if (e.KeyCode == Keys.Escape)
                cmdCancel.PerformClick();
        }

        private void cmdCancel_Click(object sender, EventArgs e)
        {
            txtInput.Text = "";
            this.Close();
        }

        private void cmdOK_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        private void _InputBox_Shown(object sender, EventArgs e)
        {
            //aqui temos que redimensionar o form por causa do tamanho da Label

            txtInput.Top = lblUserInfo.Top + lblUserInfo.Height + 5;
            this.Height = txtInput.Top + txtInput.Height + 60;
        }

        private void txtInput_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (keyPress != null)
                keyPress.Invoke(sender, e);
        }
        #endregion

    }
    #endregion

    #region Classe InputBox
    public static class InputBox
    {
        #region Métodos Show
        /// <summary>
        /// Exibe a inputbox
        /// </summary>
        /// <returns>string digitada</returns>
        public static string Show()
        {
            return InputBox.Show("", "", "", null);
        }

        /// <summary>
        /// Exibe a inputbox
        /// </summary>
        /// <param name="Title">Título desejado</param>
        /// <param name="keyHandler">Delegate tipo KeyPressEventHandler para capturar as teclas pressionadas</param>
        /// <returns>string digitada</returns>
        public static string Show(string Title, KeyPressEventHandler keyHandler)
        {
            return InputBox.Show(Title, "", "", keyHandler);
        }

        /// <summary>
        /// Exibe a inputbox
        /// </summary>
        /// <param name="keyHandler">Delegate tipo KeyPressEventHandler para capturar as teclas pressionadas</param>
        /// <returns>string digitada</returns>
        public static string Show(KeyPressEventHandler keyHandler)
        {
            return InputBox.Show("", "", "", keyHandler);
        }

        /// <summary>
        /// Exibe a inputbox
        /// </summary>
        /// <param name="initalValue">Valor inicial da inputBox</param>
        /// <param name="keyHandler">Delegate tipo KeyPressEventHandler para capturar as teclas pressionadas</param>
        /// <returns>string digitada</returns>
        public static string Show(KeyPressEventHandler keyHandler, string initalValue)
        {
            return InputBox.Show("", "", initalValue, keyHandler);
        }

        /// <summary>
        /// Exibe a inputbox
        /// </summary>
        /// <param name="userInfo">Mensagem inicial</param>
        /// <param name="initalValue">Valor inicial da inputBox</param>
        /// <param name="keyHandler">Delegate tipo KeyPressEventHandler para capturar as teclas pressionadas</param>
        /// <returns>string digitada</returns>
        public static string Show(string userInfo, string initalValue, KeyPressEventHandler keyHandler)
        {
            return InputBox.Show("", userInfo, initalValue, keyHandler);
        }

        /// <summary>
        /// Exibe a inputbox
        /// </summary>
        /// <param name="Title">Título desejado</param>
        /// <param name="userInfo">Mensagem inicial</param>
        /// <param name="initalValue">Valor inicial da inputBox</param>
        /// <param name="keyHandler">Delegate tipo KeyPressEventHandler para capturar as teclas pressionadas</param>
        /// <returns>string digitada</returns>
        public static string Show(KeyPressEventHandler keyHandler, string Title, string userInfo)
        {
            return InputBox.Show(Title, userInfo, "", keyHandler);
        }

        /// <summary>
        /// Exibe a inputbox
        /// </summary>
        /// <param name="Title">Título desejado</param>
        /// <param name="userInfo">Mensagem inicial</param>
        /// <param name="initalValue">Valor inicial da inputBox</param>
        /// <returns>string digitada</returns>
        public static string Show(string Title, string userInfo, string initalValue)
        {
            return InputBox.Show(Title, userInfo, initalValue, null);
        }

        /// <summary>
        /// Exibe a inputbox
        /// </summary>
        /// <param name="Title">Título desejado</param>
        /// <param name="userInfo">Mensagem inicial</param>
        /// <returns>string digitada</returns>
        public static string Show(string Title, string userInfo)
        {
            return InputBox.Show(Title, userInfo, "", null);
        }

        /// <summary>
        /// Exibe a inputbox
        /// </summary>
        /// <param name="Title">Título desejado</param>
        /// <param name="userInfo">Mensagem inicial</param>
        /// <param name="initalValue">Valor inicial da inputBox</param>
        /// <param name="keyHandler">Delegate tipo KeyPressEventHandler para capturar as teclas pressionadas</param>
        /// <returns>string digitada</returns>
        public static string Show(string Title, string userInfo, string initalValue, KeyPressEventHandler keyHandler)
        {
            using (_InputBox input = new _InputBox())
            {
                input.Text = string.IsNullOrEmpty(Title) ? "Infome um valor..." : Title;
                input.lblUserInfo.Text = userInfo;
                input.txtInput.Text = initalValue;
                if (keyHandler != null) input.keyPress = keyHandler;
                return input.Show();
            }
        }
        #endregion
    }
    #endregion
}

Exmplo de uso:
Adicione um novo projeto à sua solução do tipo Windows Forms Application
Faça referência a sua DLL.

Copiar e colar amigável: http://desenvolvedores.net.pastebin.com/raw.php?i=HqxqLyTT

/*
 * Exemplo de uso InputBox C#
 * by http://desenvolvedores.net
 */
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace InputBoxExample
{
    public class frmMain : Form
    {
        public frmMain()
        {
            InitializeComponent();
        }
        private void btnComHandler_Click(object sender, EventArgs e)
        {
            KeyPressEventHandler keyPress = new KeyPressEventHandler(InputBoxKeyPress);
            txtTeclaPressionada.Text = "";
            MessageBox.Show(InputBox.Show(keyPress, "Digite alguma coisa", "O que você digitar aqui irá aparecer na caixa de texto do formulário."));
        }
        private void InputBoxKeyPress(object sender, KeyPressEventArgs e)
        {
            txtTeclaPressionada.Text += e.KeyChar;
        }
        private void btnApenasTestar_Click(object sender, EventArgs e)
        {
            txtApenasTestar.Text = InputBox.Show();
        }
        private void btnValorInicial_Click(object sender, EventArgs e)
        {
            MessageBox.Show(InputBox.Show("Digite alguma coisa", "O que você digitou no textbox irá aparecer no textBox abaixo.", txtValorInicial.Text));
        }
        #region Componentes
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;
        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }
        #region Windows Form Designer generated code
        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.btnComHandler = new System.Windows.Forms.Button();
            this.lblTeclaPressionada = new System.Windows.Forms.Label();
            this.txtTeclaPressionada = new System.Windows.Forms.TextBox();
            this.btnApenasTestar = new System.Windows.Forms.Button();
            this.groupBox1 = new System.Windows.Forms.GroupBox();
            this.groupBox2 = new System.Windows.Forms.GroupBox();
            this.label1 = new System.Windows.Forms.Label();
            this.txtApenasTestar = new System.Windows.Forms.TextBox();
            this.groupBox3 = new System.Windows.Forms.GroupBox();
            this.label2 = new System.Windows.Forms.Label();
            this.txtValorInicial = new System.Windows.Forms.TextBox();
            this.btnValorInicial = new System.Windows.Forms.Button();
            this.groupBox1.SuspendLayout();
            this.groupBox2.SuspendLayout();
            this.groupBox3.SuspendLayout();
            this.SuspendLayout();
            //
            // btnComHandler
            //
            this.btnComHandler.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.btnComHandler.Location = new System.Drawing.Point(249, 43);
            this.btnComHandler.Name = "btnComHandler";
            this.btnComHandler.Size = new System.Drawing.Size(250, 32);
            this.btnComHandler.TabIndex = 2;
            this.btnComHandler.Text = "Testar capturando a tecla pressionada";
            this.btnComHandler.UseVisualStyleBackColor = true;
            this.btnComHandler.Click += new System.EventHandler(this.btnComHandler_Click);
            //
            // lblTeclaPressionada
            //
            this.lblTeclaPressionada.AutoSize = true;
            this.lblTeclaPressionada.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.lblTeclaPressionada.Location = new System.Drawing.Point(6, 19);
            this.lblTeclaPressionada.Name = "lblTeclaPressionada";
            this.lblTeclaPressionada.Size = new System.Drawing.Size(108, 13);
            this.lblTeclaPressionada.TabIndex = 0;
            this.lblTeclaPressionada.Text = "Teclas Pressionadas:";
            //
            // txtTeclaPressionada
            //
            this.txtTeclaPressionada.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.txtTeclaPressionada.Location = new System.Drawing.Point(120, 17);
            this.txtTeclaPressionada.Name = "txtTeclaPressionada";
            this.txtTeclaPressionada.Size = new System.Drawing.Size(379, 20);
            this.txtTeclaPressionada.TabIndex = 1;
            //
            // btnApenasTestar
            //
            this.btnApenasTestar.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.btnApenasTestar.Location = new System.Drawing.Point(249, 53);
            this.btnApenasTestar.Name = "btnApenasTestar";
            this.btnApenasTestar.Size = new System.Drawing.Size(250, 32);
            this.btnApenasTestar.TabIndex = 2;
            this.btnApenasTestar.Text = "Apenas Testar";
            this.btnApenasTestar.UseVisualStyleBackColor = true;
            this.btnApenasTestar.Click += new System.EventHandler(this.btnApenasTestar_Click);
            //
            // groupBox1
            //
            this.groupBox1.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
                        | System.Windows.Forms.AnchorStyles.Right)));
            this.groupBox1.Controls.Add(this.btnComHandler);
            this.groupBox1.Controls.Add(this.lblTeclaPressionada);
            this.groupBox1.Controls.Add(this.txtTeclaPressionada);
            this.groupBox1.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.groupBox1.Location = new System.Drawing.Point(12, 12);
            this.groupBox1.Name = "groupBox1";
            this.groupBox1.Size = new System.Drawing.Size(511, 91);
            this.groupBox1.TabIndex = 0;
            this.groupBox1.TabStop = false;
            this.groupBox1.Text = "Capturando as Teclas";
            //
            // groupBox2
            //
            this.groupBox2.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
                        | System.Windows.Forms.AnchorStyles.Right)));
            this.groupBox2.Controls.Add(this.label1);
            this.groupBox2.Controls.Add(this.txtApenasTestar);
            this.groupBox2.Controls.Add(this.btnApenasTestar);
            this.groupBox2.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.groupBox2.Location = new System.Drawing.Point(12, 129);
            this.groupBox2.Name = "groupBox2";
            this.groupBox2.Size = new System.Drawing.Size(511, 91);
            this.groupBox2.TabIndex = 1;
            this.groupBox2.TabStop = false;
            this.groupBox2.Text = "Apenas Testar";
            //
            // label1
            //
            this.label1.AutoSize = true;
            this.label1.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.label1.Location = new System.Drawing.Point(6, 21);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(48, 13);
            this.label1.TabIndex = 0;
            this.label1.Text = "Retorno:";
            //
            // txtApenasTestar
            //
            this.txtApenasTestar.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.txtApenasTestar.Location = new System.Drawing.Point(120, 19);
            this.txtApenasTestar.Name = "txtApenasTestar";
            this.txtApenasTestar.Size = new System.Drawing.Size(379, 20);
            this.txtApenasTestar.TabIndex = 1;
            //
            // groupBox3
            //
            this.groupBox3.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
                        | System.Windows.Forms.AnchorStyles.Right)));
            this.groupBox3.Controls.Add(this.label2);
            this.groupBox3.Controls.Add(this.txtValorInicial);
            this.groupBox3.Controls.Add(this.btnValorInicial);
            this.groupBox3.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.groupBox3.Location = new System.Drawing.Point(12, 237);
            this.groupBox3.Name = "groupBox3";
            this.groupBox3.Size = new System.Drawing.Size(511, 91);
            this.groupBox3.TabIndex = 2;
            this.groupBox3.TabStop = false;
            this.groupBox3.Text = "Valor Inicial";
            //
            // label2
            //
            this.label2.AutoSize = true;
            this.label2.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.label2.Location = new System.Drawing.Point(6, 21);
            this.label2.Name = "label2";
            this.label2.Size = new System.Drawing.Size(99, 13);
            this.label2.TabIndex = 0;
            this.label2.Text = "Digite o valor Inicial";
            //
            // txtValorInicial
            //
            this.txtValorInicial.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.txtValorInicial.Location = new System.Drawing.Point(120, 19);
            this.txtValorInicial.Name = "txtValorInicial";
            this.txtValorInicial.Size = new System.Drawing.Size(379, 20);
            this.txtValorInicial.TabIndex = 1;
            //
            // btnValorInicial
            //
            this.btnValorInicial.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.btnValorInicial.Location = new System.Drawing.Point(249, 53);
            this.btnValorInicial.Name = "btnValorInicial";
            this.btnValorInicial.Size = new System.Drawing.Size(250, 32);
            this.btnValorInicial.TabIndex = 2;
            this.btnValorInicial.Text = "Com valor inicial";
            this.btnValorInicial.UseVisualStyleBackColor = true;
            this.btnValorInicial.Click += new System.EventHandler(this.btnValorInicial_Click);
            //
            // frmMain
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(535, 340);
            this.Controls.Add(this.groupBox3);
            this.Controls.Add(this.groupBox2);
            this.Controls.Add(this.groupBox1);
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
            this.MaximizeBox = false;
            this.MinimizeBox = false;
            this.Name = "frmMain";
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            this.Text = "InputBox em C#";
            this.groupBox1.ResumeLayout(false);
            this.groupBox1.PerformLayout();
            this.groupBox2.ResumeLayout(false);
            this.groupBox2.PerformLayout();
            this.groupBox3.ResumeLayout(false);
            this.groupBox3.PerformLayout();
            this.ResumeLayout(false);
        }
        #endregion
        private System.Windows.Forms.Button btnComHandler;
        private System.Windows.Forms.Label lblTeclaPressionada;
        private System.Windows.Forms.TextBox txtTeclaPressionada;
        private System.Windows.Forms.Button btnApenasTestar;
        private System.Windows.Forms.GroupBox groupBox1;
        private System.Windows.Forms.GroupBox groupBox2;
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.TextBox txtApenasTestar;
        private System.Windows.Forms.GroupBox groupBox3;
        private System.Windows.Forms.Label label2;
        private System.Windows.Forms.TextBox txtValorInicial;
        private System.Windows.Forms.Button btnValorInicial;
        #endregion
    }
}

Para os mais preguiçosos, faça o download do exemplo completo abaixo:
[download id=”12″]

É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

: C#, Desenvolvimento, Desktop

: C#, CSharp, inputbox

About Marcelo

Paginação remota com ext.net, CSharp e ASPX

(1 votos, média: 5,00 de 5)

8 de dezembro de 2010

Olá Pessoal.

Neste tutorial eu vou escrever e falar sobre paginação remota utilizando o Ext.Net, C# e ASP.Net.

Antes de começar, uma rápida revisão sobre paginação.

O que é paginação?
Paginação (paginar) consiste em dividir em partes (páginas).
Imagine o jornal que você lê, ele é dividido em páginas para que facilite a sua leitura, você pode virar as páginas ou ir para uma página específica do seu jornal e continuar a sua leitura, o mesmo acontece com livros, revistas etc.

Agora vamos imaginar a paginação dos dados.
Quando você abre um conjunto de registros, a exibição ao usuário pode se tornar lenta, se o número de registros for grande, neste momento você precisa paginar o seu conjunto de registros, ou tupla se você preferir.

Uma tupla é cada linha de registro de uma tabela na base de dados

A idéia de paginar os seus registros é o mesmo que o jornal faz, dividir e exibir o todo em partes.

Agora vamos ao que interessa.

No ext.net existe o componente PagingToolbar

<ext:PagingToolbar></ext:PagingToolbar>

Ele é o responsável pela interface ao usuário e por gerar os eventos necessários para a paginação.

Como tudo acontece.

Quando você clica no botão de navegação o ext envia uma requisição ao servidor, passando como parâmetros no Request as seguintes variáveis start e limit

Estas duas variáveis são responsáveis por dizer onde começa e qual o tamanho da página.

Ok! Mas como o ASPXvai capturar estas informações?

Para tratarmos estes eventos dentro do ASPX temos que usar handlers.

Opa! O que são handlers?

Os handlers são responsáveis por interceptar solicitações feitas ao servidor de aplicativo.
Eles são executados como processos em resposta a um pedido feito pelo site.

Você pode criar seus próprios handlers genéricos (ashx) que processam a saída e enviam ao navegador.

Para programar um handler genérico o mesmo deverá implementar a interface System.Web.IHttpHandler.
As interfaces exigem que você implemente o método ProcessRequest e a propriedade IsReusable.

O método ProcessRequest manipula o processamento para as solicitações feitas, enquanto o booleano IsReusable é a propriedade que diz se o manipulador é reutilizável ou se um novo manipulador é necessário para cada solicitação.

Declaração básica para um handler genérico:

Diretiva de página:
<%@ WebHandler Language=”C#” Class=”DeclaracaoBasica“ %>

Código da página

using System;
using System.Web;

public class DeclaracaoBasica : IHttpHandler {

    public void ProcessRequest (HttpContext context) {
        context.Response.ContentType = "text/plain";
        context.Response.Write("Hello World");
    }

    public bool IsReusable {
        get {
            return false;
        }
    }

}

Bom, agora que temos os pré-requisitos vamos à nossa vídeo-aula clique no vídeo abaixo e assista.

O som do vídeo está baixo, recomendo o uso de um fone de ouvido.

[tubepress video=”BjFpW-Mg-bg”]

Se preferir, assista direto no youtube http://www.youtube.com/watch?v=BjFpW-Mg-bg&hd=1

Download do código de exemplo:
[download id=”11″]

Dúvidas? Poste-as no fórum referindo-se a este tutorial.
http://desenvolvedores.net/ext.net

É isso ai pessoal 🙂
Até o próximo
♦ Marcelo

: ASPX, C#, Desenvolvimento, Ext.Net, Web

: ASP, ASP.Net, ASPX, C#, coolite, CSharp, ext.net, extjs, Paginação remota