C# – Comparando Arrays

Não tem jeito. Apesar da imensa blibloteca que o .NET Framework possui, ainda não há (pelo menos até onde consegui pesquisar) um método nativo para comparação de Arrays ou Coleções.

Como esta foi uma necessidade que tive mais de uma vez em sistemas dos quais participei na construção, publicarei um método genérico para comparação de Arrays simples em C#.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/// <summary>
/// Compara dois arrays de string
/// </summary>
/// <param name="arrayA">Array 1</param>
/// <param name="arrayB">Array 2</param>
/// <returns>True se os arrays forem iguais,
/// False do contrário</returns>
public static bool ArrayCompare(string[] arrayA, string[] arrayB)
{
	if (arrayA.Length != arrayB.Length)
	{
		return false;
	}
	for (int i = 0; i < arrayA.Length; i++)
	{
		if (arrayA[i] != arrayB[i])
		{
			return false;
		}
	}
	return true;
}

O código abaixo completo mostra a utilização da função:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
using System;
 
public class testCompareArrays
{
	public static void Main(string[] args)
	{
		string[] array1 = new string[] { "a", "b", "c", "d", "e" };
		string[] array2 = new string[] { "a", "b", "c", "d", "e" };
 
		if (ArrayCompare(array1, array2))
		{
			Console.WriteLine("Os arrays são iguais");
		}
		else
		{
			Console.WriteLine("Os arrays são diferentes");
		}
	}
 
	/// <summary>
	/// Compara dois arrays de string
	/// </summary>
	/// <param name="arrayA">Array 1</param>
	/// <param name="arrayB">Array 2</param>
	/// <returns>True se os arrays forem iguais,
	/// False do contrário</returns>
	public static bool ArrayCompare(string[] arrayA, string[] arrayB)
	{
		if (arrayA.Length != arrayB.Length)
		{
			return false;
		}
		for (int i = 0; i < arrayA.Length; i++)
		{
			if (arrayA[i] != arrayB[i])
			{
				return false;
			}
		}
		return true;
	}
}

O exemplos faz uso de um array de strings, porém é simples alterá-lo para qualquer outro tipo, desde que seja nativo ou que sobrecarregue o operado ==.

Bom proveito!

Tomás

VBA – Verificar conexão com a Internet

Internet Connection

Método simples para verificar se o computador está ou não conectado a Internet por VBA.

Copie e cole o seguinte código em um módulo VBA:

Private Declare Function InternetGetConnectedStateEx Lib "wininet.dll" _
                                                     (ByRef lpdwFlags As Long, _
                                                      ByVal lpszConnectionName As String, _
                                                      ByVal dwNameLen As Integer, _
                                                      ByVal dwReserved As Long) _
                                                      As Long
 
Dim sConnType As String * 255
 
Sub TesteConexaoInternet()
    Dim Ret As Long
    Ret = InternetGetConnectedStateEx(Ret, sConnType, 254, 0)
    If Ret = 1 Then
        MsgBox "Você está conectado a Internet via " & sConnType, vbInformation
    Else
        MsgBox "Você não está conectado a Internet", vbInformation
    End If
End Sub

A chamada retorna uma mensagem que avisa se existe conexão com a Internet e através de qual conexão ela é feita.

Abraços

Tomás

Microsoft libera versão final do Service Pack 1 das ferramentas .Net Framework 3.5 e Visual Studio 2008

A Microsoft liberou a versão final do Service Pack 1 das ferramentas .Net Framework 3.5 e Visual Studio 2008.

Esses primeiros pacotes de atualizações são lançados agora, nove meses após a chegada dos dois produtos ao mercado. Segundo a Microsoft, os pacotes incluem não apenas correções, mas também alterações que atendem a sugestões feitas por usuários.

O SP1 do Visual Studio 2008, por exemplo, traz como novidade o suporte ao SQL Server 2008 – que está sendo lançado agora – e novos componentes, como o Ribbon, para incluir nos aplicativos faixas de opções no estilo das usadas no Office 2007. Esse último recurso está disponível para as linguagens Visual Basic e Visual C++.

Ainda segundo a empresa, o SP1 do .Net Framework 3.5 oferece melhorias de desempenho de 20% a 45% para aplicações baseadas em WPF (Windows Presentation Foundation). Esse ganho, sustenta a Microsoft, é obtido sem nenhuma alteração no código existente. Os dois pacotes SP1 também incorporam mudanças que têm o objetivo de facilitar o desenvolvimento das aplicações Windows que utilizam ASP.Net.

