A .Net Talk

ASP.NET MVC: EVITE usar HTML Helpers em campos Hidden

2015-07-23T00:00:00.001-03:00

Não sou a favor da cópia/plágio de postagens, porém, esbarrei em um problema recentemente que me custou um bom tempo de pesquisa em busca de uma "resposta" ou justificativa para tal. Em uma aplicação MVC 4.0, uma view de edição possuía dois formulários (duas tags "<form>").

O ID da model utilizada pela view era armazenado em hiddens criadas a partir do HTML Helper em ambos os formulários. Notei que após o cadastro da entidade, no retorno do POST da Controller, a model trazia o campo ID preenchido, porém o campo hidden na tela não era preenchido, fazendo com o valor do mesmo ficasse vazio.

Após horas de pesquisa, encontrei em um blog a sugestão de NUNCA utilizar Html Herlpers na criação de campos hidden. Aparentemente não há uma explicação oficial sobre o porque isto ocorre, mas acho interessante disseminar este ~~pequeno~~ inconveniente. Para mais detalhes, acessar o link abaixo:

Fonte: ShivaGaadu

Customização de arquivos BAT : Crie arquivos BAT dinâmicamente

2015-07-21T00:00:00.000-03:00

Um arquivo BAT é composto por instruções a serem executadas sequencialmente. Sua execução geralmente é agendadas e costuma efetuar tarefas em lote.

Na maioria dos casos, as tarefas são específicas e dificilmente precisam ser alteradas. Porém, em alguns momentos, é necessário que o arquivo obtenha informações dinâmicas de outras fontes de dados.

E é neste momento que a plataforma .NET se demonstra muito útil! Linguagens de outras plataformas, como Java por exemplo, também são capazes de realizar esta tarefa, porém neste post, utilizaremos a linguagem C# da plataforma .NET.

Embora o exemplo a seguir seja um tanto quanto simplista, ele permite ter uma ideia do potencial de arquivos bat.

No exemplo a seguir criaremos uma classe dinamicamente e geraremos um arquivo bat responsável pela compilação da mesma, transformando esta em uma dll. Para tal, criaremos um projeto do tipo Console:

A codificação da classe program será a seguinte:

string className = "testeBuild";
string folderPath = @"c:\temp\";
StringBuilder sBuilderClasse = new StringBuilder();
sBuilderClasse.AppendLine("using System;");
sBuilderClasse.AppendLine("namespace CompileViaBatDemo");
sBuilderClasse.AppendLine("{");
sBuilderClasse.AppendLine("     public class " + className);
sBuilderClasse.AppendLine("     {");
sBuilderClasse.AppendLine("         public string Hello { ");
sBuilderClasse.AppendLine("             get {              ");
sBuilderClasse.AppendLine("                 return \"Hi\";");
sBuilderClasse.AppendLine("             } ");
sBuilderClasse.AppendLine("         }");
sBuilderClasse.AppendLine("     }");
sBuilderClasse.AppendLine("}");
File.WriteAllText(string.Format("{0}{1}.cs", folderPath, className), sBuilderClasse.ToString(), Encoding.UTF8);
StringBuilder sBuilderBat = new StringBuilder();
sBuilderBat.AppendLine(@"C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe /target:library " + string.Format("{0}{1}.cs", folderPath, className));
sBuilderBat.AppendLine(@"del " + string.Format("{0}{1}.cs", folderPath, className));
sBuilderBat.AppendLine(@"del " + string.Format("{0}{1}.bat", folderPath, className));
sBuilderBat.AppendLine(@"pause");
File.WriteAllText(string.Format("{0}{1}.bat", folderPath, className), sBuilderBat.ToString(), Encoding.ASCII);

Ao executar este código, será gerado no diretório "c:\temp" nossa classe e o arquivo bat.

Quando o arquivo bat criado é executado, o mesmo gera a dll a partir da compilação da classe, deleta a classe e em seguida a si mesmo.

Ao Importar a dll criada no Visual Studio, é possível consumir sua classe.

JavaScript e OO: Adicionando métodos ao objeto

2015-07-16T00:00:00.000-03:00

Na post anterior vimos como criar objetos e manipular suas propriedades através do JavaScript. Porém, "nem só de propriedades viverá um objeto"! Um objeto pode possuir também um ou mais métodos/funções. Por exemplo:

Pensemos num objeto "Carro". Um carro geralmente possui as seguintes características:

Ano
Cor
Fabricante
Modelo

Traduzindo estas informações nas propriedades de nosso objeto no JavaScript, teríamos algo mais ou menos assim:

var carro = {
    ano: 0
   ,cor: ""
   ,fabricante: ""
   ,modelo: ""
};

Porém, todo carro que se preze realiza algumas "ações básicas" como:

Desligar
Ligar
Buzinar

No JavaScript, a sintaxe básica para a criação de uma função ou método é:

function ["nome da função"]([parâmetros]) {
 [Corpo da função]
}

A definição de uma função em um objeto JavaScript não é muito diferente. Abaixo demonstro como seria a implementação das funções necessárias para nosso objeto (desligar, ligar, buzinar):

var carro = {
    ano: 0
   ,cor: ""
   ,fabricante: ""
   ,modelo: ""
   ,desligar: function(){
       console.log("O carro foi desligado");
   }
   ,ligar: function(){
       console.log("O carro foi ligado");   
   }
   ,buzinar: function(){
       console.log("O carro buzinou");   
   }
}

