Lambda

Apaixonado por tecnologia. Tenho 7 anos de experiência em Desenvolvimento e Análise de requisitos.

Sólidos conhecimentos em Office System, plataforma .NET (Framework 3.5), C#, Linq.

Fale comigo.

Siga-me no Twitter

Ultimos comentários

Exemplos para Download

Calendário de Posts

s	t	q	q	s	s	d
30	31	1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	1	2	3	4
5	6	7	8	9	10	11

Ultimos comentários

Siga o @DicaDoNerd no Twitter e acompanhe as novidades

Utilizando Checkbox em uma TreeView para selecionar e excluir nodes com LinqToSql

Minato , Criado em 28/06/2011, 21:13

Depois de apanhar um pouco com o evento SelectedNodeChanged do TreeView do ASP.NET descobri que o fato de você clicar no checkbox não dispara o evendo para o servidor. Procurei um pouco e encontrei este site que funcionou perfeitamente.

Publiquei este artigo que demostra como preencher um TreeView de forma recursiva utilizando LinqToSql, como este não é o foco, não vou entrar em detalhes sobre o preenchimento.

Primeiro vamos montrar a estrutura para exclusão, neste artigo é possível entender as propriedades ObjectTrackingEnabled e DeferredLoadingEnabled. Para a estrutura do Context utilizei uma técnica bem interessante deste livro (que aliás é excelente) que foi originado deste site

Criei uma tabela de segmentos que utiliza uma recursividade (ParentID) para preechimento e o grande problema era excluir os dados no TreeView.

Criei uma solução bastante simples para este problema. Habilitei o Checkbox no TreeView e passo uma lista de Ids que serão excluídas.

O primeiro passo é habilitar o TreeView e criar um botão para excluir os itens selecionados.

<asp:LinkButton ID="lk" runat="server" OnClick="Excluir" Text="Excluir" /> <asp:TreeView ID="tv" ShowCheckBoxes="All" runat="server" />
HTML	Resultado.

Agora vamos incluir o javascript no projeto que será resposável para selecionar os checkboxs.

<script type="text/javascript">
function OnCheckBoxCheckChanged(evt) {
    var src = window.event != window.undefined ? window.event.srcElement : evt.target;
    var isChkBoxClick = (src.tagName.toLowerCase() == "input" && src.type == "checkbox");
    if (isChkBoxClick) {
        var parentTable = GetParentByTagName("table", src);
        var nxtSibling = parentTable.nextSibling;
        if (nxtSibling && nxtSibling.nodeType == 1)//check if nxt sibling is not null & is an element node 
        {
            if (nxtSibling.tagName.toLowerCase() == "div") //if node has children 
            {
                //check or uncheck children at all levels 
                CheckUncheckChildren(parentTable.nextSibling, src.checked);
            }
        }
        //check or uncheck parents at all levels 
        CheckUncheckParents(src, src.checked);
    }
}
function CheckUncheckChildren(childContainer, check) {
    var childChkBoxes = childContainer.getElementsByTagName("input");
    var childChkBoxCount = childChkBoxes.length;
    for (var i = 0; i < childChkBoxCount; i++) {
        childChkBoxes[i].checked = check;
    }
}
function CheckUncheckParents(srcChild, check) {
    var parentDiv = GetParentByTagName("div", srcChild);
    var parentNodeTable = parentDiv.previousSibling;

    if (parentNodeTable) {
        var checkUncheckSwitch;

        if (check) //checkbox checked 
        {
            var isAllSiblingsChecked = AreAllSiblingsChecked(srcChild);
            if (isAllSiblingsChecked)
                checkUncheckSwitch = true;
            else
                return; //do not need to check parent if any(one or more) child not checked 
        }
        else //checkbox unchecked 
        {
            checkUncheckSwitch = false;
        }

        var inpElemsInParentTable = parentNodeTable.getElementsByTagName("input");
        if (inpElemsInParentTable.length > 0) {
            var parentNodeChkBox = inpElemsInParentTable[0];
            parentNodeChkBox.checked = checkUncheckSwitch;
            //do the same recursively 
            CheckUncheckParents(parentNodeChkBox, checkUncheckSwitch);
        }
    }
}
function AreAllSiblingsChecked(chkBox) {
    var parentDiv = GetParentByTagName("div", chkBox);
    var childCount = parentDiv.childNodes.length;
    for (var i = 0; i < childCount; i++) {
        if (parentDiv.childNodes[i].nodeType == 1) //check if the child node is an element node 
        {
            if (parentDiv.childNodes[i].tagName.toLowerCase() == "table") {
                var prevChkBox = parentDiv.childNodes[i].getElementsByTagName("input")[0];
                //if any of sibling nodes are not checked, return false 
                if (!prevChkBox.checked) {
                    return false;
                }
            }
        }
    }
    return true;
}
//utility function to get the container of an element by tagname 
function GetParentByTagName(parentTagName, childElementObj) {
    var parent = childElementObj.parentNode;
    while (parent.tagName.toLowerCase() != parentTagName.toLowerCase()) {
        parent = parent.parentNode;
    }
    return parent;
} 

