C# – Referenciando tipos anônimos em controles DataBind

Novas funcionalidades são sempre bem vindas, mas as novidades sempre trazem mais novidades, situações, problemas, enfim, o trivial.

Os tipos anônimos do C# 3.0 economizam um bocado de tempo quando se precisa extrair algo de uma lista baseada em uma query LINQ. Vou dar um exemplo para elucidar a situação. Quando você extrai de uma determinada lista apenas alguns campos, por exemplo, do objeto:

public class Pessoa
{
	public string Nome { get; set; }
	public string SobreNome{ get; set; }
	public string Curso { get; set; }
	public string Escola { get; set; }
}

E queremos tirar uma lista única de Curso/Escola. Fácil, é só usar o Distinct, gerando algo como:

(from p in PessoaList
select new { p.Curso, p.Escola }).Distinct();

Mais fácil ainda se atribuir o resultado do código acima direto ao DataSource de um Repeater ou GridView. Mas, como fazer para coletar os valores e fazer o bind e um tipo que não existe, por exemplo, no evento ItemDataBound ou RowDataBound? Se você ativar o Watcher sobre o e.Item.DataItem, você verá um tipo anônimo referenciado de uma forma um pouco estranho. Se tentar usar no código, não funciona.

Como resolver? Não tem jeito: Reflection!

Se você tiver certeza de que a propriedade existe, dá para fazer uma referência direta:

e.Item.GetType().GetProperty("Escola").GetValue(e.Item, null)

Se houver dúvida quanto a existência, algumas verificações precisarão ser feitas. Deixo abaixo do código do colega leppie do StackOverFlow que faz tais verificações:

object o = e.Row.DataItem;
Type t = o.GetType();
PropertyInfo pi = t.GetProperty("StringProperty");
if (pi != null && pi.PropertyType == typeof(string))
{
  // the property exists!
  string s = pi.GetValue(o, null) as string;
  // we have the value
  // insert your code here
  // PROFIT!  :)
}

Bom proveito!

Referências:

http://stackoverflow.com/questions/607433/net-databinding-referencing-anonymous-type-properties

.NET – Evitando o InvalidOperationException em aplicações Multi Thread Windows Forms

Um problema um pouco comum para quem trabalha com aplicações Windows Forms e rotinas Multi Thread, principalmente quando as rotinas multi thread interagem com os controles. Vamos imaginar uma situação típica, um aplicativo de envio de emails.

Para oferecer uma interface amigável, você expõem campos com valores editáveis, enfim, e no final do formulário, um TextBox Multiline para mostrar o andamento das tarefas, como se fosse uma janela de Output do Visual Studio. Durante a sua rotina, você quer inserir informações do estado da execução do seu algoritmo. Bem, nada mais simples do que adicionar texto ao TextBox da forma mais tradicional possível.

Bom, se fizer isso sem aplicar Multi Thread, o que você verá é a tela parada até o término da execução da rotina, o que não serve para nós. O jeito é executar a mesma em outra thread, certo? Essa é a parte fácil, já que o .NET Framework dispõem de métodos e bibliotecas bem simples para isso. Você põem para executar o aplicativo já rodando sua rotina principal em outra thread e: InvalidOperationException.

A razão do erro é simples, mas nem tanto. Todos os controles Windows são por padrão Thread-Safe. Objetos Thread-Safe só podem ser manipulados por uma thread por vez. Isso evita que estes sejam colocados em estados inválidos ou inconsistentes. São vários os casos, mas se está tendo este problema, provavelmente sabe do que estou falando.

O que é preciso fazer então? Garantir que sua thread acessa o controle de forma que não interfira em outras threads que já o estejam manipulando. Para isso, precisaremos da propriedade InvokeRequired do controle, o método Invoke e o um delegate para criar um CallBack da nossa função. Bom, nada melhor que um exemplo para melhor entender. Vou economizar tempo e usar um da própria Microsoft, com todas as explicações nos comentários:

// Delegate para permitir a chamada assíncrona
// ao método setText
delegate void SetTextCallback(string text);
 
// A thread a ser executada
private Thread demoThread = null;
 
// O evento que segue cria um nova Thread
// para execução do método ThreadProcSafe
private void setTextSafeBtn_Click(object sender, EventArgs e)
{
	this.demoThread =
		new Thread(new ThreadStart(this.ThreadProcSafe));
 
	this.demoThread.Start();
}
 
// Método que faz uma chamada ao SetText
// que faz a verificação de Thread-Safe
private void ThreadProcSafe()
{
	this.SetText("Texto do textbox.");
}
 
// Método que tenta atribuir o texto ao controle textbox1
// de forma "segura"
private void SetText(string text)
{
	// a chamada ao InvokeRequired garante que a thread atual
	// é a mesma que está manipulando o controle no momento
	// Caso não seja a mesma thread,
	// retorna true e faz a chamada ao CallBack.
	// a chamada ao metódo Invoke faz com que a thread
	// que manipula o componente chame o CallBack quando
	// liberar o controle, passando os argumentos
	if (this.textBox1.InvokeRequired)
	{
		SetTextCallback d = new SetTextCallback(SetText);
		this.Invoke(d, new object[] { text });
	}
	else
	{
		this.textBox1.Text = text;
	}
}