Após a criação do objeto, para invocar os métodos de nosso objeto, basta utilizar a sintaxe "[objeto].[método]". Ao executar o comando "carro.ligar()", será exibido no console do navegador a mensagem "O carro foi ligado".

SQL Server: Auditando alterações no Banco de Dados

2015-07-14T00:00:00.000-03:00

Após finalizar os ajustes em um sistema, é chegada a hora de gerar um pacote para publicação. Geralmente o código fonte é armazenado em um controlador de versão, o que facilita na hora de "lembrar" e separar os arquivos que sofreram alterações ao longo do processo de desenvolvimento.

No caso do banco de dados, caso o desenvolvedor não mantenha um controle dos scripts das alterações realizadas no banco de dados, a chance de uma procedure, tabela ou função a ser alterada em produção ser esquecida é muito grande.

Dado este inconveniente, algumas empresas distribuem/comercializam softwares e plugins responsáveis por auditar a base. Ou seja, todas as alterações realizadas nos objetos do banco de dados são registrados e posteriormente é possível obter um script assertivo das mudanças a serem realizadas no ambiente de produção.

Porém, na ausência de um plugin ou software para auditoria das alterações realizadas em base, é possível se guiar pelo objeto sys.all_objects.

Ao realizar a consulta abaixo, o SQL Server traz todos os objetos que foram criados/alterados no banco de dados em relação ao período utilizado no filtro da consulta.

SELECT
    name,
    create_date,
    modify_date
FROM sys.all_objects
WHERE create_date > '[[Data]'
or modify_date > '[Data]'

ASP.NET MVC & Chosen - Parte 1

2015-07-09T00:00:00.002-03:00

Conforme prometido, hoje irei mostrar alguns exemplos práticos do uso do plugin Chosen. Neste post irei demonstrar o passo a passo de como utilizar este plugin no Visual Studio utilizando o template ASP.NET MVC. Apenas lembrando que este plugin pode ser utilizado normalmente com HTML e JavaScript/JQuery.

Primeiramente precisamos criar um projeto ASP.NET MVC no Visual Studio:

Feito isso, iremos acrescentar os arquivos CSS e JavaScript que compõe a API nas pastas Content e Scripts:

Criaremos uma Controller responsável por gerenciar as requisições de nossa página de exemplo:

Nossa controller ficará assim:

using ChosenExample.Web.Models;
using System.Web.Mvc;

namespace ChosenExample.Web.Controllers
{
    public class ChosenExampleController : Controller
    {
        public ActionResult Index()
        {
            return View(new ListHelper());
        }
    }
}

A action Index utilizada na Controller acima, retorna uma View passando nosso objeto Model (ListHelper):

using System.Collections.Generic;

namespace ChosenExample.Web.Models
{
    public class ListHelper
    {
        public int CdAnimal { get; set; }
        public int CdProduto { get; set; }
        public List Animais { get; set; }
        public List Produtos { get; set; }

        public ListHelper()
        {
            FillAnimais();
            FillProdutos();
        }

        private void FillProdutos()
        {
            Produtos = new List();
            Produtos.Add(new Produto() { IdProduto = 1, DsProduto = "Computador" });
            Produtos.Add(new Produto() { IdProduto = 2, DsProduto = "TV" });
            Produtos.Add(new Produto() { IdProduto = 3, DsProduto = "Video Game" });
            Produtos.Add(new Produto() { IdProduto = 4, DsProduto = "DVD Player" });
            Produtos.Add(new Produto() { IdProduto = 5, DsProduto = "Smart Phone" });
            Produtos.Add(new Produto() { IdProduto = 6, DsProduto = "iPhone" });
            Produtos.Add(new Produto() { IdProduto = 7, DsProduto = "Laptop" });
            Produtos.Add(new Produto() { IdProduto = 8, DsProduto = "Janela" });
            Produtos.Add(new Produto() { IdProduto = 9, DsProduto = "Mesa" });
            Produtos.Add(new Produto() { IdProduto = 10, DsProduto = "Lâmpada" });
            Produtos.Add(new Produto() { IdProduto = 11, DsProduto = "Teclado" });
        }

        private void FillAnimais()
        {
            Animais = new List();
            Animais.Add(new Animal() { IdAnimal = 1, DsAnimal = "Cachorro" });
            Animais.Add(new Animal() { IdAnimal = 2, DsAnimal = "Gato" });
            Animais.Add(new Animal() { IdAnimal = 3, DsAnimal = "Pássaro" });
            Animais.Add(new Animal() { IdAnimal = 4, DsAnimal = "Sapo" });
            Animais.Add(new Animal() { IdAnimal = 5, DsAnimal = "Peixe" });
            Animais.Add(new Animal() { IdAnimal = 6, DsAnimal = "Lagarto" });
            Animais.Add(new Animal() { IdAnimal = 7, DsAnimal = "Urso" });
            Animais.Add(new Animal() { IdAnimal = 8, DsAnimal = "Cavalo" });
            Animais.Add(new Animal() { IdAnimal = 9, DsAnimal = "Girafa" });
            Animais.Add(new Animal() { IdAnimal = 10, DsAnimal = "Elefante" });
            Animais.Add(new Animal() { IdAnimal = 11, DsAnimal = "Leão" });
        }
    }
}

As classes abaixo serão utilizadas na tipagem das listas de nossa Model

    public class Produto
    {
        public int IdProduto { get; set; }
        public string DsProduto { get; set; }
    }

    public class Animal
    {
        public int IdAnimal { get; set; }
        public string DsAnimal { get; set; }
    }

