Caros leitores, devido a preferências pessoais esse blog foi migrado para o Blogger da Google. Acesse todo esse conteúdo além de todos novos posts em:

http://fredpolicarpo.blogspot.com/

Aguardo sua visita!

Abraços,

Até!

Os modelos de programação modernos tem se preocupado principalmente com princípios de alto-nível como robustez, flexibilidade, boa arquitetura e um projeto composto de módulos com baixo acoplamento e alta coesão. E eu estou de total acordo com eles, são esses princípios que sustentam grandes softwares, principalmente aqueles que necessitam de constante alteração (isto é, 99%* deles )

Porém existem cenários em que habilidades que antes eram extremamente comuns para os programadores vôvôs, de sistemas Unix e tal, e que para nós, engenheiros de software, não são tão intuitivas, se tornam a chave para uma boa solução. Um exemplo disso são as Expressões Regulares, cujo cenário em que dominam é o reconhecimento de padrões em textos.

Por exemplo: Como fazer para verificar se uma string é uma data válida ? As duas opções que vejo são:

• Um código cheio de IFs e extremamente confuso
• Um expressão regular, não menos confusa que a opção anterior :-p

A grande vantagem da expressão regular é o desempenho, as bibliotecas que processam essas expressões são altamente eficientes, a classe Regex de .NET, por exemplo.

A grande dificuldade de expressões regulares é complexidade, veja por exemplo a expressão regular para validar data no formato dd/mm/aaaa:

(((0[1-9]|[12][0-9]|3[01])([/])(0[13578]|10|12)([/])(\d{4}))|(([0][1-9]|[12][0-9]|30)([/])(0[469]|11)([/])(\d{4}))|((0[1-9]|1[0-9]|2[0-8])([/])(02)([/])(\d{4}))|((29)(\.|-|\/)(02)([/])([02468][048]00))|((29)([/])(02)([/])([13579][26]00))|((29)([/])(02)([/])([0-9][0-9][0][48]))|((29)([/])(02)([/])([0-9][0-9][2468][048]))|((29)([/])(02)([/])([0-9][0-9][13579][26])))

Simples né ??

Mas o interessante é que encontrei um site com centenas dessas expressões malucas: http://regexlib.com/

Com essa ferramenta (o site) você pode facilitar a grande dor de cabeça das expressões regulares, isto é, a confecção das mesmas, e então aproveitar do que elas tem de melhor: Eficiência!

Dica .NET