</script>

Pronto! Camada de apresentação pronta, vamos preparar a estruta que será responsável pela exclusão.

Anexando a classe no dbml (LinqToSql)

Tem um artigo que demonstra como criar o objeto relacional com o Linq.

Crie uma classe DBHelper.

public static class DbHelper
{    
    public static dbDadosDataContext getContextData(bool ObjectTrackingEnabled)
    {
        var db = getContextData();
        db.ObjectTrackingEnabled = ObjectTrackingEnabled;
        return db;
    }

    public static dbDadosDataContext getContextData(bool ObjectTrackingEnabled, bool DeferredLoadingEnabled)
    {
        var db = getContextData();
        db.ObjectTrackingEnabled = ObjectTrackingEnabled;
        db.DeferredLoadingEnabled = DeferredLoadingEnabled;
        return db;

    }

    public static dbDadosDataContext getContextData()
    {
        //Colocar a connectionString no web.Config
        string strCnn = ConfigurationManager.ConnectionStrings["cnnConnectionString"].ConnectionString;
        var db = new dbDadosDataContext(strCnn);
        db.DeferredLoadingEnabled = false;
        db.ObjectTrackingEnabled = false;
        return db;
    }

}

Agora vamos criar o método responsável pela exclusão.

public class Segmento : IDisposable
   {
       private dbDadosDataContext db;
       public Segmento()
       {
           db = DbHelper.getContextData();
       }

       public void ExcluirSegmentos(List<int> listSegments)
       {
           db.ObjectTrackingEnabled = true; // Habilito o tracking por haver manipulação no BD.
           var segs = db.SegmentoEntidades.Where(p => listSegments.Contains(p.IDSegmento));
           db.SegmentoEntidades.DeleteAllOnSubmit(segs);
           db.SubmitChanges();

       }

       public void PreencherTreeViewSegmento(TreeView objTreeView, int? IDNoCarregar)
       {
           //A vantagem de utilizar o IQuarable é que a execução do Banco só será realizada no Bind.
           IQueryable<SegmentoEntidade> seg = db.SegmentoEntidades
                                              .Where(p => p.Inativo == false)
                                              .OrderBy(p => p.ParentID)
                                              .OrderBy(p => p.Segmento);

           //Limpo os nodes existentes.
           objTreeView.Nodes.Clear();

           var itens = seg.Where(p => (p.ParentID == null ? 0 : p.ParentID) == (IDNoCarregar == null ? 0 : IDNoCarregar))
                          .OrderBy(p => p.ParentID)
                          .OrderBy(p => p.Segmento);

           //passo por todos os nodes que foi passado como parâmetro para carregar. (organizando em ordem alfabética
           foreach (var item in itens)
           {
               //Preencho o nó pai
               TreeNode nodePai = new TreeNode();
               nodePai.Value = item.IDSegmento.ToString();
               nodePai.Text = item.Segmento;
               nodePai.ImageToolTip = item.Segmento;
               //nodePai.ImageUrl = _db.IconeEntidades.Where(p => p.IDIcone == item.IDIcone).FirstOrDefault().urlImagem;
               //Preecho os filhos
               PreencherNoFilho(nodePai, seg);

               //Adiciono o nó que foi preenchido
               objTreeView.Nodes.Add(nodePai);
           }

       }
       protected void PreencherNoFilho(TreeNode parentNode, IQueryable<SegmentoEntidade> segmentos)
       {
           //Passo por todos os elementos filhos do nó pai
           var itens = segmentos.Where(p => p.ParentID == int.Parse(parentNode.Value)).OrderBy(p => p.ParentID)
                                .OrderBy(p => p.Segmento)

           foreach (var item in itens)
           {

               TreeNode noFiltro = new TreeNode();
               noFiltro.Value = item.IDSegmento.ToString();
               noFiltro.Text = item.Segmento;
               noFiltro.SelectAction = TreeNodeSelectAction.SelectExpand; //Expando no nó.
               parentNode.ChildNodes.Add(noFiltro); //adiciono na coleção de nós
               PreencherNoFilho(noFiltro, segmentos); //Preenchemos os filhos deste Node (recursividade)
           }


       }

       ~Segmento()
       {
           this.Dispose();
       }

       #region IDisposable Members

       public void Dispose()
       {
           GC.Collet();
           GC.SuppressFinalize(this);
       }

       #endregion
   }

