todo percentual do sistema, deveria ser gravado no banco dividindo seu valor por 100 e ao se recuperar o valor, deveria multiplicar o mesmo também por 100.

Fiquei pensando como iria resolver isso e imaginei algumas possibilidades, analisando prós e contras:

• Através de get’s e set’s além de depender que cada desenvolvedor o faça na implementação, iria gerar uma replicação de código terrível
• Se fizesse os sets e gets ainda através de uma classe helper, continuaria dependendo da lembrança do desenvolvedor
• Através de componentes não iria abranger todos os outros processos não visuais
• e mais algumas loucuras…

Eu percebi que precisaria ir mais a fundo pra dar uma solução de uso simples, funcional e genérica.

Foi aí que surgiu a oportunidade de usar um tipo customizado do NHibernate.   A idéia é criar um tipo específico de dados, que de maneira transparente, se encarregaria de fazer o devido tratamento a informação segundo o critério estabelecido.

Para isso, são necessários basicamente três passos: criar um tipo de dado específico que seus objetos vao fazer uso através de propriedades, criar uma classe que ira tratar o uso desse tipo pelo NH e vincular o mapeamento do dado de seu objeto com a classe tratadora.

Passo 1 – Criar um tipo específico e fazer uso em nossos objetos

A criação de um tipo específico, que vamos chamar de Percent, nos dá a possibilidade de lidar com um outro conceito bem interessante no .NET: operadores implícitos. Nosso tipo precisa receber um valor conversível em percentual, seja ele inteiro, decimal, double ou quaisquer variações. O uso desse tipo está exemplificado nesse trecho de código:

<br />
public class Venda : EntityBase<br />
{<br />
  public virtual Percent Percentual { get; set; }<br />
}<br />

Em minha classe Venda, além de Id, tenho uma propriedade Percentual, do meu tipo customizado onde quero atribuir valores de maneira simples, das seguintes formas:

</p>
<p>// Decimal            <br />
venda.Percentual = 2.3M;</p>
<p>// Inteiro            <br />
venda.Percentual = 10;</p>
<p>// Double            <br />
venda.Percentual = 12.3;<br />

Como ficou meu tipo e como é possível fazer essas atribuições? Aqui está o código da classe Percent 

<br />
public class Percent<br />
{<br />
    #region Attributes</p>
<p>    public Double? Value { get; private set; }<br />
    public Boolean HasValue { get { return Value.HasValue; } }</p>
<p>    #endregion</p>
<p>    #region Operators</p>
<p>    public static implicit operator Percent(Int32? value)<br />
    {<br />
        return new Percent(value);<br />
    }</p>
<p>    public static implicit operator Percent(Double? value)<br />
    {<br />
        return new Percent(value);<br />
    }</p>
<p>    public static implicit operator Percent(Decimal? value)<br />
    {<br />
        return new Percent(value);<br />
    }</p>
<p>    #endregion</p>
<p>    #region Constructors</p>
<p>    public Percent(Int32? value)<br />
    {<br />
        this.Value = value;<br />
    }</p>
<p>    public Percent(Double? value)<br />
    {<br />
        this.Value = value;<br />
    }</p>
<p>    public Percent(Decimal? value)<br />
    {<br />
        this.Value = (Double?)value;<br />
    }</p>
<p>    #endregion</p>
<p>    #region Methods</p>
<p>    public override Boolean Equals(Object obj)<br />
    {<br />
        Percent objToCompare = obj as Percent;</p>
<p>        if (objToCompare == null)<br />
            return !this.HasValue || this.Value.IsDefaultValue();</p>
<p>        return objToCompare.Value.Equals(this.Value);<br />
    }</p>
<p>    public override int GetHashCode()<br />
    {<br />
        return Value.GetHashCode();<br />
    }</p>
<p>    public override string ToString()<br />
    {<br />
        return Value.ToString();<br />
    }</p>
<p>    #endregion<br />
}<br />

O segredo da atribuição a propriedade, está nas linhas marcadas. De 10 a 27.  Os operadores implicitos, unidos aos construtores que conseguem administrar os tipos recebidos, permitem que passemos os valores de diversas formas. Reparem que o valor em si, eu mantenho numa propriedade interna da classe.