Nossa Index (View) conterá dois dropdownlists a serem utilizados em nosso exemplo e um botão a ser utilizado no próximo post.

@model ChosenExample.Web.Models.ListHelper
@{
    ViewBag.Title = "Exemplos";
}



Exemplos Chosen
@Html.DropDownListFor(t => t.CdAnimal, new SelectList(Model.Animais, "IdAnimal", "DsAnimal"), "Selecione", new { multiple = "", @class = "chzn-select search-dropdown chosen-select", data_placeholder = "Selecione", style="width:400px" })
@Html.DropDownListFor(t => t.CdProduto, new SelectList(Model.Produtos, "IdProduto", "DsProduto"), "Selecione", new { @class = "chzn-select search-dropdown chosen-select", data_placeholder = "Selecione", style = "width:400px" })
<input type="submit" name="btnEnviar" value="Enviar" />

Antes de seguir em frente, existem alguns pontos interessantes a serem observados e entendidos:

O atributo multiple = "" indica que o controle será múltipla escolha, tornando possível a seleção de mais de um valor.
A classe search-dropdown habilita a busca no campo

Ao executar a aplicação, o resultado é o seguinte:

Para inicializar o plugin, basta inserir este trecho de código na página dentro da tag script:

$(document).ready(function(){
    $(".chosen-select").chosen()
});

E pronto! Bem diferente da aparência e comportamento padrão não?

Em uma próxima postagem irei abordar o tratamento e manipulação deste campo na Controller.

JavaScript e OO: Criando objetos

2015-07-07T00:00:00.002-03:00

Embora seja uma linguagem fracamente tipada, com o passar do tempo o JavaScript vem ganhando cada vez mais melhorias e funcionalidades. A tipagem desta linguagem facilita a manipulação de suas variáveis e objetos, visto que estes podem ser criados dinamicamente em tempo de execução.

Na maioria das linguagens orientadas a objeto, como Java/C#/C++, o processo de criação de objetos consiste em definir, criar e instanciar uma classe.

Com o JavaScript não é muito diferente! A vantagem deve-se ao fato de o JavaScript não precisar ser compilado antes da interpretação do script.

Caso fôssemos criar um objeto "Pessoa", utilizando a linguagem C# por exemplo, o código fonte seria algo mais ou menos assim:

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

No caso do JavaScript, a implementação desta classe poderia ser feita (de modo simplista), da seguinte maneira:

var pessoa = { 
    Nome: ""
  , Idade: 0
};

Devido ao JavaScript ser fracamente tipado, os campos/propriedades da minha classe "pessoa", são inicializados para que os mesmos "assumam" um tipo. No caso da classe C#, os tipos são pré definidos no momento da criação da classe. Para acessar um atributo de minha classe "Pessoa", é necessário primeiramente instanciar a classe e efetuar a chamada através do objeto "p" criado:

Pessoa p = new Pessoa();
//Acesso e imprimo o atributo nome do meu objeto "p"
Console.WriteLine(p.Nome);

Já para o JavaScript, existem outras maneiras de se acessar as propriedades de objetos, chamadas também de notações. Abaixo demonstro duas delas:

1 - Sintaxe de ponto (dot notation):

A propriedade é acessada assim como no C#, objeto.propriedade:

pessoa.nome = "Bruno";

2 - Sintaxe de colchetes (bracket notation):

O acesso a propriedade do objeto lembra o acesso a valores em matrizes, objeto["propriedade"]:

pessoa["nome"] = "Bruno";

Outro ponto interessante que faz do JavaScript uma linguagem poderosa, é o fato de se poder criar propriedades para objetos existentes em tempo de execução. Nosso objeto "pessoa" até o momento possuia duas propriedades: "nome" e "idade". Caso seja necessário acrescentar uma nova propriedade a este objeto, como por exemplo "peso", basta "acessar a nova propriedade":

pessoa.peso = 70;

Feito isso, o objeto "pessoa", passa a ter também a propriedade peso. Incrível, não? Para quem desejar se aprofundar mais, encontrei um link interessante bem aqui

Common Language Run-time Integration: crie e utilize métodos .NET em procedures

2015-07-02T00:00:00.000-03:00

No desenvolvimento de uma aplicação que realize acesso a base de dados, geralmente a comunicação é unilateral. Ou seja, a aplicação conhece e realiza acessos ao banco de dados, enquanto que o banco de dados desconhece a aplicação.

Dependendo do nível de complexidade da aplicação, visando evitar a repetição de código, parte da lógica da aplicação (regras de negócio) pode ser encapsulada, geralmente em uma DLL.

Quando se conhece o negócio, é possível a manipulação e consulta dos objetos do banco de dados através de procedures e comandos SQL. Porém, quando o acesso a DLL encontra-se ofuscado ou criptografado, fica a questão: e se fosse possível utilizar um método de uma DLL em uma procedure?

Por mais exótica que aparente ser (e é) esta solução, sim, é possível consumir uma DLL e realizar a chamada de seus métodos a partir de uma procedure ou função no banco de dados. Para realizar este acesso, basta seguir os seguintes passos:

Primeiramente é necessário configurar o banco de dados habilitando o CLR e ativar o TRUSTWORTHY:

sp_configure 'clr enable', 1

RECONFIGURE

ALTER DATABASE TreinamentoNET

SET TRUSTWORTHY ON

1 - Abra o Visual Studio e clique em: File > New > Project ...> Visual C# > Windows > Class Library