Os dois pacotes podem ser baixados nos seguintes endereços:

Visual Studio Service Pack 1

.Net Framework Service Pack 1

Fonte: INFO

C# – Trocando a navegação dos controles Windows do TAB para o ENTER

Essa é um pouco velha, mas tão eminente quanto a necessidade de migração de sistemas legados.

Poderia citar inúmeros motivos que levam a essa “cultura” de utilização de sistemas comerciais, mas vou enfatizar alguns:

  • Legado de sistemas orientados a caracter, geralmente feitos em CLIPPER
  • Legado de linguagens de quarta-geração, ou pelo daqueles aplicativos que o tentam ser, como Access e FoxPro
  • Facilidade na utlização do teclado numérico, já que nele além das teclas númericas há também o ENTER facilitando o acesso

O fato é que, é quase certo que os usuários do sistema antigo solicitarão que a navegação entre campos seja trocada do tradicional TAB pelo ENTER.

Para fazer isso em C# (e qualquer outra linguagem .NET, guardadas as devidas conversões), primeiramente é preciso habilitar a propriedade KeyPreview do Formulário principal para que o controle esteja habilitado a interceptar as teclas digitadas.

Depois, para trocar a navegação, bastaria interceptar o evento KeyDown e fazer o tratamento. Mas para fazer um tratamento mais completo, vamos inteceptar o KeyDown para suprimir o ENTER e o KeyUp para trocar a tecla enviada. O código abaixo faz isso:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/// inibe a ação do Enter para evitar o comportamento de
/// Accept em alguns casos
private void _ctrl_KeyDown(object sender, KeyEventArgs e)
{
	if (e.KeyCode == Keys.Enter)
		e.SuppressKeyPress = true;
}
/// adiciona a tratativa à tecla Enter e envia o TAB para
/// promover a navegação
private void _ctrl_KeyUp(object sender, KeyEventArgs e)
{
	if (e.KeyCode == Keys.Enter)
	{
		// SendKeys.Send("{TAB}");
		_ctrl.FindForm().SelectNextControl(_ctrl, true, true, true, false);
	}
}

Percebam que no KeyUp há uma parte do código comentada (SendKeys.Send(“{TAB}”);) que faria com que a tecla TAB fosse acionada no lugar do ENTER, porém, é mais elegante usar o método SelectNextControl do objeto Form, que faz a ação sem a necessidade de simular um comportamento, o que em alguns casos pode causar um comportamento não desejado.

Isso resolve o problema. Para tentar ajudar um pouco mais, disponilizo abaixo um método mais completo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/// <summary>
/// Adiciona o comportamento de navegação através da tecla Enter,
/// da mesma forma como o TAB
/// </summary>
/// <param name="_ctrl">O controle pai que contém os controles em que
/// serão adicionados os eventos</param>
public static void TrocaTABporEnter(Control _ctrl)
{
	if (_ctrl.HasChildren)
	{
		foreach (Control _child in _ctrl.Controls)
		{
			if (_ctrl.HasChildren)
				TrocaTABporEnter(_child);
		}
	}
	else
	{
		///Não funciona para Numeric Up Down
		if (_ctrl is TextBox ||
		_ctrl is MaskedTextBox ||
		_ctrl is ListBox ||
		_ctrl is CheckBox ||
		_ctrl is TabPage ||
		_ctrl is DateTimePicker ||
		_ctrl is ComboBox)
		{
			/// inibe a ação do Enter para evitar o comportamento de
			/// Accept em alguns casos
			_ctrl.KeyDown += delegate(object sender, KeyEventArgs e)
			{
				if (e.KeyCode == Keys.Enter)
					e.SuppressKeyPress = true;
			};
			/// adiciona a tratativa à tecla Enter e envia o TAB para
			/// promover a navegação
			_ctrl.KeyUp += delegate(object sender, KeyEventArgs e)
			{
				if (e.KeyCode == Keys.Enter)
				{
					// SendKeys.Send("{TAB}");
					_ctrl.FindForm().SelectNextControl(_ctrl, true, true, true, false);
				}
			};
		}
	}
}

Este método pode ser chamado em qualquer momento do seu código e faz com que todos os controles filhos do controle passado por parâmetro adiquiram o comportamento, sem a necessidade de mapear o evento para todos os controles.

Como comentado, o código não funciona com alguns controles, em particular o NumericUpDown. Para que isso seja possível, é preciso sobrescrever alguns métodos da classe, mas isso já outra história.

Abraços

Tomás Vásquez
www.tomasvasquez.com.br