Passo 2 – Criar uma classe que irá tratar o uso do tipo Percent pelo NHibernate

Percent por si só, ja é capaz de manter valores de tipo percentual. Agora vamos fazer com que o NH saiba o que fazer quando um valor for passado a uma propriedade desse tipo. O NHibernate tem no namespace NHibernate.UserTypes algumas interfaces que nos ajudam nesse processo. Vamos fazer uso de IUserType. Ao implementar essa interface, alguns métodos sao auto explicativos mas outros merecem maior atenção. Chamei minha classe de PercentType

<br />
[Serializable]<br />
public class PercentType : IUserType<br />
{<br />
    #region IUserType Members<br />
    private static readonly NHibernate.SqlTypes.SqlType[] SQL_TYPES = { NHibernateUtil.Double.SqlType };</p>
<p>    public SqlType[] SqlTypes<br />
    {<br />
        get { return SQL_TYPES; }<br />
    }</p>
<p>    public Type ReturnedType<br />
    {<br />
        get { return typeof(Percent); }<br />
    }</p>
<p>    public new bool Equals(Object x, Object y)<br />
    {<br />
        if (ReferenceEquals(x, y)) return true;</p>
<p>        if (x == null || y == null) return false;</p>
<p>        return x.Equals(y);<br />
    }</p>
<p>    public Object DeepCopy(Object value)<br />
    {<br />
        return value;<br />
    }</p>
<p>    public Boolean IsMutable<br />
    {<br />
        get { return false; }<br />
    }</p>
<p>    public Object NullSafeGet(IDataReader rs, String[] names, Object owner)<br />
    {<br />
        var obj = NHibernateUtil.Decimal.NullSafeGet(rs, names[0]);</p>
<p>        if (obj == null)<br />
            return new Percent(null);<br />
        {<br />
            Decimal result = (Decimal)obj;<br />
            if (result != default(Decimal))<br />
                return new Percent(result * 100);<br />
            else<br />
                return new Percent(result);<br />
        }<br />
    }</p>
<p>    public Object Assemble(Object cached, Object owner)<br />
    {<br />
        return cached;<br />
    }</p>
<p>    public Object Disassemble(Object value)<br />
    {<br />
        return value;<br />
    }</p>
<p>    public Int32 GetHashCode(Object x)<br />
    {<br />
        return x.GetHashCode();<br />
    }</p>
<p>    public void NullSafeSet(IDbCommand cmd, Object value, Int32 index)<br />
    {<br />
        if (value == null)<br />
            ((IDbDataParameter)cmd.Parameters[index]).Value = DBNull.Value;<br />
        else<br />
        {<br />
            Percent percent = value as Percent;<br />
            ((IDbDataParameter)cmd.Parameters[index]).Value = percent.Value / 100;<br />
        }<br />
    }</p>
<p>    public object Replace(object original, object target, object owner)<br />
    {<br />
        return original;<br />
    }<br />
    #endregion<br />
} <br />

Nesse bloco de código, informamos ao NH os tipos SQL que serão tratados por nossa classe

<br />
    private static readonly NHibernate.SqlTypes.SqlType[] SQL_TYPES = { NHibernateUtil.Double.SqlType };</p>
<p>    public SqlType[] SqlTypes<br />
    {<br />
        get { return SQL_TYPES; }<br />
    }<br />

Aqui, temos outros blocos importantes, nos métodos NullSafeGet e NullSaveSet. Nesses métodos, dizemos ao NH como tratar os valores no objeto:

<br />
    public Object NullSafeGet(IDataReader rs, String[] names, Object owner)<br />
    {<br />
        var obj = NHibernateUtil.Decimal.NullSafeGet(rs, names[0]);</p>
<p>        if (obj == null)<br />
            return new Percent(null);<br />
        {<br />
            Decimal result = (Decimal)obj;<br />
            if (result != default(Decimal))<br />
                return new Percent(result * 100);<br />
            else<br />
                return new Percent(result);<br />
        }<br />
    }<br />
    public void NullSafeSet(IDbCommand cmd, Object value, Int32 index)<br />
    {<br />
        if (value == null)<br />
            ((IDbDataParameter)cmd.Parameters[index]).Value = DBNull.Value;<br />
        else<br />
        {<br />
            Percent percent = value as Percent;<br />
            ((IDbDataParameter)cmd.Parameters[index]).Value = percent.Value / 100;<br />
        }<br />
    }</p>