2 - No menu "Projeto", selecione a opção "Add New Item" e em seguida "Class".

3 - Segue abaixo a classe utilizada neste exemplo:

using System;
using Microsoft.SqlServer.Server;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using System.Data;
namespace ProcDotNet.Classes
{
    public class ProcedureDotNET
    {
        [SqlProcedure()]
        public static void InsertProduct(SqlString nome, SqlString observacao)
        {
            using (SqlConnection conn = new SqlConnection(@"Data Source = localhost\SQL; Initial Catalog = TreinamentoNET; User ID = sa ; Password = P@$$w0rd"))
            {
                SqlCommand objCommand = new SqlCommand();
                objCommand.Parameters.AddWithValue("@nome", nome);
                objCommand.Parameters.AddWithValue("@observacao", observacao);
                objCommand.CommandText = "INSERT INTO tbProduto (nome, observacao) VALUES (@nome, @observacao)";
                objCommand.Connection = conn;
                conn.Open();
                objCommand.ExecuteNonQuery();
                conn.Close();
            }
        }
    }
}

Na classe acima, o método InsertProduct recebe dois parâmetros e realiza o insert em tabela. É importante lembrar que o projeto class library deve utilizar o framework .NET correspondente a versão suportada pelo SQL Server utilizado. No caso do SQL Server 2008 por exemplo, a versão do framework suportada é a 2.0

Após a compilação do projeto, é necessário registrar a DLL no banco de dados. Para isso, basta executar os scripts abaixo:

CREATE ASSEMBLY ProcedureDotNET

AUTHORIZATION dbo FROM 'C:\Users\bruno\Desktop\ProcDotNet\ProcDotNet.Classes\bin\Debug\ProcDotNet.Classes.dll'

WITH PERMISSION_SET = UNSAFE

Após a execução do script acima, o SQL Server cria um assembly no banco de dados. A partir deste assembly é possível efetuar as chamadas aos métodos da DLL a partir de procedures e funções.
No exemplo abaixo, uma procedure é criada para receber os dois parâmetros requisitados pelo método e invocá-lo:

CREATE PROCEDURE sp_insert_product

@nome nvarchar(50),

@observacao nvarchar(50)

AS EXTERNAL NAME ProcedureDotNET.[ProcDotNet.Classes.ProcedureDotNET].InsertProduct

Feito isso, é chegada a hora de testar nossa criação. Ao executar a procedure enviando os parâmetros, as informações são persistidas na base de dados:

sp_insert_product 'Carro', '4 portas'

Ao realizar uma consulta na tabela, é possível verificar que tudo funciona perfeitamente e que os dados enviados para a procedure foram persistidos:

select * from tbProduto

JavaScript: alert ou console.log?

2015-06-30T00:00:00.000-03:00

Lembro me quando comecei a desenvolver sistemas para web. Um novo universo, uma nova realidade. Não precisa compilar? Era tudo novidade! Porém, com o passar do tempo e consequentemente com o aumento da complexidade dos scripts desenvolvidos, surgiu o questionamento: Como eu "debugo" o meu script (JavaScript)?

A primeira opção a mim apresentada foi o método nativo do JavaScript "alert" e em primeira instância, pensei ter descoberto "O Santo Graal" para depuração de scripts.

No entanto, notei que o método "alert", não era o suficiente para exibir estruturas mais complexas como o exemplo abaixo:

var produto = { Nome: 'Computer',
                  PrecoUnidade: 1110.25,
                  QuantidadeEstoque: 2
              };

Caso eu passe como parâmetro o objeto "produto", o navegador me exibirá o seguinte resultado (pouco útil):

alert(produto);

Ou seja, para objetos, o método alert() não se demonstra tão útil. E neste momento há quem apele para o uso de "alerts" personalizados para inspecionar o objeto criado:

alert("Nome: '"+produto.Nome+"', Preço: $"+produto.PrecoUnidade);

Neste ponto, podemos chegar a conclusão de que dependendo da complexidade do objeto criado no JavaScript, o uso de alerts para "depuração" é inviável. E é neste momento em que a tecla "F12" do teclado ganha sentido.

Na maioria dos navegadores modernos como o Chrome ou Firefox e as mais recentes versões do IE (a partir do 9), ao pressionar a tecla F12, o navegador exibe uma janela chamada comumente de "Developer Tools (Ferramentas de Desenvolvimento)".

Note que que entre as ferramentas disponibilizadas, existe o "Console", em minha opinião, a ferramenta mais poderosa dos browsers modernos.

A princípio esta ferramenta aparentemente simples não demonstra grande importância, porém ela permite a criação e manipulação de todos os objetos existentes em uma página web em tempo de execução.

Dois fatores fazem que o Console supere de longe o método alert:

1 - Ele é discreto: não ocorre, a menos que o método alert seja invocado, a exibição de janelas no navegador.

2 - Ele é eficiente: além de não haver a necessidade de haver um arquivo JavaScript, ele possui intelisense (dependendo do navegador).

Veja como ficaria nosso exemplo anterior utilizando o método console.log([texto]) no Console do navegador:

var produto = { Nome: 'Computer',
                  PrecoUnidade: 1110.25,
                  QuantidadeEstoque: 2
              };

console.log("Nome: '"+produto.Nome+"', Preço: $"+produto.PrecoUnidade);

produto

Resultado:

Ou seja, tudo ocorre dentro do console sem a necessidade de clicar em botões "OK" ou "Cancelar" como no caso do método "alert()"

Para consultar outros métodos de output, clique aqui.

