Apaixonado por tecnologia. Trabalho com tecnologia desde 2003.

Saiba mais sobre minha vida profissional aqui .

Fale comigo.
Siga-me no Twitter
Ultimos comentários
Calendário de Posts
<<  julho 2017  >>
stqqssd
262728293012
3456789
10111213141516
17181920212223
24252627282930
31123456

Siga o @DicaDoNerd no Twitter e acompanhe as novidades


Eu utilizo o BlogEngine 1.6 e cada vez mais gosto dele, tanto pela facilidade de administração, personalização e principalmente a facilidade da publicação de artigos.

Estou utilizando o Word para publicar este artigo e sem esforço nenhum é assumido todo o estilo (css) que utilizo em meu site.

Conto com diversos benefícios do Word, embora a maioria das vezes eu utilize o Windows Liver Writer para escrever meus Posts, pois, consigo customizar facilmente os plug-ins para inserção de formatação de códigos, vídeos, imagens e etc.

Vou mostrar de forma não muito abrangente como publicar um post utilizando o Microsoft Word.

Abra o Word e selecione a opção “Novo” e depois “Nova Postagem no blog”, como informado na figura abaixo.

 Blog

clip_image002

 

 

 O Word solicitará a configuração do seu blog. O Word poderá conectar-se a vários providers, como o Live Spaces e Blogger por exemplo.

Você deverá selecionar o seu provider do B log. Como utilizo o BlogEngine, selecionei Outros.

clip_image004

 

 

 

No url , informe sua url seguida metaweblog.axd.

Coloque seu usuário e senha. Configure as opções de imagem (se fará o Upload para seu repositório de imagens ou para o SkyDrive. Para isso será necessário vincular sua conta do Hotmail.

Confirme no botão Ok, você receberá uma mensagem de confirmação e pronto já pode começar a postar no seu blog.

Você tem alguma sugestão? Entre em contato, assim, faremos este blog evoluir juntos!

Abraços e até a próxima.

     No Microsoft word, existe um problema quando você insere as legendas, marcadores e índices no documento, sempre que você coloca um novo ítem, é necessário selecionar os itens e clicar com botão direito e atualizar campo.

     Há uma forma mais simples de realizar esta operação atualizando os Range via VBA.

     Segue o exemplo:

   1: Sub AtualizarRanges() 
   2:      
   3:     Dim Ranges
   4:      
   5:     Set Ranges = Selection.Range 
   6:      
   7:     Selection.WholeStory 
   8:     Selection.Fields.Update 
   9:      
  10:     Ranges.Select 
  11:      
  12: End Sub

      Simples assim.

 

      Minato 8-)

          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>
  10:         public static IQueryable<TEntidade> Filtrar<TEntidade>(this IQueryable<TEntidade> entidadeOrigem, List<FiltroEntidade> filtros) where TEntidade : class
  11:         {
  12:             //Pega apenas filtros que ainda não foram aplicados, em caso da lista de filtros ser reutilizada
  13:             List<FiltroEntidade> filtrosAplicar = filtros.Where(p => p.FiltroAplicado == false).ToList();
  14:  
  15:             foreach (FiltroEntidade item in filtrosAplicar)
  16:             {
  17:                 entidadeOrigem = entidadeOrigem.Filtrar(item.NomePropriedade, item.tipoCompracao, item.ValorProcurar);
  18:                 item.FiltroAplicado = true;
  19:             }
  20:  
  21:             return entidadeOrigem;
  22:  
  23:         }
  24:  
  25:  
  26:         /// <summary>
  27:         /// Aplica um unico Filtro
  28:         /// </summary>
  29:         /// <typeparam name="TEntidade">Instancia da Entidade</typeparam>
  30:         /// <param name="entidadeOrigem">objeto que será filtrada</param>
  31:         /// <param name="NomePropriedade">Nome da propriedade</param>
  32:         /// <param name="TipoComparacao">Tipo Comparação</param>
  33:         /// <param name="ValorProcurar">Valor que será filtrado filtrar</param>
  34:         /// <returns>Retorna um objeto com a lista das entidades filtradas</returns>
  35:         public static IQueryable<TEntidade> Filtrar<TEntidade>(this IQueryable<TEntidade> entidadeOrigem, string NomePropriedade, Minato.Entidades.FiltroEntidade.TipoComparacao TipoComparacao, string ValorProcurar)
  36:                                                                 where TEntidade : class
  37:         {
  38:  
  39:             Type type = typeof(TEntidade);
  40:             ConstantExpression procurarFiltro = Expression.Constant(ValorProcurar);
  41:             ParameterExpression parametro = Expression.Parameter(type, "p");
  42:             PropertyInfo propriedade = type.GetProperty(NomePropriedade);
  43:             Expression acesssoPropriedade = Expression.MakeMemberAccess(parametro, propriedade);
  44:  
  45:             Type tipo = Nullable.GetUnderlyingType(propriedade.PropertyType);
  46:  
  47:             if (tipo != null)
  48:             {
  49:                 PropertyInfo valProp = typeof(Nullable<>).MakeGenericType(tipo).GetProperty("Value");
  50:                 acesssoPropriedade = Expression.MakeMemberAccess(acesssoPropriedade, valProp);
  51:             }
  52:             else
  53:             {
  54:                 tipo = acesssoPropriedade.Type;
  55:             }
  56:             if (tipo == typeof(Guid))
  57:             {
  58:                 Guid guid = new Guid(ValorProcurar);
  59:                 procurarFiltro = Expression.Constant(guid);
  60:             }
  61:             else
  62:             {
  63:                 procurarFiltro = Expression.Constant(Convert.ChangeType(ValorProcurar, tipo));
  64:             }
  65:  
  66:  
  67:             MethodInfo startsWith = typeof(string).GetMethod("StartsWith", new Type[] { typeof(string) });
  68:             MethodInfo endsWith = typeof(string).GetMethod("EndsWith", new Type[] { typeof(string) });
  69:             MethodInfo contains = typeof(string).GetMethod("Contains", new Type[] { typeof(string) });
  70:             Expression operacaoRealizar = null;
  71:             switch (TipoComparacao)
  72:             {
  73:                 default:
  74:                 case FiltroEntidade.TipoComparacao.Igual:
  75:                     operacaoRealizar = Expression.Equal(acesssoPropriedade, procurarFiltro);
  76:                     break;
  77:                 case FiltroEntidade.TipoComparacao.Diferente:
  78:                     operacaoRealizar = Expression.NotEqual(acesssoPropriedade, procurarFiltro);
  79:                     break;
  80:  
  81:                 case FiltroEntidade.TipoComparacao.Maior:
  82:                     operacaoRealizar = Expression.GreaterThan(acesssoPropriedade, procurarFiltro);
  83:                     break;
  84:                 case FiltroEntidade.TipoComparacao.MaiorIgual:
  85:                     operacaoRealizar = Expression.GreaterThanOrEqual(acesssoPropriedade, procurarFiltro);
  86:                     break;
  87:  
  88:                 case FiltroEntidade.TipoComparacao.Contem:
  89:                     operacaoRealizar = Expression.Call(acesssoPropriedade, contains, procurarFiltro);
  90:                     break;
  91:  
  92:             }
  93:             var ExpressaoWhere = Expression.Lambda(operacaoRealizar, parametro);
  94:             var ResultadoDaExpressao = Expression.Call(typeof(Queryable), "Where", new Type[] { entidadeOrigem.ElementType }, entidadeOrigem.Expression, ExpressaoWhere);
  95:  
  96:             return entidadeOrigem.Provider.CreateQuery<TEntidade>(ResultadoDaExpressao);
  97:         }
  98:     }