<p>

Em NullSafeGet eu obtenho o valor que vem do banco, multiplico por 100 e devolvo uma instancia de Percent já com valor tratado. Em NullSafeSet, inverto o cálculo e passo o valor ao parametro que irá para o banco. Simples assim. Seguindo essa linha de raciocínio, as possibilidades de tratamento de tipos são incontáveis. Vai da necessidade e/ou imaginação.

Passo 3 – Mapear no NH, a associação de uma propriedade Percent com o tratamento de PercentType

Como o objetivo desse post nao é configuracação e uso de NHibernate em si, vou mostrar somente um caso de forma de mapeamento. Eu estou usando Fluent NHibernate mas é perfeitamente possível fazer com hbm ou Active Record visto que é uma funcionalidade do NH. Este é o mapeamento via fluent: 

public class VendaMap : ClassMap&lt;Venda&gt;<br />
{<br />
    public VendaMap()<br />
    {<br />
        Id(x =&gt; x.Id)<br />
            .GeneratedBy<br />
                .Native(&quot;SEQVENDA&quot;);</p>
<p>        Map(x =&gt; x.Percentual)<br />
            .CustomType&lt;PercentType&gt;();<br />
    }<br />
}</p>
<p>

Segue tambem um pequeno teste para demonstrar o uso e funcionamento do que fizemos. É um teste simples e nada abrangente mas mostra que funciona. Não explico também a gestão da sessão do NH mas ser voce tiver tudo funcionando ok na sua máquina é facil reproduzir o teste.

    [TestMethod]
    public void PercentTypeTest()
    {
        Int32 value = 20;

        Venda venda = new Venda();
        venda.Percentual = value;

        FluentHelper.Instance.CurrentSession.Save(venda);

        Assert.AreEqual(venda.Percentual, value);
    }

 

É isso. Se houver interesse eu disponibilizo o projeto completo pra download. Vou tentar no próximo post, falando um pouco mais de NH, mostrar como usar um interceptor para gerenciar numeração incremental customizada nas suas entidades.

Abraaaaaaaço

Eu concordo mas aqui é um lugar público, que ninguém vem ver, e ainda é meu. Só tenho aqui mesmo pra me manifestar publicamente sobre esse assunto.

Os atuais candidatos a presidência não me agradam. Podia dar empate sem votos e os dois desistirem. Contudo, algumas coisas que eu considero balela tem me incomodado muito. Sob o meu ponto de vista, que isso fique bem claro.

Primeiro as campanhas: “for dummies.”  São verdadeiros shows. Vão se agravando, se agravando e até o fim desse mês, quando termina o segundo turno, eles estarão se xingando, podem anotar ai. Como eu já falei antes, caso “cenzinho” no chão com qualquer um como na próxima eleição presidencial as campanhas vão ser dignas de Broadway ou Cirque du Soleil.

Não é isso que precisamos. Nem de promessas baseadas em pequenos pseudo feitos. Mas de propostas, de certeza e hoje em dia, de confiança se possível.

Antes também quero deixar claro que não tenho nada contra o Lula como figura, como representante. Ate votei nele em seu primeiro mandato. Eu acredito que personalização de uma estrutura realmente influencia. E a figura simpatica de nosso presidente conquista espaço. O problema é que presidente sozinho não faz nada e o grupo que ele levou mostrou que era péssima escolha.

Outra coisa que tem me incomodado muito é ver os candidatos assumirem a responsabilidade do crescimento de nosso país. E nesse assunto é que está o “core” do meu pensamento. O crescimento não é graças a esse governo nem ao anterior. O país cresceu pq TINHA que crescer. Era inevitável. Não teve influencia de ninguém. Só tinham duas opções: virávamos Cuba2 ou viveríamos. Alguém pode me falar: Ahhh mas cuba tem uma saúde excelente. Tem sim mas e dai? Eh uma merda de morar. O pessoal la toda hora quer fugir. Eles tem saúde que não faz o pais melhor. Nós temos o melhor futebol e estamos ai enrolados também.

