ASP.NET – Redirecionando para a mesma Página

É relativamente simples fazer com que uma página ASP.NET redirecione para si mesmo, o que faz com que ela volte ao seu estado inicial, não caracterizando um “PostBack”. Existem 3 opções:

1. Response.Redirect(Request.Path);

Onde o Path retorna a url relativa da página corrente, por exemplo: /Pasta/Pagina.aspx

2. Response.Redirect(Request.RawUrl);

A diferença principal para o Path é que o RawUrl traz também todas as informações da url, incluindo a querystring, por exemplo: /Pasta/Pagina.aspx?Parametro=Valor

3. Response.Redirect(Request.Url.ToString());

Neste caso, a objeto Url da classe Uri traz informações completas sobre esta. A chamada do método ToString deste objeto traz uma string com a Url absoluta:  http://localhost/Pasta/Pagina.aspx?Parametro=Valor

Métodos simples que resolvem o problema.

Referências:

http://metadeveloper.blogspot.com/

Redirect Method

http://msdn.microsoft.com/en-us/library/system.web.httpresponse.redirect.aspx

HttpRequest Object

http://msdn.microsoft.com/pt-br/library/system.web.httprequest.aspx

.NET – Transforme strings em Resources com o Resource Refactoring Tool

Não é de hoje que deixar valores de domínio em strings dentro do código é uma má prática. Qualquer mudança nestas, por exemplo, uma mensagem, obrigará a recompilação do aplicativo.

A ferramenta Eclipse tem um recurso interessante chamado Externalize Strings. Nele, a ferramenta analisa todo o código fonte e coleta todas as strings nele e as coloca em um arquivo de configuração, substituindo-as no código fonte por tokens que serão aplicados em tempo de compilação.

Pois bem. Tive essa necessidade no Visual Studio 2005/2008 recentemente e procurei algo que fizesse a mesma proeza da ferramenta da IBM. Entre as opções, além das pagas, há uma bem interessante e free no codeplex que é a Resource Refactoring Tool. Ele faz um trabalho parecido com o Externalize Strings do Eclipse, porém, colocas as strings em um arquivos do tipo Resources (resx) e faz a substituição da string pelo token respectivo.

Após instalado, a opção é adicionada ao menu Refactor do Visual Studio conforme a figura abaixo:

RefactoringTool-Menu

O arquivo de Resource pode ser selecionado e o Preview do código após a alteração pode ser visto, da mesma forma que as ferramentas do Refactor trabalham:

A janela Extrat to Resoruce
A janela Extrat to Resoruce
Preview Dialog padrão do Refactor
Preview Dialog padrão do Refactor

O Resource Refactoring Tool faz um bom trabalho, apesar de não ser tão completo como o Externalize Strings do Eclipse, já que para “externalizar” as strings de um arquivo de código, é preciso clicar em cada uma e executar a ação de Extract to Resource, enquanto o concorrente é capaz de analisar todo o arquivo de código fonte. Provavelmente está será uma funcionalidade futura da ferramenta.

Mas por ser free, faz um belo trabalho. O link oficial da ferramenta é:

http://www.codeplex.com/ResourceRefactoring

Como é mencionado na página, os desenvolvedores estão em busca de contribuidores para melhoria de ferramenta.

Bom proveito!

ASP.NET – Obtendo o nome da página corrente

Parace um pouco estranho, mas geralmente dá mais trabalho é obter as informações mais óbvias e básicas. Bibliotecas e mais bibliotecas fornecem informações sobre tudo, mas o básico geralmente está além do trivial.

Uma dessas informações que me forçou a uma pesquisa na web foi como obter o nome físico da página em que estava trabalhando. O nome físico mesmo, por exemplo, Default.aspx. Nada mais óbvio não?

Pois bem, a linha de código não óbvia que resolver este problema é esta:

// pega o nome do arquivo da página corrente
string pageFileName = System.IO.Path.GetFileName(HttpContext.Current.Request.FilePath);

Bom, uma vez conseguida a informação, a pergunta que fica é, onde poderíamos ou até deveríamos usá-la? Uma situação que vivi por exemplo foi a de trabalhar com o controle MultiView. Como ele se baseia em várias Views que devem ser definidas no momento de mostrar seu conteúdo, pode ser necessária uma estrutura bem montada para fazer a troca das Views, com por exemplo, via QueryString. Neste cenário, seria necessário saber o nome da página corrente para fazer o redirecionamento correto com a QueryString montada. Claro que o nome da página poderia ser informado diretamente, mas no caso de ser necessário renomear a página por qualquer motivo, seria um problema ter que lembrar de corrigir todas as strings no código que a contém.

É isso. Bom proveito!

Tomás

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