Agora vamos criar os métodos na camada de apresentação.

Page_Load.

protected void Page_Load(object sender, EventArgs e)
{
    if (!Page.IsPostBack)
    {
        //Preencho o controle treeview
        FillControls(); //
        //atribuimos o evento click ao checkbox
        tv.Attributes.Add("onclick", "OnCheckBoxCheckChanged(event)"); 

    }

}

O método responsável para

Preencher o controle TreeView.

protected void FillControls()
{

    using (Segmento seg = new Segmento())
    {
        seg.PreencherTreeViewSegmento(tv, null);

    }

}

Agora vamos criar o método que irá excluir.

protected void Excluir(object sender, EventArgs e)
{
    List<int> lista = new List<int>();
    //Preencho a lista com os Nodes selecionados.

    foreach (TreeNode item in tv.CheckedNodes)
        lista.Add(int.Parse(item.Value));
    
    using (Negocio.Cliente.Segmento seg = new Negocio.Cliente.Segmento())
    {
        seg.ExcluirSegmentos(lista);
    }
    FillControls();
}

Pronto, de uma forma bem simples e estruturada preenchemos e excluimos itens com checkbox.

Espero que tenham gostado.

Sigam o @DicaDoNerd no Twitter.

d743f946-e884-4e05-ab0d-4c39d7eb7142|2|5.0

Tags: TreeView, TreeNode, DataContext, DBHelper Categorias: LINQ | Lambda | ASP.NET | C#

E-mail | Permalink | Comentários (0) |

Como criar Expressões lambdas dinâmicamente.

Minato , Criado em 25/04/2010, 17:12

Surgiu a necessidade em um projeto de criar uma estrutura para criar filtrar entidades dinâmicamente com C#. A idéia era criar uma estrutura onde qualquer desenvolvedor pudesse utilizar a estrutura em qualquer lugar, desde que, a entidade estivesse preenchida. Passando muitas horas apanhando, cheguei em uma solução bem viável, tanto no quesito performance quanto no quesito usabilidade. Neste site encontrei bastante informações úteis.

Hoje, com a evolução do Linq e Expressões lambdas o trabalho no desenvolver reduziu drasticamente. Para filtrar dados em entidade com Linq e Expressão lambdas poderíamos fazer assim:

        1: IList Resultado  = clientes.Where(p => p.Idade > 5).ToList();

Aí surgiu o desafio, como criar o “Where” e as Expressões dinamicamente:

Com uma estrutura bem simples, com dois métodos de extensão (um sobrecarregado), onde o usuário pode passar qual a propriedade deseja filtrar, o Tipo de Comparação e o valor que deseja procurar, com isso, Criei também uma classe que pode ser utilizada para executar diversos filtros.

Como os estrutura utilizada para filtrar (Lst<Filtroentidade>) ficam em um ViewState, pois, há varios controles que implementam a mesma interface, surgiu um problema quando o filtro deveria ser excluído, como não existia um ID (pois os filtros ainda não estavam na base de dados) para cada nova instancia do objeto guardo o hash do objeto para poder excluir. Sempre que um filtro é aplicado, marco a aplicação através da propriedade FiltroAplicado. Assim, as informações não serão filtradas novamente.

Classe que contem a estrutura que utilizada para filtrar a entidade.

       1: public class FiltroEntidade

       2:    {

       3:        public enum TipoComparacao

       4:        {

       5:            Igual,

       6:            Diferente,

       7:            Contem,

       8:            MaiorIgual,

       9:            MenorIgual,

      10:            Maior

      11:  

      12:        }

      13:  

      14:        public int hashCode

      15:        {

      16:            //Atribui o hash de cada item gerado para caso eu precise remover um determinado item de uma lista de filtros.

      17:            get { return this.GetHashCode(); }

      18:        }

      19:  

      20:        public string NomePropriedade { get; set; }

      21:        public TipoComparacao tipoCompracao { get; set; }

      22:        public string ValorProcurar { get; set; }

      23:        public Type Entidade { get; set; }

      24:        public bool FiltroAplicado { get; set; }

      25:  

      26:  

      27:  

      28:    }

