C# – static readonly vs. const

C#
O pessoal do grupo em que participo colocou essa pergunta e achei bacana comentar aqui.

Qual a diferença entre utilizar static readonly ou const ? Tem algum
que é mais performatico?

const é avaliado em tempo de compilação, enquanto static readonly em tempo de execução. Isso permite que no static readonly você inicialize uma classe ou struct, enquanto no const você só pode usar tipos primários (porque são compilados).

O readonly pode ser inicializado dentro do construtor. Ou seja, dependendo do construtor que você usar, o readonly pode ter valores diferentes. Já o const não. Mas isso só vale pra readonly non-static, pq só existe um construtor static pra classe.

Tem mais um fator, muito importante aliás, principalmente na utilização de componentes.

Em quase todas as linguagens, const é apenas um facilitador para substituição de valores. Quando você declara um const e atribui um valor a ele, por exemplo, um inteiro de valor 5, ao compilar, todos os lugares que referenciam sua const vão ter o valor substituído pelo inteiro 5. Por isso a performance.

No caso do static reanonly, isso não acontece pois, apesar da variável ser somente leitura, ela ainda é uma “variável” e sempre será referenciada.

Um caso típico de onde não se deve usar const é em bibliotecas. Por exemplo, você criar uma lib que vai conter a string de conexão. Você a coloca em uma const. Na compilação, todos os valores que refenciam a
string de conexão terão seus valores substituídos pelo valor da const. Ok, era o que você queria. Mas, caso você preciso alterar a string de conexão, você obviamente vai recompilar e publicar somente a lib com a
informação. O fato é, ao fazê-lo, todo o resto do código só conhece o valor anterior da const.

Para ver um exemplo bem simples, crie o seguinte programa no notepad mesmo:

1
2
3
4
5
6
7
8
9
10
11
using System;
 
public class TestConst
{
        public static void Main(string[] args)
        {
                const string MinhaString = "bla";
                Console.WriteLine(MinhaString);
        }
 
}

Compile com o csc.exe. Em seguida, abra o assembly com o ILDASM ou mesmo o Reflector. Veja o resultado.

ASP.NET – Preenchendo o controle Repeater com um Array de String

O controle Repeater tem um único defeito, que é também sua maior virtude. Peca pela simplicidade.

Entre algumas coisas que precisei fazer recentemente, uma era colocar os itens de um Array em uma página ASP.NET. Querendo fugir do Response.Write e da concatenação de itens dentro de um laço de repetição, decidi usar o bom e velho Repeater. O problema é que, após definir o DataSource do dito como sendo o Array de Strings, não há como informar o “Value” ou “Text” de um Array para o Eval() ou Bind(). Solução: Basta mencionar o Container.DataItem no código aspx que o Repeater se encarrega de efetuar o “Bind” com o Array:

1
2
3
4
5
6
7
8
9
10
11
12
13
	<asp:Repeater ID="RepeaterArray" runat="server">
	    <HeaderTemplate>
	    	 <ul>
	    </HeaderTemplate>
	    <ItemTemplate>
		<li>
		        <%# Container.DataItem %>
		</li>
	    </ItemTemplate>
	    <FooterTemplate>
                </ul>
	    </FooterTemplate>
	</asp:Repeater>
1
2
3
4
5
6
7
8
9
string[] meuArray = new string[] {
        "item 1",
        "item 2",
        "item 3",
        "item 4",
        "item 5" };
 
RepeaterArray.DataSource = meuArray;
RepeaterArray.DataBind();

Mais simples impossível. Bom proveito!

C# – Mesclando Arrays (Merge Arrays)

Mais um código da classe “utilitária”. Como várias das funções do Framework ainda retornar nativamente arrays (lembrando que nas primeiras versões do .NET Framework, os Generics não existiam), é comum precisarmos unir Arrays de tipos primitivos, um trabalho nada usual e que atualmente com as listas tipadas tornaram-se bem mais fácil de fazer.

O problema é que geralmente temos que apelar a loops para fazer esse tipo de trabalho, o que acaba por “sujar” um pouco o código, já que esse tipo de tarefa não está vinculada a uma lógida de negócios, podendo ser classificada como um dificuldade técnica.

O código abaixo mostra um exemplo de como fazer o merge utilizando algumas funções auxiliares da classe Array:

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
 
namespace MergeArrays
{
	public class Program
	{
		public static void Main(string[] args)
		{
			string[] filesInTemp = Directory.GetFiles(@"C:\temp");
			string[] filesInTem2 = Directory.GetFiles(@"C:\temp2");
			string[] allFiles = new string[filesInTemp.Length + filesInTem2.Length];
 
			filesInTemp.CopyTo(allFiles, 0);
			filesInTem2.CopyTo(allFiles, filesInTemp.Length);
 
			for (int i = 0; i < allFiles.Length; i++)
			{
				Console.WriteLine("{0} = {1}", i, allFiles[i]);
			}
 
			Console.Read();
		}
	}
}

No exemplo, o código usa o método GetFiles da classe Directory, que retorna um Array de string com os nomes dos arquivos (absoluto, ou seja, com a pasta e tudo) contidos na pasta informada. Dois arrays são montados com os arquivos de duas pastas. Em seguida, um terceiro array é criado com o trabalho dos dois arrays anteriormente preenchidos. O método CopyTo da classe Array faz a mágica de copiar o conteúdo para um novo Array, tomando o cuidado de mencionar o índice correto a partir de onde o Array deve copiar para não sobreescrever nenhum dado. No código, o primeiro copia seu contéudo a partir do índice 0 e o segundo a partir do tamanho (length) do segundo.

Assim, caso for necessário mesclar mais Arrays, o mesmo raciocício pode ser utilizado.

Bom proveito!

C# – Convertendo um Array de String em um List

Dica bacana do site DotNetSpider, segue um trecho de código que efetua a conversão de um array de strings em um List<string>:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
string[] mylist = new string[5]; // cria o array de strings;
 
// preenche com alguns valores
mylist[0] = "Olá";
mylist[1] = "como";
mylist[2] = "vai";
mylist[3] = "você";
mylist[4] = "?";
 
// criar uma lista tipada de strings (List),
// passando o tamanho do array de strings por parâmetro
List StringtoList = new List(mylist.Length);
 
// chama-se o método AddRange que aceita arrays convencionais
// como parâmetro para adicionar os itens do array no List
// e para efetuar a "conversão"
StringtoList.AddRange(mylist);

Os comentários são bem elucidativos para o entendimento do código. Como muitos métodos nativos do framework que retornar arrays de string, só para lembrar, Enum.GetNames e Directory.GetFiles, é útil em várias situações.

Bom proveito!