Resultado:

Where

 

 

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

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:  
  10:             Stopwatch tempo = new Stopwatch();
  11:  
  12:             tempo.Start();
  13:  
  14:             for (int i = 0; i < QtdadeRegistrosAdicionar; i++)
  15:             {
  16:                 clientes.Add(new ClienteEntidade { NomeCliente = "Cliente" + i, Endereco = "Endereço" + i, Idade = i, Salario = rnd.Next(1000, 10000) });
  17:  
  18:             }
  19:             tempo.Stop();
  20:             Console.WriteLine("Tempo gasto para preencher {0} registros: {1}", QtdadeRegistrosAdicionar, tempo.Elapsed);
  21:             List<FiltroEntidade> filtros = new List<FiltroEntidade>();
  22:             filtros.Add(new FiltroEntidade { NomePropriedade = "NomeCliente", tipoCompracao = FiltroEntidade.TipoComparacao.Contem, ValorProcurar = "Cli" });
  23:             filtros.Add(new FiltroEntidade { NomePropriedade = "Idade", tipoCompracao = FiltroEntidade.TipoComparacao.MaiorIgual, ValorProcurar = "300" });
  24:  
  25:             TimeSpan tempoDinamico, TempoTradicional;
  26:             int NumeroVezesExecucao = 10;
  27:             for (int i = 0; i < NumeroVezesExecucao; i++)
  28:             {
  29:                 tempo.Reset();
  30:                 tempo.Start();
  31:                 IList clientesFiltrados = clientes.AsQueryable().Filtrar(filtros).ToList();
  32:                 tempo.Stop();
  33:                 tempoDinamico = tempo.Elapsed;
  34:                 Console.WriteLine("Filtro Dinâmico    {0}", tempo.Elapsed);
  35:                 
  36:                 
  37:                 tempo.Start();
  38:                 IList clientesLambda = clientes.Where(p => p.NomeCliente.Contains("Cli") && p.Idade >= 300).ToList();
  39:                 tempo.Stop();
  40:                 TempoTradicional = tempo.Elapsed;
  41:                 Console.WriteLine("Filtro tradicional {0}", tempo.Elapsed);
  42:  
  43:                 Console.WriteLine("Comparativo (Dinamico - Tradicional): {0}", tempoDinamico - TempoTradicional);
  44:  
  45:  
  46:             }
  47:  
  48:             Console.ReadKey();
  49:         }
  50:     }

 