Classe que contém os métodos reponsáveis por filtrar os dados da entidade.

       1: public static class Filtro

       2:     {

       3:         /// <summary>

       4:         /// Aplica uma lista de Filtros em uma entidade.

       5:         /// </summary>

       6:         /// <typeparam name="TEntidade">Instancia da entidade que será filtrada</typeparam>

       7:         /// <param name="entidadeOrigem">entidade que está sendo filtrada</param>

       8:         /// <param name="filtros">Lista de Filtros que deverão ser aplicadas</param>

       9:         /// <returns>Retorna um objeto com a lista das entidades filtradas</returns>

        public static IQueryable<TEntidade> Filtrar<TEntidade>(this IQueryable<TEntidade> entidadeOrigem, List<FiltroEntidade> filtros) where TEntidade : class

        {

            //Pega apenas filtros que ainda não foram aplicados, em caso da lista de filtros ser reutilizada

            List<FiltroEntidade> filtrosAplicar = filtros.Where(p => p.FiltroAplicado == false).ToList();

  

            foreach (FiltroEntidade item in filtrosAplicar)

            {

                entidadeOrigem = entidadeOrigem.Filtrar(item.NomePropriedade, item.tipoCompracao, item.ValorProcurar);

                item.FiltroAplicado = true;

            }

  

            return entidadeOrigem;

  

        }

  

  

        /// <summary>

        /// Aplica um unico Filtro

        /// </summary>

        /// <typeparam name="TEntidade">Instancia da Entidade</typeparam>

        /// <param name="entidadeOrigem">objeto que será filtrada</param>

        /// <param name="NomePropriedade">Nome da propriedade</param>

        /// <param name="TipoComparacao">Tipo Comparação</param>

        /// <param name="ValorProcurar">Valor que será filtrado filtrar</param>

        /// <returns>Retorna um objeto com a lista das entidades filtradas</returns>

        public static IQueryable<TEntidade> Filtrar<TEntidade>(this IQueryable<TEntidade> entidadeOrigem, string NomePropriedade, Minato.Entidades.FiltroEntidade.TipoComparacao TipoComparacao, string ValorProcurar)

                                                                where TEntidade : class

        {

  

            Type type = typeof(TEntidade);

            ConstantExpression procurarFiltro = Expression.Constant(ValorProcurar);

            ParameterExpression parametro = Expression.Parameter(type, "p");

            PropertyInfo propriedade = type.GetProperty(NomePropriedade);

            Expression acesssoPropriedade = Expression.MakeMemberAccess(parametro, propriedade);

  

            Type tipo = Nullable.GetUnderlyingType(propriedade.PropertyType);

  

            if (tipo != null)

            {

                PropertyInfo valProp = typeof(Nullable<>).MakeGenericType(tipo).GetProperty("Value");

                acesssoPropriedade = Expression.MakeMemberAccess(acesssoPropriedade, valProp);

            }

            else

            {

                tipo = acesssoPropriedade.Type;

            }

            if (tipo == typeof(Guid))

            {

                Guid guid = new Guid(ValorProcurar);

                procurarFiltro = Expression.Constant(guid);

            }

            else

            {

                procurarFiltro = Expression.Constant(Convert.ChangeType(ValorProcurar, tipo));

            }

  

  

            MethodInfo startsWith = typeof(string).GetMethod("StartsWith", new Type[] { typeof(string) });

            MethodInfo endsWith = typeof(string).GetMethod("EndsWith", new Type[] { typeof(string) });

            MethodInfo contains = typeof(string).GetMethod("Contains", new Type[] { typeof(string) });

            Expression operacaoRealizar = null;

            switch (TipoComparacao)

            {

                default:

                case FiltroEntidade.TipoComparacao.Igual:

                    operacaoRealizar = Expression.Equal(acesssoPropriedade, procurarFiltro);

                    break;

                case FiltroEntidade.TipoComparacao.Diferente:

                    operacaoRealizar = Expression.NotEqual(acesssoPropriedade, procurarFiltro);

                    break;

  

                case FiltroEntidade.TipoComparacao.Maior:

                    operacaoRealizar = Expression.GreaterThan(acesssoPropriedade, procurarFiltro);

                    break;

                case FiltroEntidade.TipoComparacao.MaiorIgual:

                    operacaoRealizar = Expression.GreaterThanOrEqual(acesssoPropriedade, procurarFiltro);

                    break;

  

                case FiltroEntidade.TipoComparacao.Contem:

                    operacaoRealizar = Expression.Call(acesssoPropriedade, contains, procurarFiltro);

                    break;

  

            }

            var ExpressaoWhere = Expression.Lambda(operacaoRealizar, parametro);

            var ResultadoDaExpressao = Expression.Call(typeof(Queryable), "Where", new Type[] { entidadeOrigem.ElementType }, entidadeOrigem.Expression, ExpressaoWhere);

  

            return entidadeOrigem.Provider.CreateQuery<TEntidade>(ResultadoDaExpressao);

        }

    }