JavaScript: 3 maneiras de se utilizar

2015-06-25T04:00:00.000-03:00

Em certos momentos do desenvolvimento nos deparamos com certos dilemas como qual abordagem utilizar na codificação de modo a tentar se distanciar o mínimo possível das "Boas práticas de programação".

Quando o assunto é "Desenvolvimento Web", nos deparamos com um bombardeio de informações, arquiteturas, frameworks, exemplos, fóruns... Com o JavaScript não é diferente.

Existem "n" modos de se efetuar chamadas a funções JavaScript e neste artigo citarei as três mais utilizadas comentando suas vantagens ou desvantagens:

1 - Inline

Descrição: no exemplo abaixo, a chamada JavaScript é realizada dentro do evento "onload" da página.

Consideração: pior modo de utilizar.

Motivo: o script vinculado ao evento "onload" só será executado após o carregamento de todos os assets da página. Caso algum elemento da página possua dependência deste script, erros podem ocorrer. Dependendo de como o navegador interpretar o código abaixo, a função alert pode ser executada antes da renderização dos elementos contidos na tag body, impedindo o carregamento da página até que o usuário interaja com a mensagem.

<!DOCTYPE html>
<html>
<head>
    <title>Carregando o javascript</title>
</head>
<body onload="alert('inline');">
    <h1>Formas de carregamento</h1>
</body>
</html>

2 - Embed

Descrição: no exemplo abaixo, a chamada JavaScript é realizada enquanto a página é carregada

Consideração: as vezes é utilizado.

Motivo: não interrompe o carregamento da página, pois, o script só é carregado/interpretado após o carregamento dos elementos da página e pode ser utilizado quando o conteúdo da página é dinâmico ou condicional.

Exemplo: exibir ou não informações na página ou aplicar alguma regra de negócio sobre campos/elementos de um formulário.

<!DOCTYPE html>
<html>
<head>
    <title>Carregando o javascript</title>
</head>
<body>
    <h1>Formas de carregamento</h1>
    <script type="text/javascript">
        alert('embed');
    </script>
</body>
</html>

3 - External

Descrição: no exemplo abaixo, a chamada JavaScript é realizada a partir de um arquivo externo.

Consideração: melhor maneira.

Motivo: além da vantagem mencionada no item 2, deixa o HTML da página menos poluído, já que toda a codificação JavaScript fica em um arquivo externo.

<!DOCTYPE html>
<html>
<head>
    <title>Carregando o javascript</title>
</head>
<body>
    <h1>Formas de carregamento</h1>
    <script type="text/javascript" src="externalFile.js"></script>
</body>
</html>

externalFile.js

alert('external');

Vale ressaltar que cada navegador possui sua própria engine e efetua o parse do HTML e JavaScript de modo diferente, resultando consequentemente em comportamentos diferentes.

Chosen: dropdownlists multi-seleção

2015-06-23T00:00:00.000-03:00

Crie DropDownLists amigáveis, dinâmicos e multi-selecionáveis!

Encontre o que deseja através de busca viva!

No desenvolvimento Web, os controles Dropdown (tag select) acabam sendo vastamente utilizados, seja no preenchimento de um formulário ou no filtro de informações.

Selecione e remova itens de modo intuitivo!

Porém estes controles por padrão permitem a seleção de apenas uma informação, o que em alguns casos não atende aos requisitos do software desenvolvido. Existem na internet diversas empresas e frameworks pagos que possibilitam a customização e/ou adaptação destes controles para que os mesmos permitam a multi-seleção de informações. No entanto, nem sempre os resultados obtidos correspondem ao esperado e a experiência do usuário final é comprometida.

Em meio a minhas pesquisas para o desenvolvimento de uma aplicação ASP.NET MVC, encontrei o Chosen, um plugin jQuery responsável por permitir esta customização do controle @Html.DropDownList. O plugin conta com diversas opções de customização como: busca, agrupamento, multi-seleção, entre outros.

Os resultados do uso deste plugin são surpreendentes, visto que a customização do controle não apresentam alteração significativa na performance do mesmo quando aplicado sobre pequenas quantidades de dados (ex: 100 registros). Em breve publicarei alguns exemplos de uso prático deste plugin.

Para baixar o plugin, basta acessar este link!

Remover senha de planilha Excel

2015-06-17T21:52:00.000-03:00

Recentemente recebi a tarefa de dar manutenção em uma página responsável pelo upload de planilhas Excel. A funcionalidade básica (upload de arquivos) funcionava perfeitamente.

Entretanto, devido a confidencialidade das informações a serem armazenadas, a partir daquele momento, as mesmas seriam enviadas protegidas por senha. A aplicação anteriormente, utilizava o ClosedXML para efetuar a leitura e manipulação da planilha. Mas, esta API não possuía em sua documentação um método capaz de ler uma planilha criptografada (protegida por senha).
Na internet existem inúmeras APIs não gratuitas capazes de decriptar/remover senhas de planilhas, porém preferi recorrer a uma API "quase nativa" em ambientes corporativos. A solução foi apelar para o bom e velho Office.
Ao instalar o Office na máquina, o instalador registra as dlls do mesmo, podendo estas serem importadas e utilizadas no Visual Studio para automatizar operações em documentos.
Então, em busca de uma solução de menor impacto no algoritmo de importação já existente utilizado pela aplicação, codifiquei o seguinte protótipo, responsável por criar uma cópia do documento importado sem a senha, para que assim, o documento criptografado seja armazenado e o sistema efetue a leitura a partir de uma cópia descriptografada.