O que eu quero dizer é que isso iria acontecer de qualquer jeito. No meu entendimento, nós somos inexperientes. Algo que eu chamo de “Imaturidade Democrática”. Não temos nem 30 anos ainda de democracia real. A primeira eleição pra presidente tinha bilhões de candidatos, uma zona. Nesse mesmo período que fomos nos adaptando, aprendendo e amadurecendo à força como é essa tal democracia, o mundo estava em ebulição: tecnologia em geral, globalização, comunicação e outras coisas. Não tinha como fugir disso, ou acompanhava ou se fechava(olha Cuba aí).

No geral, não houve influencia com exceção de duas coisas que me recordo. Podem haver mais mas eu me lembro desses dois itens: Plano Real(quem se lembra da URV?) e a abertura comercial ao exterior feita pelo Collor. Ele fez merda sim(imaturo democrático) mas ele deu o grande passo pro nosso crescimento. Na verdade pro nosso não fechamento.

Não acho justo ninguém querer assumir responsabilidade por isso. Iria acontecer de qualquer jeito. Ai fico indignado com as políticas de miséria e esmola como essas bolsas. Eu tenho certeza que ajudam muita gente que precisa delas e sem, não poderiam viver dignamente. Mas também tenho convicção que se ainda houver um pouco de orgulho em todas essas pessoas, mesmo depois de tanto desgaste em nosso país, que elas preferiam conquistar o meio de obter os rendimentos e não recebe-los diretamente. Qualquer um honesto e ainda com um pouco de orgulho e/ou dignidade preferia trabalho e serviço público decente ao invés de um “bolsa-algumacoisa”.

Antes de ir embora quero falar novamente sobre a imaturidade democrática: ela deve ser contida! Logo. E o jeito é assumi-la. Precisamos perceber essa imaturidade, assumir que a temos e trata-la melhor. Essa mesma imaturidade gerou genuinos, dirceus, valérios e colegas. Quem diria que la dentro teriam figuras corruptas deste nível? Sabe pq? Imaturidade. Olha q incrível: eles não estavam preparados nem mesmo para ser honestos.

Acho que é isso.
Espero ter sido claro e comentários são bem vindos.

Abraaaaaaaaaaaaço

Como eu já havia previsto, e tinham me dito, dar andamento a essa parada de Blog não é mesmo fácil. E não é por falta de conteúdo ou experiências mas sim o mesmo motivo de todos: o danado do tempo.

Como tempo é o que me falta resolvi compartilhar o que anda me tomando tanto dele.

Um dos motivos é um novo contrato de consultoria que fechamos eu e @Fred_Castro_ O trabalho é consultoria em um ERP Web SaaS desde concepção e acompanhamento da arquitetura passando por desenvolvimento de Framework.  Tem sido um trabalho muito bom pela liberdade para soluções e experimentação. Sem a pressão do ROI gritando nessa fase.

O outro motivo e matéria desse post é que estava estudando como um camelo para a prova 70-547 da Microsoft. Fiz a prova e passei. Com essa certificação obtive o título de MCPD Web 2.0.

Essa prova estava pendurada no meu backlog havia bastante tempo e é um passo no meu sonhado skill path. Meu próximo passo é o upgrade para a versão 3.5 antes que cheguem as novas.

Resolvi compartilhar meu sentimento com relação à prova.

Primeiro uma coisa que achei chato: A Microsoft não manda mais o Welcome Kit, que continha o seu certificado impresso em um papel bonito que dava orgulho. Faz parte de uma campanha de redução do consumo de papel pró ambiente. O estranho é que se você fizer questão do certificado, pagando, aí sim eles lhe enviam.

Enfim, a prova. Tive o melhor aproveitamentos das 3 que eu fiz apesar de toda a insegurança antes de começar. Tive um rotina de estudos mal regrada e isso sempre me preocupa. Mas foi uma prova extremamente interessante.