Para fazer a validação de data (dd/mm/aaa) em .NET (C#) use o seguinte código:

bool regex(string data)

{

string expressao = @”(((0[1-9]|[12][0-9]|3[01])([/])(0[13578]|10|12)([/])(\d{4}))|

(([0][1-9]|[12][0-9]|30)([/])(0[469]|11)([/])(\d{4}))|

((0[1-9]|1[0-9]|2[0-8])([/])(02)([/])(\d{4}))|((29)(\.|-|\/)(02)([/])([02468][048]00))|

((29)([/])(02)([/])([13579][26]00))|

((29)([/])(02)([/])([0-9][0-9][0][48]))|

((29)([/])(02)([/])([0-9][0-9][2468][048]))|

((29)([/])(02)([/])([0-9][0-9][13579][26])))”;

return Regex.IsMatch(data, expressao);

}

O recado é esse, se precisar de Expressões Regulares, prontinhas e esperando para serem usadas, acesse:

* Esses 99% foi um número inventado por mim mesmo, mas caso você pesquise verá que realmente se trata da grande maioria.

Neste artigo vou falar um pouco de como trabalhar com Case-Insensitive em Listas, como havia combinado no artigo anterior.

Antes de falar de lista gostaria de falar de um tipo de Hashtable (eu sei que Hashtable foi assunto do outro post, porém existe uma armadilha do .NET )

Conforme apresentei anteriormente, a classe usada para criar Hashtable Case-Insensitive é CollectionsUtil, com o método CollectionsUtil.CreateCaseInsensitiveHashtable(). O outro método utilitário desta classe é CollectionsUtil.CreateCaseInsensitiveSortedList(). Então ele é o usado para lista case insensitive ?? Não, ele é usado para criar um SortedList que na verdade é um Hashtable e que ordena as entradas pelo valor das chaves :S Estranho, não!? Esse nome realmente não é sugestivo, pois não se trata de uma lista ordenada, mas SortedList é assunto para outro post, vamos ao que interessa!

Pra começar é interessante notar que Case-Insensitive é um problema natural de dicionários, e não de listas, e deve ser por isso que não existe um lista nativa em .NET que seja Case-Insensitive.

Então por que estou escrevendo este post ? Pra mostar uma forma de se fazer busca Case-Insensitive em um ArrayList.

Busca Case-Insensitive em ArrayList.

Isto é, buscar uma string em uma lista sem considerar o case.

Vamos criar um método estático que recebe um ArrayList, um string para ser buscada e então retorna true se a string existir e false se não existir, considerando a comparação Case-Insensitive:

public static bool ContemValor(string valor, ArrayList lista)

{

ArrayList aux = new ArrayList(lista);

aux.Sort();

return (aux.BinarySearch(valor, StringComparer.InvariantCultureIgnoreCase) >= 0);

}

Outra opção é estender a classe ArrayList e sobrescrever o método Contains, segue a implmentacão:

public class ListaCaseInsensitive : ArrayList

{

public override bool Contains(object item)

{

ArrayList aux = new ArrayList(lista);

aux.Sort();

return (aux.BinarySearch(valor, StringComparer.InvariantCultureIgnoreCase) >= 0);

}

}

Para a inserção essa operação não faz sentido pois se fossémos verificar se um valor, case-insensitive ou não, existe em uma lista antes de inserí-lo na mesma essa lista passaria a ser um tipo de Conjunto, o qual, diferentemente de uma lista, não possui elementos repetidos.

É isso, como podem ver a implementação é bastante enxuta, porém pode causar dúvidas por não ser uma operação nativa de ArrayList ou qualquer outro tipo de lista em .NET 2.0. Essa foi a melhor forma que encontrei de satisfazer esse requisito, caso conheça alguma outra compartilhe conosco!

Espero ter colaborado, se esse assunto te interessou faça um comentário!

Certa vez me deparei com o problema de criar dicionários onde as chaves fossem Case-Insensitive, isto é, dicionários onde a chave “nda” fosse considerada a mesma chave “NdA”.

Existem diversos cenários onde este comportamento é desejável. Imagine, por exemplo, um dicionário que contém o mapeamento nomeDoCampo para ObjetoCampo, que é usado para representar todos o campos de um objeto formulário.

Se nas regras de negócio o nome do campo for Case-Sensitive, isto é, o campo nomeado “Campo01″ for considerado diferente do campo nomeado “CAMPO01″, não existe segredo, basta usar um Hashtable ou um Dictionary genérico que o problema estará sanado.

Se, pelo contrário, as regras definirem que os nomes de campo “campo01″ e “CAMPO01″ devem se tratar do mesmo objeto, então seu dicionário, o qual irá conter esse mapeamento, precisa de um comportamento diferenciado.

Vamos ver como seria o trabalho de verificar se um dado campo, supondo que no nome do campo seja case-insensitive, está presente em um dicionário normal, juntamente com a operação de adição de um novo campo.

static Hashtable campos = new Hashtable();
static void insiraCampo(string nome, object campo)
{
if (!campoExiste(nome))
campos.Add(nome, campo);
}
static bool campoExiste(string nomeDoCampo)
{
foreach (DictionaryEntry entrada in campos)
{
if (entrada.Key.ToString().ToUpper().Equals(nomeDoCampo.ToUpper()))
return true;
}
return false;
}

Veja o mesmo exemplo onde a variável campos é um dicionário Case-Insensitive

static Hashtable camposInsensitive = CollectionsUtil.CreateCaseInsensitiveHashtable();
static void insiraCampoCaseInsensitive(string nome, object campo)
{
if (!campos.ContainsKey(nome))
campos.Add(nome, campo);
}
/*
O método campoExiste(string nomeDoCampo) não é mais necessário, basta invocar campos.ContainsKey(nomeDoCampo) para obter o resultado.
*/

O ganho não é apenas na menor quantidade de linhas de código e de um melhor aproveitamento da API .NET, uma das principais vantagens é também o desempenho.

Vejam abaixo as diferenças entre os tempos de inserção usando as duas formas:

Baixe o código de testes clicando aqui.

Configurações da máquina de Testes:

• 1.75 GB de Memória RAM

• Processador AMD Athlon 64 x2 – Dual Core Processor TK-53

// Forma padrão de se criar um Hashtable Case Insensitive
Hashtable insensitive = CollectionsUtil.CreateCaseInsensitiveHashtable();
/*
Criação de um Hashtable Case Insensitive informando o número máximo de entradas que o objeto suporta.
*/
Hashtable insensitive2 = CollectionsUtil.CreateCaseInsensitiveHashtable(1000);
/*
Criação de um Hashtable Case Insensitive baseado em um Dicionário existente
o dicionário recebido com argumento é não-genérico, mas caso deseje realizar essa operação com um dicionário genérico basta fazer o cast que funcionará corretamente.
*/
IDictionary<object, string> dicionario = new Dictionary<object, string>();
dicionario.Add(“chave01″, “Qualquer coisa”);
dicionario.Add(“Chave01″, “Outra Coisa”);
dicionario.Add(“chave02″, “Qualquer coisa denovo”);
dicionario.Add(“Chave02″, “Mais uma coisa”);
// Dispara um ArgumentException
Hashtable insensitive3 = CollectionsUtil.CreateCaseInsensitiveHashtable(dicionario as IDictionary);

No próximo post irei falar um pouco sobre a manipulação Case-Insensitive de outros tipos de Coleções.

Espero ter contribuído, e fiquem a vontade para comentar e questionar sobre este post!

Abraços

]]> http://fredpolicarpo.wordpress.com/2008/04/28/colecoes-case-insensitive-parte-01-dicionarios/feed/ 1 fredpolicarpo Como usar dicionários Case-Insensitive