using Microsoft.Office.Interop.Excel;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace Excel.PasswordRemover
{
    class Program
    {
        static void Main(string[] args)
        {
            string password = "12345";

            //Crio as variáveis com os tipos usando pelo Excel
            Application excel = null;
            Workbooks workbooks = null;
            Workbook workbook = null;

            try
            {
                //Inicio uma instância do Excel
                excel = new Application();

                //Inicio os workbooks
                workbooks = excel.Workbooks;

                //Abro o arquivo passando a senha entre os parâmetros
                workbook = workbooks.Open(@"C:\Users\bruno\Desktop\plan1.xlsx"
                , Type.Missing, Type.Missing, Type.Missing, password, password, Type.Missing
                , Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing
                , Type.Missing);
                //Desprotejo o documento
                workbook.Unprotect(password);

                //Limpo as senhas
                workbook.Password = string.Empty;
                workbook.WritePassword = string.Empty;

                //Salvo uma "cópia" do arquivo sem a senha
                workbook.SaveAs(@"C:\Users\bruno\Desktop\plan1_no_password.xlsx"
                , Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing
                , Microsoft.Office.Interop.Excel.XlSaveAsAccessMode.xlShared, Type.Missing
                , Type.Missing, Type.Missing, Type.Missing, Type.Missing);

                workbook.Close();

                excel.Quit();
            }
            catch (Exception)
            {
                //TODO: Tratar Exceptions
            }
            finally
            {
                //Garanto a finalização da instância do Excel
                Marshal.ReleaseComObject(workbook);
                Marshal.ReleaseComObject(workbooks);
                Marshal.ReleaseComObject(excel);
            }
        }
    }
}

C# Windows Form Anti Flickadas

2012-10-21T09:23:00.002-02:00

O componente RichTextBox é um componente muito útil para entrada de texto passíveis de formatação. Com este componente, podemos criar analisadores gramaticais, editores de texto, entre outras finalidades. Através do método Select(), podemos selecionar o texto a ser formatado e aplicar uma diferenciação de fonte, cor e estilo. Porém em textos maiores, o ato de ficar sempre controlando o texto com o uso do método Select a cada entrada no controle, faz com que o mesmo dê algumas flickadas, comportando de maneira estranha a esperada.

Garimpando na internet, constatei em fórums, se tratar de uma funcionalidade não implementada no controle para controle do redesenho, o que faz com que ele haja desta maneira. Para contornar, encontrei mil e uma maneiras, porém a que me foi mais eficiente, foi a seguinte:

Importar a seguinte dll no código:

[DllImport("user32.dll")]
public static extern bool LockWindowUpdate(IntPtr hWndLock);

try
{
      LockWindowUpdate(richTextBox1.Handle);
      //As alterações desejadas vem aqui
}
finally
{
      LockWindowUpdate(IntPtr.Zero);
}

IE9: Modo compatibilidade

2012-10-18T18:31:00.002-03:00

Uma das premissas a ser levada em consideração na criação e manutenção de aplicações web a compatibilidade. Com os constantes avanços nas linguagens de desenvolvimento web (HTML5, XHTML, CSS3, entre outros), algumas funcionalidades e efeitos visuais tendem a funcionar em determinado navegador e não funcionar em outros.
No dia a dia, costumo testar minhas aplicações no navegador Internet Explorer 9 e o mesmo possui um ícone próximo à barra de endereços para exibição em modo de compatibilidade.

Porém na manutenção de uma aplicação web em que determinado recurso não funciona corretamente no IE9, ficar clicando neste ícone toda vez que for testar aplicação é na menor das hipóteses uma perda de tempo. Nestes casos, há como deixar o modo de compatibilidade ativo sempre que o navegador abrir. Para isto, basta abrir o IE, clicar em Configuração do Modo de Exibição de Compatibilidade. Lá você tem a opção de definir o endereço a ser acessado neste modo ou definir que todos os sites sejam acessados desta maneira.

Problemas com ASP.NET FileUpload

2012-08-21T21:56:00.001-03:00

Em alguns cenários ao se trabalhar com o componente FileUpload no ASP.NET, revela-se uma caixa de pandora. Uma coisa importante ao se trabalhar com aplicações Web, é desabilitar as mensagens amigáveis de seu IE. Para fazer isso, basta acessar o menu Ferramentas> Opções da Internet> guia Avançadas> nas opções em Navegação, desmarque o checkbox Mostrar mensagens de erro HTTP amigáveis. e em seguida, clique em OK.

Voltando ao assunto, em alguns momentos, ao selecionar um arquivo para upload e executar qualquer ação/ evento que envolva um postback da página, a aplicação lança um erro. Existem muitas causas para este erro, mas a mais comum, é devido ao tamanho padrão para arquivos no controle.

Ou seja, para corrigir esta deficiência, basta definir no arquivo de configuração da aplicação (web.config) o seguinte nó:

<httpRuntime useFullyQualifiedRedirectUrl="true|false [para definir se haverá redirecionamento]" maxRequestLength="[tamanho máximo do arquivo em kbyes]" executionTimeout="120"/>

Na maioria dos cenários, esta pequena alteração costuma ser suficiente. Neste nó, outros parâmetros podem ser acrescentados para o controle de fila de requisições e das threads envolvidas.

Found a quote for which there is no matching quote

2012-08-16T23:55:00.001-03:00