Diferente da 70-356 e 70-528 que eu havia feito, essa foi a que teve o maior conteúdo teórico. Ela realmente tem o foco em projeto e não apenas em linguagem e programação. Te testa com relação a componentes, criação de um Framework e pasmem: todo o processo de levantamento e desenho de solução.

Como entusiasta de Agile e sendo ScrumMaster Certificado me causou espanto ler no Training Kit coisas como: visão, levantamento junto ao usuário, stories e não use cases e ainda questionamento sobre eficácia dos use cases. Achei muito interessante a visão pessoal levada nos primeiros capítulos do livro onde você é conduzido através do processo de levantamento e desenho das melhores solucões para atender o projeto. E atentem para o destaque: atender o projeto e não utilizar qualquer tecnologia ou solução por indução de A ou B.

Depois desse início excelente o treinamento te leva ao processo de desenvolvimento de um Framework visando sempre o que é melhor pra atender o projeto e pensando não numa implementação mas numa solução para uma equipe de desenvolvimento. ( função de um arquiteto, talvez?!)

Me identifiquei muito com o andamento, como arquiteto e desenvolvedor. Na parte prática passamos por componentes, soluções avançadas de segurança , ambiente e deploy, entre outros.

Um outro item que me chamou bastante atenção foi a dedicação dada à tratamento de exceções e refatoração. Teoria e prática. Mais uma boa surpresa.

Enfim, acho que foi a prova que eu mais gostei. Pude aprender muito novamente no processo de estudo e vou seguir em frente no path.

Espero não demorar tanto pra postar da próxima vez e trazer algo prático. To com alguns mistérios nas mangas que assim que tiver uma solução trago à tona.

Esses dias tenho pensado muito sobre administração da pressão. Acho ainda que a melhor maneira é a absorção da pior parte e compartilhamento com quem está envolvido/comprometido. Opção essa, contrária a tentar esconder e acabar espalhando ou cascateando( que é pior ) a pressão. Você pode fazer inimigos. E se tá ruim, diga que tá ruim. Mostrar sensibilidade e não tentar dar uma de simpático( formador de caô)  é essencial pra conquistar confiança. Pensando nisso tudo me veio uma frase que repito há anos:

“Nada é melhor do que trocar uma idéia”

O objetivo é falar de tudo um pouco, do que der na cabeça mas tentar manter o foco em TI. Tentar pelo menos.

Ainda não encontrei o nome ideal, a cor ideal, tema, mas vou tentando. Tenho o objetivo também de tentar manter o Blog em uma estrutura .NET, como não podia deixar de ser.

Pra começar, vou postar a solução que encontrei para uma questão levantada essa semana no trabalho:

Como saber se um evento de um objeto foi assinado?

Pra começar, vamos declarar uma classe com um evento disponível:

public class Quency
{
  public event EventHandler OnTest;
  public void Test()
  {
    if (OnTest != null)
      OnTest(this, EventArgs.Empty);
  }
}

Vamos criar uma instância desse objeto e assinar o evento OnTest dele:

Quency quency = new Quency();

quency.OnTest += new EventHandler(quency_OnTest);

Para cada evento de um objeto, o framework cria internamente um Field( campo privado ) em sua instância que mantém todos os métodos ( delegates ) associados a este evento.
Vamos encontrar esse campo, fazer um cast dele para o tipo MulticastDelegate e, se houver alguma assinatura, ele terá a lista de métodos que foram associados:

MulticastDelegate multiCastDelegate = (MulticastDelegate)quency.GetType().GetField("OnTest", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(quency);
if (multiCastDelegate != null)
  Delegate[] delegates = multiCastDelegate.GetInvocationList();

Com essa lista de métodos e acesso ao campo de evento em mãos você pode agora remover, adicionar e até executar os métodos. Lembrando que fizemos todo esse acesso via Reflection e, com sorte, vamos falar muito ainda sobre isso.
Bom é isso. Primeiro Blog, primeiro post. Ja está tarde pra cacete e espero melhorar muito a qualidade dos próximos posts.
Frase do dia, muito conhecida pela equipe de um certo projeto: “Nada é fácil!”
]]> http://subindoaladeira.wordpress.com/2009/10/07/hello-world-2/feed/ 2 Gustavo Rocha