Arquivo da tag: .NET

VBA e .NET – Diferenças entre Projetos

Curtiu o primeiro vídeo da série? Ótimo! Vamos entender agora como um projeto VBA funciona e compará-lo a um projeto criado em no Visual Studio.

Arquivos utilizados no vídeo ► http://www.tomasvasquez.com.br/forum/download/file.php?id=4266

Download do Visual Studio Community ► https://www.visualstudio.com/vs/older-downloads/

Como preparar seu projeto VBA para o controle de versão de código fonte ► https://www.youtube.com/watch?v=09fTq17kLfY

Acesse também

BLOG ► https://www.tomasvasquez.com.br/blog/
FÓRUM ► http://www.tomasvasquez.com.br/forum/
CURSO ONLINE DE C# ► http://www.tomasvasquez.com.br/cursocsharp

Aqui também!

FACEBOOK ► https://www.facebook.com/tomasvaquezsites
TWITTER ► https://twitter.com/tomamais
GOOGLE+ ► https://plus.google.com/+TomasvasquezBr/

Roteiro, apresentação, edição, etc, etc ► eu mesmo 🙂

VBA e VB.NET – Um comparativo (injusto)

E eis o primeiro vídeo da série! Vamos ver o que o .NET tem de bom, principalmente quando se trata de ListView… ou melhor, DataGridView 🙂

Arquivos utilizados no vídeo ► http://www.tomasvasquez.com.br/forum/…

Download do Visual Studio Community ► https://www.visualstudio.com/vs/older…

Entrevista Karen Abecia (RubberDuck) ► https://www.youtube.com/watch?v=7IE9w…

Acesse também

BLOG ► https://www.tomasvasquez.com.br/blog/
FÓRUM ► http://www.tomasvasquez.com.br/forum/
CURSO ONLINE DE C# ► http://www.tomasvasquez.com.br/cursoc…

Aqui também!

FACEBOOK ► https://www.facebook.com/tomasvaquezs…
TWITTER ► https://twitter.com/tomamais
GOOGLE+ ► https://plus.google.com/+TomasvasquezBr/

Roteiro, apresentação, edição, etc, etc ► eu mesmo 🙂

.NET – Obtendo a versão do Framework

Uma rapidinha!

Para que precisamos disso? Nem me perguntem. Por uma necessidade de um dos sistemas na empresa, precisamos fazer uma verificação da versão do framework em que o assembly estaria executando.

Em primeiro instante, pareceu ser algo monstruoso, mas, como de costume, o .NET Framework não nos decepcionou. A linha que traz o dado que queríamos resume-se a seguinte:

System.Environment.Version.ToString()

A linha devolve a versão exata do Framework em que o assembly está executando. É curioso ver o código funcionando em diferentes versões. Tente compilar o programa abaixo em diferentes versões do compilador csc.exe:

using System;
 
public class getFrameworkVersion
{
	public static void Main(string[] args)
	{
		Console.WriteLine(Environment.Version.ToString());
	}
}

Claro, o objeto Version é bem mais completo do que isso. Para ver sua referência completa, é só acessar o link abaixo:

http://msdn.microsoft.com/en-us/library/system.environment.version.aspx

.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