Debugando uma aplicação recentemente, me deparei com um "erro", no mínimo intrigante. No momento em que a aplicação realizava o acesso à base para realizar uma atualização, ocorria uma exceção com a seguinte descrição:

"Found a quote for which there is no matching quote."

Inicialmente fui até minha consulta para verificar se havia esquecido algum apóstrofo, para minha alegria/desespero, a consulta estava ok. Garimpando na internet, descobri que esse erro, poderia ocorrer caso eu tivesse me esquecido de um apóstrofo ou aspas, ou, se a primeira aspa/apóstrofo estivesse em uma linha diferente da aspa/apóstrofo final. Logo após a leitura, verifiquei que um dos parâmetros a ser persistido na base, possuía um "\n" (quebra de linha). Após remover a quebra de linha, o comando funcionou. Portanto, caso você se depare com este erro, vale a pena rever a documentação de seu sistema de gerenciamento do banco de dados, pois, dependendo do sistema, o tratamento de "novas linhas" pode ser uma configuração a ser desativada/ativada.

Introdução ao PSR(Problem Step Recorder)

2012-08-12T12:49:00.000-03:00

O PSR (Problem Step Recorder), é uma ferramenta desenvolvida pela Microsoft para a exibição de cenários de erros. Por muitas vezes após a etapa de desenvolvimento de um sistema, na etapa de QA(Quality Assurance), alguns erros aparecem em cenários bem específicos, muitas vezes, não descobertos/percebidos ou até mesmo especificados no desenvolvimento. E neste momento, para facilitar a exibição do cenário, é que chega o PSR. Para acessar a ferramenta, pressione (Windows)+R e digite psr.exe.

Feito isso, será aberta a seguinte janela:

Ao clicar em iniciar gravação, pode-se minimizar a janela e todos os passos executados pelo usuário, serão detalhados. E quando digo todos, me refiro a TODOS! Todas as interações do usuário serão sumarizadas e printadas com a descrição da ação executada. Quando desejar parar, basta abrir a janela minimizada no início do tutorial e clicar em parar. Será gerado um arquivo zip com uma página em .mht com todos os passos para a simulação do erro. Espero que tenham gostado e que ajude!

Controlando Exceções

2012-08-05T11:28:00.003-03:00

Em alguns momentos debugando algumas aplicações, nos deparamos com determinadas exceções que acabam nos atrapalhando, pois não é algo que se trate de um erro, mas sim um aviso da plataforma. Recentemente, me deparei com uma exception que me impedia de continar a depuração de uma rotina e a seguinte mensagem era exibida:

ContextSwitchDeadlock was detectedMessage: The CLR has been unable to transition from COM context 0x16a300 to COM context 0x16a020 for 60 seconds. The thread that owns the destination context/apartment is most likely either doing a non pumping wait or processing a very long running operation without pumping Windows messages. This situation generally has a negative performance impact and may even lead to the application becoming non responsive or memory usage accumulating continually over time. To avoid this problem, all single threaded apartment (STA) threads should use pumping wait primitives (such as CoWaitForMultipleHandles) and routinely pump messages during long running operations.

No Visual Studio 2010, há como controlar as exceptions a serem lançadas. No meu caso, esta mensagem tratava-se de um MDA (Managed Debugging Assistants). Para controlar algumas exceptions lançadas pela IDE, basta acessar o menu Debug->Exceptions > MDA e habilitar/desabilitar os check boxes.

Armazenando configurações nos Gadgets / Side bar Gadgets Windows Vista/Windows 7

2012-02-27T21:49:00.000-03:00

O que acho interessante nas tecnologias, é o como elas se cruzam e muitas vezes se completam. Os tão aclamados gadgets, foram uma das grandes novidades da Microsoft em aplicações, pois estes nada mais são do que páginas da web. Porém, em muitos sites na internet, como fórums e grupos de discussão, em diversas línguas, reside uma única dúvida.

Como armazenar as configurações parametrizadas pelo usuário em um Gadget, ou, side bar gadgets como descobri recentemente?

Despois de árduas horas de pesquisa, encontrei em apenas um site uma solução definitiva. Portanto, o conteúdo deste post, nada mais é do que a multiplicação do conhecimento, pois, quanto mais conteúdo de um determinado assunto ou tecnologia fica disponível na internet, mais fácil a solução para determinados problemas será encontrada.

Nativamente, os Gadgets recorrem aos métodos System.Gadget.Settings.read("parametroChave") e System.Gadget.Settings.readString("parametroChave") para ler valores de configurações relacionados à chave informada e os métodos System.Gadget.Settings.write("parametroChave", "valor") e System.Gadget.Settings.writeString("parametroChave", "valor").

E aí me veio a seguinte pergunta, e esta pode ser a sua neste momento. Qual a diferença entre writeString e write? A resposta é bem simples, ao chamar o writeString, o valor será armazenado no formato string. E qual a utilidade? Em caso de números com maior precisão, é recomendável armazená-los em String para evitar um arredondadmento, visto que usando write, deixamos a cargo do sistema, a interpretação do tipo de dados a ser gravado (o que em alguns casos, resulta em um truncamento ou perca de precisão). E feito a gravação, aonde encontro as informações gravadas?

As informação dos Gadgets em execução, geralmente podem ser encontradas no seguinte caminho:

C:\Users\Nome_de_Usuário\AppData\Local\Microsoft\Windows Sidebar