Em miúdos, ao tentar alterar a propriedade de texto do controle este já estiver sendo manipulado por outra thread, cria-se um enfileiramento da sua chamada. Assim, quando a thread que ocupa o controle liberá-lo, sua rotina será automaticamente executada.

A parte chata é que isso deverá ser feito para toda e qualquer propriedade que precisar ser alterada no controle sob a execução de um thread que não a principal.

O mesmo exemplo pode ser visto em VB.NET neste link:

http://www.codigofonte.net/dicas/dotnet/222_trabalhando-com-threads-em-formularios-windows

Bom proveito!

Referências:

http://msdn.microsoft.com/en-us/library/ms171728.aspx

.NET – Habilitando o OpenFileDialog no controle PropertyGrid

Poucou utilizado em sistemas tradicionais, infelizmente, o controle PropertyGrid disponibilizado a partir do .NET Framework 2.0 possui um forma prática de exibir características de um determinado objeto ou controle. Um tutorial bem completo deste pode ser visto aqui.

Tudo certo. Em um de seus usos, fiquei curioso em saber como alguns sistemas, inclusive o Visual Studio e outras IDEs Microsoft conseguir transformar algumas das caixas de valores do PropertyGrid campos OpenFileDialog, ou seja, quando este precisar conter o caminho de um arquivo, que aparecesse o pequeno botão a direta do campo para exibir tal funcionalidade.

Bom, a resposta é simples. A propriedade que irá expor o valor deve conter os seguintes atributos:

[EditorAttribute(typeof(System.Windows.Forms.Design.FileNameEditor),
typeof(System.Drawing.Design.UITypeEditor))]
public string CaminhoDoArquivo { get; set; }

A mágica é feita pelo atributo System.Windows.Forms.Design.FileNameEditor. O projeto precisa referenciar a bibliotecas System.Windows.Forms e System.Design para alcançar as classes mencionadas. A aparência fica dessa forma:

Também é possível adicionar a caixa de mapeamento de diretório, trocando o valor para System.Windows.Forms.Design.FolderNameEditor. O funcionamento do clique nos botões dispensa explicações, bem como a versão do código para VB.NET, certo?

Referências

http://stackoverflow.com/questions/170791/how-can-i-get-an-openfiledialog-in-a-custom-controls-property-grid

Bom proveito!

DotNetNuke – Importação de usuários em massa

DotNetNuke
DotNetNuke

O DotNetNuke destaca-se por ser um dos poucos gerenciadores de conteúdo online que rodam na plataforma .NET, da Microsoft. Bom, quem chegou até este post sabe muito bem do que estou falando. Para o restante, reservarei um outro post para falar de uma forma geral sobre este conhecido CMS.

Sob a pressão de uma necessidade na empresa (sempre é), que trabalha com o DotNetNuke, houve uma necessidade específica de efetuar uma grande carga de usuários para um portal específico. Para isso, seria necessário desenvolver algumas rotinas específicas, já que a inserção de um Usuário no Portal DotNetNuke segue algumas regras, a começar pela criptografia da senha. Bom, como toda boa necessidade, antes de desenvolver, vamos ver o que tem na comunidade certo? Bom, o resultado foi uma solução dada por John Mitchell’s, onde em uma simples página, ele criou uma rotina que através de informações de um XML baseado nos campos o objeto UserInfo da biblioteca do DotNetNuke, estes dados são automaticamente importandos para o banco de dados do portal onde a página é hospedada.

O XML é algo parecido com o seguinte:

<Users>
   <User>
      <Username>User1</Username>
      <Email>user1@yahoo.com</Email>
      <FirstName>User</FirstName>
      <LastName>One</LastName>
      <Password>password</Password>
      <Unit></Unit>
      <Street></Street>
      <City></City>
      <Region></Region>
      <PostalCode></PostalCode>
      <Country></Country>
      <Telephone></Telephone>
   </User>
   <User>
      <Username>User2</Username>
      <Email>user2@yahoo.com</Email>
      <FirstName>User</FirstName>
      <LastName>Two</LastName>
      <Password>password</Password>
      <Unit></Unit>
      <Street></Street>
      <City></City>
      <Region></Region>
      <PostalCode></PostalCode>
      <Country></Country>
      <Telephone></Telephone>
   </User>
</Users>

São apenas dois arquivos, o .aspx e o .vb do codebehind, que obviamente executam interpretados, mas executam a proeza com maestria, economizando algumas boas horas de trabalho. Na execução, algumas inconsistências foram detectadas, mas nada que comprometa o trabalho.

Link original:

http://blogs.snapsis.com/CommentView,guid,c9d3082b-d7b1-4dfb-8c9c-67c0e864964d.aspx

Bom proveito!