Resultado:

Para quem estiver preocupado com performance, segue aí o comparativo.

É isso mesmo, foi mais performático do que o modelo tradicional de lambda. (Executei 10 vezes, com dois itens na lista, um com tipo de comparação contains e outro com “maior igual“.

Quer saber como foi realizado o comparativo? Pois, em tecnologia a primeira pergunta é: Mas como foi feita esta comparação?

       1: class Program

       2:     {

       3:         static void Main(string[] args)

       4:         {

       5:             List<ClienteEntidade> clientes = new List<ClienteEntidade>();

       6:             Random rnd = new Random();

       7:  

       8:             int QtdadeRegistrosAdicionar = 1000000;

       9:  

            Stopwatch tempo = new Stopwatch();

  

            tempo.Start();

  

            for (int i = 0; i < QtdadeRegistrosAdicionar; i++)

            {

                clientes.Add(new ClienteEntidade { NomeCliente = "Cliente" + i, Endereco = "Endereço" + i, Idade = i, Salario = rnd.Next(1000, 10000) });

  

            }

            tempo.Stop();

            Console.WriteLine("Tempo gasto para preencher {0} registros: {1}", QtdadeRegistrosAdicionar, tempo.Elapsed);

            List<FiltroEntidade> filtros = new List<FiltroEntidade>();

            filtros.Add(new FiltroEntidade { NomePropriedade = "NomeCliente", tipoCompracao = FiltroEntidade.TipoComparacao.Contem, ValorProcurar = "Cli" });

            filtros.Add(new FiltroEntidade { NomePropriedade = "Idade", tipoCompracao = FiltroEntidade.TipoComparacao.MaiorIgual, ValorProcurar = "300" });

  

            TimeSpan tempoDinamico, TempoTradicional;

            int NumeroVezesExecucao = 10;

            for (int i = 0; i < NumeroVezesExecucao; i++)

            {

                tempo.Reset();

                tempo.Start();

                IList clientesFiltrados = clientes.AsQueryable().Filtrar(filtros).ToList();

                tempo.Stop();

                tempoDinamico = tempo.Elapsed;

                Console.WriteLine("Filtro Dinâmico    {0}", tempo.Elapsed);

                

                

                tempo.Start();

                IList clientesLambda = clientes.Where(p => p.NomeCliente.Contains("Cli") && p.Idade >= 300).ToList();

                tempo.Stop();

                TempoTradicional = tempo.Elapsed;

                Console.WriteLine("Filtro tradicional {0}", tempo.Elapsed);

  

                Console.WriteLine("Comparativo (Dinamico - Tradicional): {0}", tempoDinamico - TempoTradicional);

  

  

            }

  

            Console.ReadKey();

        }

    }

Espero que tenham gostado.

Baixem a Solução

9cb37de5-d8fd-491c-94a5-9df24e33e611|1|5.0

Tags: Expressões lambdas, Métodos de extensão, Expression Categorias: ASP.NET | C# | Lambda | LINQ

E-mail | Permalink | Comentários (1) |

s	t	q	q	s	s	d
30	31	1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	1	2	3	4
5	6	7	8	9	10	11

s	t	q	q	s	s	d
30	31	1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	1	2	3	4
5	6	7	8	9	10	11

Post por mês

Utilizando Checkbox em uma TreeView para selecionar e excluir nodes com LinqToSql

Como criar Expressões lambdas dinâmicamente.

Classe que contem a estrutura que utilizada para filtrar a entidade.

s	t	q	q	s	s	d
30	31	1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	1	2	3	4
5	6	7	8	9	10	11