Nesta pasta, encontramos geralmente, um arquivo chamado Settings e uma pasta chamada Gadgets. No arquivo Settings.ini, ficam armazenadas todas as informações referentes as instâncias dos Gadgets em execução no Windows, como sua localização na tela entre outros. Ou seja, toda e qualquer alteração em um Gadget, resulta na atualização deste arquivo.

Partindo deste conhecimento, uma biblioteca JavaScript muito útil é o SettingsManager. Importando esta biblioteca, temos acesso aos seguintes métodos:

SettingsManager.loadFile() e SettingsManager.saveFile().

Segue abaixo um exemplo do uso desta biblioteca:

O método SettingsManager.loadFile(), carrega todas as configurações do arquivo Settings.ini localizado na pasta raíz do Gadget em memória.

Com o método SettingsManager.setValue("nome_grupo_config","chave", "valor"), armazenamos em memória um valor associado a uma chave, pertencente a um grupo de configurações (o nome do grupo não faz muita diferença). É importante ressaltar que até o momento, nada foi escrito no arquivo

SettingsManager.getValue("nome_grupo_config","chave", valorPadrão), obtem da memória, um valor associado a uma chave, pertencente a um grupo de configurações, caso não seja possível obter este valor, será retornado o valor padrão.

O método SettingsManager.saveFile(), armazena todas as informações carregadas em memória em um arquivo Settings.ini (nome definido por padrão). Caso o arquivo não exista, ele é automaticamente criado.

E assim, independente de o computador ser reiniciado, desligado, ou o gadget fechado, todas as configurações permanecem salvas. Para maiores informações, segue o link original

Fonte: Settings Manager for Windows Vista Sidebar Gadgets

Criando, Hospedando e Consumindo um WCF Service

2012-02-21T00:54:00.000-02:00

Neste tutorial, utilizei o Visual Studio 2010, IIS 7.0 e um navegador para vizualisar o conteúdo hospedado.

O projeto é um exemplo muito simples de uma calculadora, onde os métodos são expostos pelo serviço e consumidos por um client.

Iniciamos criando o projeto WCF que será o portador dos métodos do serviço a serem consumidos:

File>New Project>WCF>WCF Service Application

Neste projeto iremos editar os arquivos Service1.svc.cs e o IService.cs (A interface (Service Contract), responsável por definir quais os métodos(Operation Contracts) a serem expostos pelo serviço.

Após editar os arquivos, é interessante compilarmos a solução para garantir que a mesma está funcionando corretamente.

Feito isso, clique com o botão direito no projeto WCF>Build Deployment Package. Com isto, o Visual Studio irá gerar um pacote na pasta obj>package pronto para ser publicado no IIS.

Agora, para que o serviço seja acessível, é necessário que ele rode em algum lugar. Neste post, usaremos o IIS para hospedar o serviço.

Com o IIS aberto, clique com o botão direito no site que hospedará a aplicação>Implantar>Importar Aplicativo. Em algumas versões dependendo do idioma, o termo implantar, pode aparecer como deploy.

Será exibida a seguinte janela onde apontaremos para nosso pacote gerado anteriormente na pasta obj>package.

Clique em avançar. Serão exibidos os conteúdo que o pacote contém e que serão implantados.

Em seguida, será exibida uma tela onde podemos personalizar o "alias", ou nome da aplicação no site.

Após definir um nome, clique em avançar e em seguida, concluir. Após isso, nossa aplicação teoricamente, deveria estar no ar. Para confirmar, basta abrir um navegador e digitar o endereço da máquina que hospedou a aplicação /(barra)nome da aplicação.

Se você obtiver um resultado igual a este, ou, parecido com este, sua aplicação está no ar.

Agora, criaremos uma aplicação do tipo Console, apenas para consumir o serviço e trazer o resultado.

Abrimos um novo projeto no Visual Studio: File>New>Project>Windows>Console Application

Para consumirmos um serviço, é necessário adicinar uma referência ao mesmo. Portanto, clicamos com o botão direito no projeto>Add Service Reference. Será exibida a seguinte janela:

Caso seu projeto WCF, Esteja na mesma solução do projeto Console, basta clicar no botão Discover e o serviço aparecerá na relação Services. Seguindo a idéia do post, inserimos o mesmo endereço utilizado no browser, apontando para o arquivo ".svc" e ao clicarmos em GO, será encontrado o serviço hospedado no IIS. Ainda na mesma janela, acessando a interface, vemos os métodos expostos pelo serviço. No campo inferior "Namespace" podemos definir o nome para identificação do serviço.

Após editarmos estas informações, basta clicar em OK.

Com isto já possuímos a referência de serviço em nosso projeto console para consumirmos o serviço própriamente dito.

Para consumirmos o serviço, basta instanciarmos um objeto client e a partir dele, efetuar a chamada dos métodos. Em meu teste, chamo a função Calculate passando dois valores decimais e a operação soma.

É uma boa prática, fecharmos a conexão com o serviço após as operações. Ao rodar o código acima, obtive o seguinte resultado:

Simples não? Nos vemos nos próximos posts! =)

Qualquer dúvida, crítica ou sugestão, sintam-se livres em comentar!

Apresentação

2012-02-17T22:51:00.001-02:00

Meu nome é Bruno, atuo na área de desenvolvimento em .NET com ênfase em C# e ASP.NET entre outros a quase um ano. No momento estou cursando a graduação em Desenvolvimento de Jogos Digitais na FATEC de Carapicuíba. Este blog tem a simples e única finalidade de contribuir na disseminação de conhecimentos das tecnologias de desenvolvimento Microsoft. Todos os comentários e sugestões são bem vindos.