bruno Kenj on System.Web

Pessoal,

outro dia, precisei fazer uma edição de um conteúdo de apenas uma linha (um campo) de uma forma direta, no estilo “Web 2“, para um novo portal que estamos criando no #CFOAB. Para não duplicar código e provavelmente isso iria acontecer, acabei decidindo fazer meu primeiro plugin para o jQuery. Até então, eu vinha mexendo muito com o ExtJS e ficava só na vontade de mexer com o jQuery desde que se tornou padrão no ASP.NET.

A idéia do plugin é simples e deve ser utilizado por um único objeto DOM, utilizando os seletores do jQuery, passando pelo menos dois parâmetros obrigatórios (urlRequest e nomeParam).

Infelizmente, meu host (arght!), não deixou configurado o ASP.NET MVC, nem 1, nem 2, e então eu acabei usando o WebForms para a demonstração, mas vou postar o código utilizando o ASP.NET MVC 1 (RTM) e 2 (RC).

Antes de partir para o código, aqui vai uma DEMO do resultado aplicado em uma div e uma table.

Então vamos aos códigos CSS, Javascript, jQuery e HTML.

Código HTML

<%@ Page Language=”C#” AutoEventWireup=”true”  CodeFile=”Default.aspx.cs” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>

<html xmlns=”http://www.w3.org/1999/xhtml”>
<head runat=”server”>
    <title>JQuery Plugin - Change In Line : Demo - Bruno Kenj</title>
    <link href=”Content/Site.css” rel=”stylesheet” type=”text/css” />
    <script src=”http://ajax.googleapis.com/ajax/libs/jquery/1.4.0/jquery.min.js” type=”text/javascript”></script>
    <!– Microsoft AJAX CDN: http://ajax.microsoft.com/ajax/jquery/jquery-1.4.0.min.js –>
    <script src=“Scripts/ChangeInLine.js” type=“text/javascript”></script>
    <!– Cada aplicação deve ter sua própria configuração de input, etc –>
    <style type=“text/css”>
            input { border:1px solid #e3e3e3; }
            .clEdit { padding: 5px; width:300px; }
            table { border:0px; width:310px; }
            table tr td.texto { width:100px; }
    </style>
</head>

<body>

    <div id=“txtEmail” class=“clEdit”>contato@brunokenj.net</div>

    <table>
        <tr>
            <td class=“texto”>E-mail:</td>
            <td id=“txtEmailTable” class=“clEdit”>contato@brunokenj.net</td>
        </tr>
    </table>

    <script type=“text/javascript”>

        $(document).ready(function() {

            function ChangeEmail(args) {
                alert(‘O email ‘ + args.email + ‘ foi alterado? ‘ + args.sucesso);
            }

            var options = {
                urlRequest: ‘Servicos/AlterarEmail.ashx’,
                nomeParam: ‘email’,
                savedChanges: ChangeEmail
            };

            $(‘#txtEmail’).ChangeInLine(options);

            $(‘#txtEmailTable’).ChangeInLine(options);

        });

    </script>

</body>
</html>

Para fazer a chamada no javascript para o Change In Line, basta recuperarmos o objeto DOM com o jQUery e chamar a função ChangeInLine(opts) informando os parâmetros necessários.

$('#txtEmail').ChangeInLine({ urlRequest: 'Servicos/AlterarEmail.ashx', nomeParam: 'email', savedChanges: ChangeEmail });

Dois parâmetros são obrigatórios:

1. urlRequest: URL que recebe o POST com o conteúdo na variável nomeParam.
2. nomeParam: Nome da variável que vai receber o valor do campo a ser alterado.

Não obrigatórios:

1. savedChanges: function(args). Função para ação pós requisição.
2. urlImageSave: URL da imagem de Salvar.
3. urlImageCancel: URL da imagem de Cancelar.
4. urlImageLoading: URL da imagem de Loading.

Vamos ao restante agora CSS e jQuery.

CSS

/* Componente Change in Line */
.clEdit { background:#fff url(Imagens/12-em-pencil.png) no-repeat 99% 50%; cursor:pointer; padding-right:15px; }
.clEditHover { background-color:#ffffd3; }
.clActive { background-color:#ffffd3; background-image:none; }

Bem simples, apenas três classes. Fique atento ao caminho da imagem na classe clEdit.

E para finalizar, o plugin do jQuery:

Change In Line

/* Criado por Bruno Kenj (http://www.brunokenj.net) */
(function($) {

    $.fn.ChangeInLine = function(options) {

        var defaults = {
            urlRequest: ”,
            nomeParam: ”,
            urlImageSave: ‘Content/Imagens/16-circle-green-check.png’,
            urlImageCancel: ‘Content/Imagens/16-circle-red-delete.png’,
            urlImageLoading: ‘Content/Imagens/loading.gif’,
            savedChanges: function(args) { }
        };

        var options = $.extend(defaults, options);

        var root, valorTexto, html, loading;

        function setActive(obj) {
            obj.data(‘inEdit’, true);
            obj.unbind(‘click’);
        }

        function setInative(obj) {
            obj.data(‘inEdit’, false);
            obj.bind(‘click’, onChangeInLine);
        }

        function setFocus(obj) {
            obj.find(‘input’).select();
        }

        function onFocus() {
            this.select();
        }

        function save() {
            saveChanges(root, false);
        }

        function cancel() {
            saveChanges(root, true);
        }

        function setEventInButtons(obj) {
            obj.find(‘.clSavar’).click(save);
            obj.find(‘.clCancelar’).click(cancel);
        }

        function setHTML(obj, valor) {
            obj.html(valor);
        }

        function toogleActive(obj) {
            obj.toggleClass(“clActive”);
        }

        function isLoading() {
            return loading;
        }

        function setLoading(isLoading) {
            loading = isLoading;

            if (isLoading) {
                var space = ‘&nbsp;’;
                var inputText = ‘<input type=”text” value=”‘ + root.find(‘input’).val() + ‘” disabled=”disabled” />’;
                var imageLoading = ‘<img src=”‘ + options.urlImageLoading + ‘” class=”clLoading” width=”16″ height=”16″ />’;
                setHTML(root, inputText + space + space + imageLoading);
            }
        }

        function onChangeInLine() {
            if (root.data(‘inEdit’) == false || root.data(‘inEdit’) == null) {
                valorTexto = root.html();

                var space = ‘&nbsp;’;
                var inputText = ‘<input type=”text” value=”‘ + valorTexto + ‘”/>’;
                var buttonOK = ‘<img src=”‘ + options.urlImageSave + ‘” class=”clSavar” width=”16″ height=”16″ />’;
                var buttonNO = ‘<img src=”‘ + options.urlImageCancel + ‘” class=”clCancelar” width=”16″ height=”16″ />’;

                html = inputText + space + space + buttonOK + space + buttonNO;

                setActive(root);
                setHTML(root, html);
                setEventInButtons(root);
                setFocus(root);
            }
            else {
                setInative(root);
                setHTML(root, valorTexto);
            }

            toogleActive(root);
        }

        var savedChangesCallBack = function(args) {
            onChangeInLine();
            setLoading(false);
            root.removeClass(‘clEditHover’);
            root.html(eval(‘args.’ + options.nomeParam));
            options.savedChanges(args);
        }

        function saveChanges(obj, cancel) {
            if (cancel) {
                obj.click(onChangeInLine);
            } else {
                var objJson = eval(‘({ “‘ + options.nomeParam + ‘”: “‘ + obj.find(‘input’).val() + ‘” })’);
                setLoading(true);
                jQuery.post(options.urlRequest, objJson, savedChangesCallBack, “json”);
            }
        }

        function mouseOver() {
            $(this).addClass(‘clEditHover’);
        }

        function mouseOut() {
            $(this).removeClass(‘clEditHover’);
        }

        return this.each(function() {
            root = $(this);
            root.click(onChangeInLine)
                .mouseover(mouseOver)
                .mouseout(mouseOut);
        });
    };
})(jQuery);

Dica: para evitar problemas com outras bibliotecas, o mínimo para fazermos o plugin deve ser:

(function($){
 $.fn.ChangeInLine = function() {  

    return this.each(function() {  

    });
 };
})(jQuery);

OK. Mas, ainda falta receber o valor no servidor para realizar a persistência do dado. Vou colocar o exemplo utilizando WebForms, MVC 1 e MVC 2 RC.

Obs: Nestes exemplos, eu adicionei o Thread.Sleep(600) para podermos ver melhor o efeito de loading.

WebForms (AlterarEmail.ashx - Handle HTTP)

<%@ WebHandler Language=“C#” Class=“AlterarEmail” %>

using System;
using System.Web;

public class AlterarEmail : IHttpHandler {

    public void ProcessRequest (HttpContext context) {
        System.Threading.Thread.Sleep(600);
        string email = context.Request.Form[“email”];
        context.Response.ContentType = “text/json”;
        string retorno = string.Format(“”sucesso”: true, ”email”: ”{0}”", email);
        context.Response.Write(“{” + retorno + “}”);
    }

    public bool IsReusable { get { return false; } }
}

Bem simples. Reparem que a variável que vem no Request do Form é o nome (email) informado na configuração do plugin. Aqui, eu poderia ter usado alguma biblioteca para serializar o JSON mas fiz direto com string mesmo.

ASP.NET MVC 1 (ServicosController)

[AcceptVerbs(HttpVerbs.Post)]
public JsonResult AlterarEmail(string email)
{
    System.Threading.Thread.Sleep(600);
    var retorno = new { sucesso = true, email };
    return Json(retorno);
}

ASP.NET MVC 2 (ServicosController)

public JsonResult AlterarEmail(string email)
{
    System.Threading.Thread.Sleep(600);
    var retorno = new { sucesso = true, email };
    return Json(retorno, JsonRequestBehavior.AllowGet);
}

Recursos utilizados e Download:

Download das Imagens
Download da Solução (WebForms)

DEMONSTRAÇÃO

Espero que tenham gostado do plugin. Como eu fiz ele em uma tarde, é possível que exista algum erro. Se alguém encontrar antes de mim, por favor, me informe que eu atualizo o post. Se alguém tiver alguma dúvida, pode me procurar no Twitter: @brunokenj.

Já tenho em mente uma próxima melhoria: permitir o uso de TextArea para campos de textos grandes e outros controles HTML.

abraços,

Pessoal,

Vamos realizar o 2º Happy Hour do BRASILDOTNET no dia 30/01 (Sábado), a partir das 19:00 no FRIDAY’S (Pier 21).

Quem foi no primeiro HH, se divertiu um bocado. Aguardo vocês lá para confratenizarmos e conversamos um pouco sobre o que está por vir em 2010.

Qualquer dúvida, podem me ligar: 9258.1277 (Bruno).

Link da publicação no BRASILDOTNET

abraços,
abraços,

Pessoal,

algumas pessoas estão usando o Chrome e ao colocar o foco dentro de um campo html, uma borda é adicionada automaticamente neste campo. Como desenvolvedores Web, devemos ficar atentos pois isso pode ocasionar algum problema no layout.

A borda adicionada pelo Chrome é mais ou menos isso daqui, somado com o efeito de anti-aliasing.

input:focus { border:1px solid #e3be75; outline:1px solid #f1ca80; }

Para sobrescrevermos este comportamento, basta alterarmos o atributo outline, durante o foco (:focus).

Para substituir em todos os elementos, podemos um dos dois códigos abaixo:

*:focus { outline:0 none; }

input:focus { outline:0 none; }

Para personalizar a borda, podemos usar o seguinte exemplo:

CSS:

*:focus { outline:0 none; }
input { border:1px solid #e3e3e3; }
input.minhaBorda:focus { border:1px solid #000000; }

HTML:

<input class=”minhaBorda” type=”text” />

Bem simples, não? Cuidado, pois alguns objetos como o submit e o button, podem ficar sem foco também. Nesse caso, pode usar um seletor, em CSS ou jQuery - input[type=text] - para filtrar os objetos certos.

abraços,

Pessoal,

Vem aí o SQL Server Saturday Night, dia 16/01, em sua segunda edição, irá abordar temas variados: Filestream, SQL Server 2008 & Sharepoint Server 2007, LINQ, Data Minning & Office 2007, Powershell Extensions, etc.

17:55 - 18:00 >> Abertura do Evento

18:00 - 18:50 >> “Integrando dados do SQL Server 2008 no Sharepoint 2007″ - Marcelo Sincic

18:50 - 19:40 >> “O que voce queria saber sobre Filestream mas não sabia aonde encontrar” - Vitor Fava/Alexandre Lopes

19:40 - 20:30 >> “Preveja o Futuro com os Add-ins de Data Mining do Office 2007” - Thiago Zavaschi

20:30 - 21:20 >> “SQL Server Powershell Extensions” - Laerte Jr

21:20 - 22:10 >> “Usando o SSIS como ferramenta de integração de aplicações” – Roberto Fonseca

22:10 - 23:00 >> “Acesso a dados com LINQ” - Agnaldo Diogo dos Santos

23:00 – 23:10 >> Encerramento do Evento

Você não vai querer perder 5 horas de SQL Server 2008 de graça. Como disse o Alexandre Lopes, um preparativo para o SQL Server Day 2010.

Faça sua inscrição aqui.

abraços,

De 18 a 22 de janeiro acontecerá uma série de webcasts sobre Interoperabilidade na Microsoft Brasil.

Essas apresentações online abordarão as principais tecnologias de integração entre sistemas Microsoft e Open Source e explorará cenários reais de aplicação dessas tecnologias em ambientes heterogêneos.

Você conhecerá a fundo cada passo dos processos e ao final das apresentações poderá fazer perguntas aos palestrantes de cada um dos eventos. Entre eles estão os principais especialistas da comunidade técnica nos temas e profissionais da Microsoft Brasil.

MSDN

O Projeto Mono: Aplicaçõs .NET para sistemas não Windows
Palestrante: Alessandro Binhara
Quando: 18/01, às 17h

Moonlight: Silverlight para sistemas não Windows
Palestrante: Alessandro Binhara
Quando: 19/01, às 17h

Desenvolvimento de games multi-plataforma com .NET
Palestrante: Alessandro Binhara
Quando: 20/01, às 17h

Desenvolvendo aplicativos ASP.NET para Linux
Palestrante: Alessandro Binhara
Quando: 21/01, às 17h

Trabalhando com IronPython
Palestrante: Alessandro Binhara
Quando: 22/01, às 17h

TechNet

Autenticando o Windows no OpenLDAP e Linux no Active Directory
Palestrantes: Fabio Hara, Luciano Kadoya, Fernando Oliveira e André Ruschel
Quando: dia 18/01, ao meio-dia

Monitoramento de plataforma UNIX/Linux
Palestrantes: Rodrigo Dias, Ricardo Frois e Helio Panissa
Quando: dia 19/01, ao meio-dia

Microsoft e Linux em um ambiente mais seguro
Palestrantes: Rodrigo Immaginario e Alberto Oliveira
Quando: dia 20/01, ao meio-dia

Implantando BI estratégico a partir de bancos de dados OpenSource utilizando o SQL Server 2008
Palestrantes: Herleson Pontes e Luiz Pimenta
Quando: dia 21/01, ao meio-dia

Como obter maior produtividade de aplicações PHP com o IIS 7.5
Palestrantes: Pablo Weyne e Igor Humberto
Quando: dia 22/01, ao meio-dia

Não fique de fora e atualize-se!

abraços,

Pessoal, hoje o post é curto.

O Riba, colega de trabalho, precisou remover o cache de um serviço WCF que retorna dados em JSON, pois os dados mudavam e era necessário uma atualização sem recarregar a página.

Chamar o serviço assíncrono não adiantava, porque o output por comportamento padrão, estava em cache. Em termos de performance, tudo bem, mas tem casos que precisamos recuperar sempre os dados atualizados.

Para resolver o problema, vamos informar que não será necessário guardar o cache.

1. Fazer referência para System.Web:

using System.Web;

2. Adicionar as chamadas dentro do método que retornar o objeto JSON.

HttpContext.Current.Response.Cache.SetExpires(DateTime.UtcNow.AddMinutes(-1));
HttpContext.Current.Response.Cache.SetCacheability(HttpCacheability.NoCache);
HttpContext.Current.Response.Cache.SetNoStore();

Veja a lista de HTTP headers

abraços,

Pessoal,

neste sábado eu gravei meu primeiro podcast, junto com o Maurício Júnior, onde falamos um pouco sobre a comunidade BRASILDOTNET e o evento ECO Developers, que foi realizado no mês de outubro.

Clique e ouça o podcast.

Meu áudio ficou bem ruim mas o próximo já vai estar melhor. Comprei o LifeChat™ LX-3000.

abraços,

Pessoal,

ontem, dia 19/11, fizemos o 1º Happy Hour do BRASILDOTNET, para comemorar quase 7 anos do grupo em Brasília.

A confraternização aconteceu no Spicy Bar, na 209 norte e contou com a participação de 15 pessoas, apesar da chuva forte, que teve no final da tarde no plano piloto.

Foi uma excelente oportunidade para rever os amigos, ex-colegas de trabalhos e usuários do grupo BRASILDOTNET. Até o @GildeoniSantos apareceu! Muito bacana.

Estiveram também presentes no evento: @tacidoria, @pablohadler, @robertomb, @mmpimentel, @miltonsampaio, @brunohelius, Aline, Laurent, Luiz Gonzaga (Gonzaguinha) e outros colegas.

Algumas fotos do evento:

Foi bem bacana o networking… valeu pessoal!

abraços,

Pessoal,

segue o convite do 1º Happy Hour do BRASILDOTNET.

Convite Happy Hour BRASILDOTNET

Happy Hour BRASILDOTNET

Eu vou! Vamos?

abraços,

Pessoal,

este é um post que eu queria ter feito há muito tempo atrás. Alguém já se percebeu alguma limitação do Enum do C#?

Como seria um Enum em C# padrão?

public enum Sexo
{
    Masculino,
    Feminino
}

Bacana… mas, além do tipo, percebia outras limitações que atrapalhavam o desenvolvimento. Conversando com o Gildeoni, pensamos em criarmos uma classe de domínio base para podermos trabalhar, de modo desconectado, com outros tipos, conversões, etc. Deste então eu tenho adotado este modelo nos projetos. Além dessa classe base, fizemos alguns métodos de extensão e uma classe para binding.

Eu não vou colocar todas as classes aqui mas o projeto está disponível para download.

Antes de colocar alguns códigos, vou colocar duas imagens para ilustrar o funcionamento da classe de domínio:

Imagem - Domain Class

Imagem - Uso

Para começar, a classe base. Através dela que vamos escpefícicar o tipo do dominio (int, char, string, bool), o nome do objeto e o nome real dele (atributo NameAs: para utilizarmos fazermos binding).

DomainBase.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using Arquitetura35.Attributes;

namespace Arquitetura35.Domain
{
    public abstract class DomainBase<TDomain, TValue> : IEquatable<DomainBase<TDomain, TValue>>, IEquatable<TValue>
        where TDomain : DomainBase<TDomain, TValue>, new()
    {
        public TValue Valor
        {
            get { return __value; }
        }

        private TValue __value;

        public string NameAs
        {
            get
            {
                string nome = string.Empty;

                BindingFlags bindings = (BindingFlags.Public | BindingFlags.Static);
                FieldInfo[] fieldInfos = this.GetType().GetFields(bindings);

                foreach (FieldInfo fieldInfo in fieldInfos)
                {
                    object domainValue = fieldInfo.GetValue(null);

                    if (this.__value.ToString() == domainValue.ToString())
                    {
                        IgnoreAttribute ignoreAttribute = fieldInfo.GetCustomAttribute<IgnoreAttribute>();

                        if (ignoreAttribute != null)
                        {
                            break;
                        }

                        NameAsAttribute nameAsAttribute = fieldInfo.GetCustomAttribute<NameAsAttribute>();

                        if (nameAsAttribute != null)
                        {
                            nome = nameAsAttribute.Name;

                            break;
                        }
                    }
                }

                return nome;
            }
        }

        public static List<TDomain> ToList()
        {
            List<TDomain> lista = new List<TDomain>();

            Type genericType = typeof(TDomain);
            BindingFlags bindings = (BindingFlags.Public | BindingFlags.Static);
            FieldInfo[] fieldInfos = genericType.GetFields(bindings);

            foreach (FieldInfo fieldInfo in fieldInfos)
            {
                object domainValue = fieldInfo.GetValue(null);
                lista.Add((TDomain)domainValue);
            }

            return lista;
        }

        protected DomainBase()
        {

        }

        protected DomainBase(TValue value)
        {
            this.__value = value;
        }

        public bool Equals(DomainBase<TDomain, TValue> other)
        {
            if (other != null)
            {
                return (other == this);
            }

            return (false);
        }

        public bool Equals(TValue other)
        {
            IEquatable<TValue> equatable = (other as IEquatable<TValue>);

            if (equatable != null)
            {
                return (equatable.Equals(this.__value));
            }

            return (Object.Equals(this.__value, other));
        }

        public override bool Equals(object obj)
        {
            DomainBase<TDomain, TValue> myBase = (obj as DomainBase<TDomain, TValue>);

            if (myBase != null)
            {
                return (myBase == this);
            }

            return (false);
        }

        public override int GetHashCode()
        {
            if (this.__value != null)
            {
                return (this.__value.GetHashCode());
            }

            return (base.GetHashCode());
        }

        public override string ToString()
        {
            return (this.__value.ToString());
        }

        public static explicit operator TValue(DomainBase<TDomain, TValue> rightValue)
        {
            return rightValue.__value;
        }

        public static explicit operator DomainBase<TDomain, TValue>(TValue rightValue)
        {
            TDomain domain = new TDomain();

            domain.__value = rightValue;

            return (domain);
        }

        public static bool operator !=(DomainBase<TDomain, TValue> leftValue, DomainBase<TDomain, TValue> rightValue)
        {
            return (!(leftValue == rightValue));
        }

        public static bool operator ==(DomainBase<TDomain, TValue> leftValue, DomainBase<TDomain, TValue> rightValue)
        {
            bool leftIsNull = Object.ReferenceEquals(leftValue, null);
            bool rightIsNull = Object.ReferenceEquals(rightValue, null);

            if (leftIsNull && rightIsNull)
            {
                return (true);
            }
            else if (leftIsNull || rightIsNull)
            {
                return (false);
            }

            IEquatable<TValue> equatable = (leftValue.__value as IEquatable<TValue>);

            if (equatable != null)
            {
                return (equatable.Equals(rightValue.__value));
            }

            equatable = (rightValue.__value as IEquatable<TValue>);

            if (equatable != null)
            {
                return (equatable.Equals(leftValue.__value));
            }

            return (Object.Equals(leftValue.__value, rightValue.__value));
        }
    } // class DomainBase
} // namespace Arquitetura35.Domain

ExtensionMethods.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Globalization;
using System.Web;
using System.Web.UI.WebControls;
using System.Web.UI;

public static class ExtensionMethods
{
    #region Object

    public static TResult To<TResult>(this object source)
    {
        return (To<TResult>(source, CultureInfo.CurrentCulture));
    }

    public static TResult To<TResult>(this object source, IFormatProvider provider)
    {
        if (source != null)
        {
            object result = Convert.ChangeType(source, typeof(TResult), provider);

            return ((TResult)result);
        }

        return (default(TResult));
    }

    #endregion

    #region Web

    public static TResult GetSelectedValue<TResult>(this ListControl listControl)
    {
        if (listControl == null)
        {
            throw (new ArgumentNullException(“listControl”));
        }

        string selectedValue = listControl.SelectedValue;

        if (!String.IsNullOrEmpty(selectedValue))
        {
            TResult value = selectedValue.To<TResult>();

            return (value);
        }

        return (default(TResult));
    }

    public static void CarregarItemInicial(this DropDownList ddl)
    {
        ddl.Clear();
        ddl.AppendDataBoundItems = true;
        ddl.Items.Add(new ListItem(“Selecione o item”, “-1″));
    }

    public static void Popular<TClass>(this ListControl ddl, IList<TClass> tClass, string valor, string texto)
    {
        ddl.DataTextField = texto;
        ddl.DataValueField = valor;
        ddl.DataSource = tClass;
        ddl.DataBind();
    }

    public static void Clear(this ITextControl textControl)
    {
        if (textControl == null)
        {
            throw (new ArgumentNullException(“textControl”));
        }

        if (textControl is System.Web.UI.WebControls.ListControl)
        {
            ((System.Web.UI.WebControls.ListControl)textControl).Items.Clear();
        }
        else
        {
            textControl.Text = String.Empty;
        }
    }

    #endregion
}

DomainBindingSource.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.Collections;
using System.Reflection;

using Arquitetura35.Attributes;

namespace Arquitetura35
{
    /// <summary>
    /// 
    /// </summary>
    public class DomainBindingSource : Component, IListSource, IEnumerable, IEnumerable<DomainBindingSource.DomainListItem>
    {
        /// <summary>
        /// 
        /// </summary>
        public class DomainListItem
        {
            private string _campo;

            private object _valor;

            public DomainListItem()
            {

            }

            public DomainListItem(string campo, object valor)
            {
                this._campo = campo;
                this._valor = valor;
            }

            /// <summary>
            /// 
            /// </summary>
            public string Campo
            {
                get { return (this._campo ?? String.Empty); }
                set { this._campo = value; }
            }

            /// <summary>
            /// 
            /// </summary>
            public object Valor
            {
                get { return (this._valor); }
                set { this._valor = value; }
            }

            /// <summary>
            /// 
            /// </summary>
            /// <returns></returns>
            public override string ToString()
            {
                return (this.Campo);
            }
        }

        private List<DomainListItem> list = new List<DomainListItem>();

        private Type _domainType;

        /// <summary>
        /// 
        /// </summary>
        public DomainBindingSource()
        {

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name=”domainType”></param>
        public DomainBindingSource(Type domainType)
        {
            DomainBindingSource.ValidateDomainType(domainType);

            this._domainType = domainType;
            this.CreateList();
        }

        /// <summary>
        /// 
        /// </summary>
        bool IListSource.ContainsListCollection
        {
            get { return true; }
        }

        /// <summary>
        /// 
        /// </summary>
        [Browsable(true)]
        [Description(“Indicates the type of the System.Class that will be used as data source.”)]
        public Type DomainType
        {
            get { return this._domainType; }

            set
            {
                DomainBindingSource.ValidateDomainType(value);

                if (this._domainType != value)
                {
                    this._domainType = value;
                    this.CreateList();
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        IEnumerator<DomainListItem> IEnumerable<DomainListItem>.GetEnumerator()
        {
            foreach (DomainListItem item in this.list)
            {
                yield return (item);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        IList IListSource.GetList()
        {
            return this.list;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name=”domainType”></param>
        /// <returns></returns>
        private static Dictionary<string, object> GetNames(Type domainType)
        {
            Dictionary<string, object> names = new Dictionary<string, object>();

            BindingFlags bindings = (BindingFlags.Public | BindingFlags.Static);

            FieldInfo[] fieldInfos = domainType.GetFields(bindings);

            foreach (FieldInfo fieldInfo in fieldInfos)
            {
                object domainValue = fieldInfo.GetValue(null);
                IgnoreAttribute ignoreAttribute = fieldInfo.GetCustomAttribute<IgnoreAttribute>();

                if (ignoreAttribute != null)
                {
                    names.Add(null, null);

                    continue;
                }

                NameAsAttribute nameAsAttribute = fieldInfo.GetCustomAttribute<NameAsAttribute>();

                if (nameAsAttribute != null)
                {
                    names.Add(nameAsAttribute.Name, domainValue);

                    continue;
                }

                names.Add(fieldInfo.Name, domainValue);
            }

            return names;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name=”domainType”></param>
        private static void ValidateDomainType(Type domainType)
        {
            SpecialDomainClassAttribute specialDomain = domainType.GetCustomAttribute<SpecialDomainClassAttribute>();

            if (specialDomain == null)
            {
                throw new Exception(“O tipo não é uma classe de domínio especial”);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        private void CreateList()
        {
            this.list.Clear();

            Dictionary<string, object> names = DomainBindingSource.GetNames(this._domainType);

            foreach(KeyValuePair<string, object> pair in names)
            {
                if (pair.Key != null)
                {
                    DomainListItem listItem = new DomainListItem(pair.Key, pair.Value);
                    this.list.Add(listItem);
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public IEnumerator GetEnumerator()
        {
            return this.list.GetEnumerator();
        }
    }
}

Negocio.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

using Arquitetura35;
using Domain;

/// <summary>
/// Summary description for Negocio
/// </summary>
public class Negocio
{
    public Negocio()
    {

    }

    public static List<DomainBindingSource.DomainListItem> RetornaTodos()
    {
        return RetornaTodosOrdenado(true);
    }

    public static List<DomainBindingSource.DomainListItem> RetornaTodosOrdenado(bool asc)
    {
        if (asc)
            return new DomainBindingSource(typeof(Status)).OrderBy(p => p.Campo).ToList();
        else
            return new DomainBindingSource(typeof(Status)).OrderByDescending(p => p.Campo).ToList();
    }
}

Existem algumas classes de atributos também que eu não vou colocar aqui, mas elas estão no projeto.

Agora, vamos ao principal, nossas classes de Domínio, Sexo e Status:

Sexo.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Arquitetura35.Domain;
using Arquitetura35.Attributes;

namespace Domain
{
    [SpecialDomainClass]
    public class Sexo : DomainBase<Sexo, bool>
    {
        #region ”  Construtores  “

        public Sexo() : base(true)
        {

        }

        protected Sexo(bool value) : base(value)
        {

        }

        #endregion

        #region ”  Domínios  “

        [NameAs(“Masculino”)]
        public static readonly Sexo Masculino = new Sexo(true);

        [NameAs(“Feminino”)]
        public static readonly Sexo Feminino = new Sexo(false);

        #endregion
    }
}

Status.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Arquitetura35.Domain;
using Arquitetura35.Attributes;

namespace Domain
{
    [SpecialDomainClass]
    public class Status : DomainBase<Status, int>
    {
        #region ”  Construtores  “

        public Status() : base(1)
        {

        }

        protected Status(int value)
            : base(value)
        {

        }

        #endregion

        #region ”  Domínios  “

        [NameAs(“Sem Status”)]
        public static readonly Status Sem_Status = new Status(1);

        [NameAs(“Ativo”)]
        public static readonly Status Ativo = new Status(2);

        [NameAs(“Inativo”)]
        public static readonly Status Inativo = new Status(3);

        #endregion
    }
}

Legal, é possível então criar “Enumeradores” com String, Char, Bool…

Vamos ao mais interessante agora, ver o uso disso no ASP.NET e no C#:

Default.aspx

<%@ Page Language=”C#” AutoEventWireup=”true”  CodeFile=”Default.aspx.cs” Inherits=”_Default” %>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>

<html xmlns=”http://www.w3.org/1999/xhtml”>
<head runat=”server”>
    <title></title>
</head>
<body>
    <form id=”form1″ runat=”server”>

        <p>1. Recuperar o nome do Domínio: <asp:Label ID=”lblNomeDominio” runat=”server”></asp:Label></p>

        <p>2. Conversão do valor para o Nome: <asp:Label ID=”lblConversaoValor” runat=”server”></asp:Label></p>

        <p>
            3. Carregar um DDL com a classe de dominio:
            <asp:DropDownList ID=”ddlStatus” runat=”server”></asp:DropDownList><br />
            <asp:Label ID=”lblStatus” runat=”server”></asp:Label><br />
            <asp:Button ID=”btnEnviar” runat=”server” Text=”Enviar” onclick=”btnEnviar_Click” />
        </p>

        <p>2. Parse de String para Domain: <asp:Label ID=”lblParseDomain” runat=”server”></asp:Label></p>

    </form>
</body>
</html>

Default.aspx.cs

using System;
using System.Collections.Generic;
using System.Web.UI;

using Domain;
using Arquitetura35.Domain;

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!Page.IsPostBack)
        {
            // Exemplo 1
            lblNomeDominio.Text = Status.Sem_Status.NameAs;

            // Exemplo 2
            bool sexo = true; // Masculino
            lblConversaoValor.Text = ((Sexo)sexo).NameAs;

            // Exemplo 3
            ddlStatus.CarregarItemInicial();
            ddlStatus.Popular(Negocio.RetornaTodos(), “Valor”, “Campo”);

            // Exemplo 4
            lblParseDomain.Text = Dominio<Sexo>.Parse(“Masculino”).Valor.ToString();

            // Exemplo 5
            int status = 1; // Suponha que venha do SQL Server;

            if (status == Status.Ativo.Valor) { }
            else if (status == Status.Inativo.Valor) { }

            // Exemplo 6
            List<Sexo> lstSexo = Sexo.ToList();
        }
    }

    protected void btnEnviar_Click(object sender, EventArgs e)
    {
        lblStatus.Text = string.Format(“Valor: {0} | Texto: {1}”,
            ddlStatus.GetSelectedValue<int>(),
            ((Status)ddlStatus.GetSelectedValue<int>()).NameAs);
    }
}

Não parei para detalhar como funciona a classe DomainBase, mas se alguém tiver alguma dúvida, pode entrar em contato comigo pelo e-mail: contato@brunokenj.net.

Basicamente, são dois atributos que a classe de dominio vai ter: NameAs e Valor, para recuperarmos o Nome (podendo ter espaço) e o Valor, respectivamente. No binding, estas são as duas propriedades utilizadas como “Texto” e “Valor”. Desde então, nunca mais usei Enum no C#. Espero que tenham gostado da solução. Agradecimentos especiais ao Gildeoni que me ajudou com esta solução.

Faça o download da solução. Lembrando: coloquei as classes dentro da pasta APP_CODE do ASP.NET. O ideal separar essas classes em projetos a parte, para poder reutilizar em todos os projetos.

abraços,

Próxima Página »

bruno Kenj on System.Web

Desenvolvimento Web (ASP.NET, Javascript, Usabilidade e Padrões)

MCP, MCAD, MCSD.NET, MCTS, MCPD

Meu Primeiro jQuery Plugin - Change in Line

2º Happy Hour do BRASILDOTNET

Altere a borda automática em campos ativos no Browser

SQL Server Saturday Night – 2ª edição

Semana de Interoperabilidade na Web

Remover o Cache de respostas JSON com Serviços WCF

Podcast com Maurício Júnior. #BRASILDOTNET e #ECOdevelopers

Resumo e Fotos do #HHBDN

1º Happy Hour do BRASILDOTNET (19/11)

Classe de Domínio (sem Enum)

Arquivos

Tags

Links

Lista de Links

Feed on RSS

VISITANTES