Espero que tenham gostado.

Baixem a Solução

Minato , Criado em 25/04/2010, 11:35

        Para abrir meu primeiro post, vou falar um pouco sobre o blog engine.

        Há tempos venho procurando um blog que tenha uma customização fácil e que toda as “firulas” fossem prontas, como ultimos Post’s, administração, usuários e etc.

        Então conheci o BlogEngine uma ferramenta muito prática, simples e de fácil manutenção. Uma das vantagens é a criação de temas. Basta criar um diretório com o tema. Óbvio que há regras que devem ser seguidas, mas, nada muito complicado. Você pode utilizar também o Mega-Pack de themas

        Você pode utiliza-lo com MySQL, SQLLite, SQLServer ou até mesmo através de XML. A implementação é muito simples. Dentro do diretório BlogEngine.Web há uma pasta chamada Setup. Dentro delas há os scripts para criação ou upgrade de versões, basta escolher o banco desejado e pronto, estruturas criadas.

        Após isso, no arquivo web.Config da sua aplicação é necessário alterar a String de Conexão.

<add name="BlogEngine" connectionString="Data Source=SeuServidor;Initial Catalog=BaseDados;Persist Security Info=True;User ID=usuario;Password=senha;" providerName="System.Data.SqlClient"/>

        É necessário tambem alterar o provider:

<blogProvider defaultProvider="DbBlogProvider">

 

Pronto, agora é só fuçar.

Minato , Criado em 17/04/2010, 00:36

Todos sabem que o Linq veio para facilitar a vida do desenvolvedor, então, vamos utiliza-lo para ler os feeds/rss.

De uma maneira simples temos os o Titulo, descricao e itens (lista), que podem ser acessados simples assim.

   1: XDocument xmlFeed = XDocument.Load(strUrl);
   2:                 var query = from feed in xmlFeed.Descendants("channel")
   3:                             select new
   4:                             {
   5:                                 Titulo = feed.Element("title").Value,
   6:                                 Descricao = feed.Element("description").Value,
   7:                                 Link = feed.Element("link").Value,
   8:                                 Itens = (from feedItens in feed.Descendants("item")
   9:                                          select new
  10:                                          {
  11:                                              Noticia = feedItens.Element("title").Value,
  12:                                              Link = feedItens.Element("link").Value,
  13:                                              Descricao = feedItens.Element("description").Value
  14:                                          }).ToList()
  15:                             };
  16:                 var rss = query.Single();
  17:  
  18:                 IList ListaDeItens = rss.Itens.ToList();

 

Espero ter ajudado

 

Minato 8-)

Minato , Criado em 01/04/2010, 23:58

Bom, muitas vezes precisamos criar cookies. Isso pode ser feito de uma maneira muito simples utilizando a classe HttpCookie.

   1: // Gravo um cookie 'Cadastro'
   2:  
   3: HttpCookie Cookies = new HttpCookie("Cadastro"); 
   4:  
   5: Cookies.Values.Add("Nome", "Alexandre"); //Coloco o valor do Nome
   6:  
   7: Cookies.Values.Add("Sobrenome", "Minato"); //Coloco o valor do SobreNome
   8:  
   9: Cookies.Expires = new DateTime(2010, 12, 1); // Data que expira o cookie 
  10:  
  11: (Utilize: Cookies.Expires.AddDays(1)para adicionar dias à um cookie existente
  12:  
  13: // Grava o cookie no client
  14:  
  15: Response.AppendCookie(Cookies);
  16:  
  17:  
  18:  
  19: HttpCookie retorno; // Variavel do Tipo HttpCookie, que receberá o Cookie
  20:  
  21: retorno = Request.Cookies["Cadastro"]; // Retorno o valo do cookie
  22:  
  23: string strNome = retorno.Values["Nome"].ToString(); // Encontro o nome
  24:  
  25: string strSobrenome = retorno.Values["Sobrenome"].ToString(); // Encontro o Sobrenome

 

Espero ter ajudado,

 

Minato 8-)

 
teste