Já vimos diversos tipos de Array a já aprendemos o que são Classes de Coleção, se você não viu ou não conhece procure nos Posts Relacionados no final da página.

Hoje vamos ver a Classe de Coleção Queue e Stack.

Queue

Essa classe utiliza o famoso conceito FIFO (First-in, First-out: primeiro a entrar, primeira a sair).

Imagine 3 potes vc enche o pote 1, o pote 2 e o pote 3, o pote 1 foi o primeiro a ser preenchido, agora você vai esvaziar o pote 1 depois o pote 2 e em seguida o pote 3. Pronto!

using System;
using System.Collections;

// instânciamos uma nova fila
 Queue novaFilaN = new Queue();

 // Criamos um array com valores
 int[] nums = new int[]{2, 4, 6, 7, 8, 9};

 // inserimos valores na fila
 foreach (int numeros in nums)
 {
     novaFilaN.Enqueue(numeros);
     Console.WriteLine(numeros + "<- Enfileramos\n");
 }

 Console.WriteLine("\n Nossa Fila está assim: ");

 // percorremos a fila
 foreach (int num in novaFilaN)
 {
     Console.WriteLine(num);
 }

 Console.WriteLine("\n --- Agora vamos retirar os valores da fila --- \n");
 // esvaziamos a fila

 while (novaFilaN.Count > 0)
 {
     int number = (int)novaFilaN.Dequeue();
         /** O casting é nesessário pois a Classe de Coleção Queue
          *  é uma classe Generalizada e armazena os valores como object
          *  OBS: Não confundam classes Generalizadas com classes Genéricas
          */
     Console.WriteLine(number + " <- Retiramos ");
 }

A saída vai ser essa:

Stack

A classe Stack implementa o mecanismo LIFO (Last-In, First-Out, último a entrar é o primeiro a sair).

É como uma pilha de pratos, o último prato colocado é o primeiro a ser retirado da pilha =D

Stack pilha = new Stack();

 int[] numeros = new int[] { 2, 4, 6, 7, 8, 9 };

 foreach (int num in numeros)
 {
pilha.Push(num);
Console.WriteLine(num + " <- empilhamos\n");
 }

 Console.WriteLine("\n Nossa Pilha está assim: ");

 // percorremos a pilha
 foreach (int numbs in pilha)
 {
Console.WriteLine(numbs);
 }

 Console.WriteLine("\n --- Agora vamos retirar os valores da fila --- \n");

 //esvaziamos a pilha
 while (pilha.Count > 0)
 {
int number = (int)pilha.Pop();
Console.WriteLine(number + " <- Retiramos da Pilha");
 }

A saída será essa:

Até a próxima!

private Dictionary<String, int> table = new Dictionary<String, int>();

O Dictionary trabalha como o HashMap do java, que tem uma chave e um valor, no nosso caso a chave vai ser uma String e o valor um inteiro.

Adicionando itens no Dictionary.

this.table.Add("PAULO",21);
this.table.Add("Alexandre",24);

No caso de se tentar adicionar e ja existir a chave, não vamos conseguir pois as chaves nao podem se repetir, como em um dicionario.

Removendo itens de um Dictionary:

this.table.Remove("PAULO");

No caso da remoção de um elemento, temos que passar uma chave, se a chave não existir vamos tomar uma Exceção na cara. =D

Simples assim.

No meu último post, falamos sobre Arrays, agora você aprenderá o que é uma Classe de Coleção e qual a diferença entre ela e um Array.

Classes de Coleção derivam do namespace System.Collection , visite Object Browser do Visual Studio 2008 – CTRL+ALT+J, que colecionam elementos só que de uma maneira muito especial.

As classes base de coleção armazenam e retornam seus elementos como umo bjetos (object), isso quer dizer que ao contrário de um Array convencional, que você pode criar ele do tipo int e os valores são armazenados diretamente como um inteiro. Uma classe de coleção os valores sofrerão boxing (explicarei em outro post) isso quer dizer que o valor não fica na pilha mas sim no heap, na pilha fica apenas um alias para o elemento no heap, deu pra entender?

OBS: Existe classes de coleção que nem sempre usam object como tipo de elemento e que podem sim armazenar tipo-valor assim como tipo-referência, mas esse não é o nosso caso agora…

ArrayList

ArrayList é muito bom para misturar elementos além de ter características que um Array comum não tem, exemplo:

• Para redimensionar um Array, você precisa criar um novo maior copiar os elementos para esse novo Array ou se for no caso de diminuir criar um Array menor e omitir elementos.
• Para adicionar um elemento ou remover você terá que redimensionar, em conclusões finais você terá que seguir a teoria do que foi dito acima.

Com um ArrayList essa limitação acaba, para remover, adicionar e inserir nós usaremos métodos.

Veremos aqui alguns desses métodos e propriedades da classe de coleção ArrayList.

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;

namespace ArrayList0
{
    class Program
    {
        static void Main(string[] args)
        {
            // Primeiro criamos o nosso objeto ArrayList chamado de meuAL
            ArrayList meuAL = new ArrayList();

            // Mostramos a capacidade do nosso ArrayList, nesse caso
            // não precisamos de parênteses () porque é uma propriedade
            // e não um método
            Console.WriteLine("1- O ArrayList.Capacity é {0} \n", meuAL.Capacity);

            // Populamos o nosso ArrayList
            Console.WriteLine("2- Populando ArrayList...");
            int z = 0;
            for (int i = 5; z < i; i--)
            {
                // Repare que utilizamos um método
                // não atribuimos mais valor do elemento
                // ao indice como antes: meuAL[0] = valor
                meuAL.Add(i);
            }

            // Agora da pra perceber que a capacidade do ArrayList
            // aumentou dinâmicamente ao adicionar-mos elementos
            Console.WriteLine("\n3- O ArrayList.Capacity agora é: {0}\n", meuAL.Capacity);

            // A propriedade Count contém o número de elementos
            Console.WriteLine("4- ArrayList.Count é: {0} \n", meuAL.Count);

            // Imprimimos os valores dos elementos na tela
            for (int y = 0; y < meuAL.Count; y++)
            {
                try
                {
                    // Observe que é necessário fazer casting dos elementos
                    // isso porque os elementos armazenados no ArrayList
                    // são objetos, quando valores são inseridos com o método
                    // Add() ou Insert() eles sofrem boxing e são armazenados
                    // no heap e não na pilha
                    Console.WriteLine("O índice {0} = {1}", y, (int)meuAL[y]);
                }
                catch (Exception e)
                {
                    Console.WriteLine("\n\n Ops... Algo Errado Aconteceu!\n {0}", e);
                }
            }

            // Tiramos as Gorduras....
            meuAL.TrimToSize();
            Console.WriteLine("\n5- Tiramos as gorduras\n   Agora o ArrayList.Capacity é: {0}\n", meuAL.Capacity);

            // A propriedade Count contém o número de elementos
            Console.WriteLine("6- ArrayList.Count ainda é: {0} \n", meuAL.Count);

            // Imprimimos os valores dos elementos na tela novamente
            for (int y = 0; y < meuAL.Count; y++)
            {
                try
                {
                    Console.WriteLine("O índice {0} = {1}", y, (int)meuAL[y]);
                }
                catch (Exception e)
                {
                    Console.WriteLine("\n\n Ops... Algo Errado Aconteceu!\n {0}", e);
                }
            }
        } // END MAIN
    } // END CLASS PROGRAM
}// END NAMESPACE#

Esse foi só um exemplo! Se tiverem com tempo brinquem com o Object Browser e procurem saber como funciona os seguintes métodos, eles são bem interessantes…

• insert();
• remove();
• removeAt();
• removeRange();
• getRange();
• toArray();
• sort();
• reverse();

Abraços…

Olá a todos,

é verdade depois de um tempo todo mundo aparece… fiquei sem fazer posts nesses últimos dias porque por enquanto eu trabalho com um chefe maluco que joga 3 projetos para eu Administrar, Programar, Criar a Modelagem e Colocar em Produção em apenas 1 mês!

Definitivamente acabou com minha vida, e pra completar vou ter que viajar pra Angola no dia 6 de setembro… é a vida, mas vamos ao que interessa… Arrays em C#!

Bem.. a maioria das pessoas que já desenvolveram podem pular esse paragrafo. O array nada mais é uma seqüência de elementos do mesmo tipo, esses elementos são acessados por um índice do tipo int.

Em questão de memória o Array residem em um bloco contíguo da memória e são tipo-referência, em questão de OO Array também é uma classe, como sempre volto a repetir.. quer saber mais sobre tal classe, interface e etc.? Procure no Object Browser no seu Visual Studio 2008 “CTRL+W, J”.

Declarando e Instânciando Array

A declaração de um array é feito especificando o nome do tipo de elemento seguido por um par de colchetes “[]” e o nome do próprio array:

int[] motosID;

Como toda boa classe sem você instância-la você não faz nada! precisamos criar o objeto. Para instancia-lo utiliza-se a keyword new com o tipo do array seguido com o tamanho dentro de colchetes… Instanciar um array também inicializa seus valores padrões (0, null ou false dependendo do tipo do array)

motosID = new int[9]; // instância o array motos com o tamanho 10 (os índices iniciam contando do 0)
/* Você também pode inicializar, instanciar e definir os valores ao mesmo tempo */
int[] motosID = { 10, 11, 12, 13, 14, 15, 16 };

Também é possível criar Arrays multidimensionais, mas esse não é o objetivo desse artigo.

Você também pode criar Arrays utilizando estruturas (structs) e classe como o tipo do Array.

public class Moto{
// ...
    public Moto(){
        //Construtor padrão
    }
<pre>    public Moto(string nomeMoto){
        //Construtor com argumento
    }</pre>
}

Moto[] intruder = new Moto[1] { new Moto("Intruder125cc"), new Moto("Intruder250cc") };
/* Você pode usar o construtor da classe para iniciar os valores do array */

Iniciando um Array sem Tipo

Muitas vezes você não sabe qual vai ser o tipo do array à ser utilizado, porém você ainda precisa declara-lo… com isso o C# pode “adivinhar” o tipo dos valores que estão sendo utilizados.

var carros = new[]{"Palio", "Siena", "Punto"};

As novidades aqui são: a palavra-chave “var”; a omissão dos colchetes após o tipo (porque não existe tipo aqui ao declarar); a utilização do operador new e os colchetes antes da lista inicializadora.

Para utilizar esse recurso infelizmente você tem que assegurar que todos os valores do array serão iguais se no exemplo acima se eu colocasse depois do punto um valor int você obteria um erro.

Caso os valores sejam compatíveis o compilador converte automaticamente os valores, exemplo:

var numeros = new[]{5, 6, 7, 8, 9, 9.5, 9.6, 9.9, 10} // nesse caso o array não será int mas sim double

Talvez agora para você um array não tipado pode não ter muito sentido, eles são mais úteis utilizados em conjunto com tipos anônimos, mas isso é assunto para outro post.

Acessando Elementos no Array

Agora que já aprendemos a criar um array, precisamos recuperar os valores armazenados lá dentro.

int[] numeros = {1, 2, 3, 4, 5};
Console.WriteLine(numeros[0]); // O valor 1 será impresso na sua tela
//vamos modificar o valor daquela posição do array
numeros[0] = 11;
Console.WriteLine(numeros[0]); // O valor 11 será impresso na sua tela

Como nós sabemos que pode exestir problemas como em qualquer ciração feita pelo ser humano, alguém pode requisitar um índice de acesso que não existe, para isso temos que tratar o erro:

try{
    int[] numeros = {1, 2, 3, 4, 5};
    Console.WriteLine(numeros[5]);
} catch (IndexOutOfRangeException e){
 // código para  tratar o erro
}

Não só isso mas existe a necessidade também de percorremos um array inteiro, claro que para isso podemos utilizar o famoso FOR!!!

int[] numeros = {5, 6, 7, 8, 9, 10,, 11, 12, 13, 14, 15};

for(int i = 0; i < numeros.Length; i++){
int numero = numeros[i];
Console.WirteLine(numero);
}

Length é uma propriedade e não um array, por isso não é utilizados colchetes “()” ao acessa-lo. Lembre-se que o índice do array começa com zero então a última posição é Length – 1. Você também pode utilizar o foreach para percorrer um elemento.

int numeros = {5, 6, 7, 8, 9, 10,, 11, 12, 13, 14, 15};
foreach (int numero in numeros){
Console.WriteLine(numero);
}

O foreach declara uma variável de iteração (neste caso o inteiro numero) que recebe cada valor do Array numeros e executa as instruções seguintes, em primeira vista isso é maravilhoso para percorrer, mas infelizmente você fica limitado:

1. Percorrer apenas em uma parte do Array, ou pular certos elementos. O foreach percorre ele todo obrigatóriamente
2. Percorrer o Array de trás para frente, o foreach percorre o Array sempre do 0 à Lenght -1
3. Se o corpo do loop necessita saber o índice ao invéz do valor atual.
4. Se você precisar alterar o valor de um elemento no array também ficará limitado
5. Etc.

Copiando Arrays

Como um array é um tipo-referência uma variável Array possui uma referência a uma instância do Array, isso quer dizer que ao copiar um Array você acaba copiando a referência e não o Array em si próprio.

int[] inteiros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11};
int[] inteirosSegundo = inteiros;

O problema desse exemplo acima, é que se você modificar alguma valor no Array do inteirosSegundo você estará modificando o valor do Array ponteiros, e vice-versa…

Para copiar o Array é necessário criar outro Array do mesmo tipo e com o mesmo tamanho e criar um FOR para percorrer os valores do Array para o outro Array a ser copiado, exemplo:

int[] inteiros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11};
int[] inteirosCopy = new  int[inteiros.Length];

for(int i = 0; i < inteiros.Length; i++){
inteirosCopy[i] = inteiros[i];
}

O legal é que a classe System.Array nos fornece alguns métodos legal, e dentre elas é CopyTo() que copia os valores de um Array para outro partindo de um determinado índice.

int[] inteiros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11};
int[] inteirosCopy = new int[inteiros.Length];
inteiros.CopyTo(inteirosCopy, 0);

Um detalhe é que esse método é estático, então você pode utilizar esse método a partir da própria classe System.Array.

int[] inteiros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11};
int[] inteirosCopy = new int[inteiros.Length];
Array.CopyTo(inteiros, inteirosCopy, inteirosCopy.Length);

Para mais detalhes de uma olhada no Object Browser do seu Visual Studio.

Você também tem o método Clone no seu objeto de Array ele retorna um object, para copiar os valores é necessário fazer um casting (casting será abordado em outro post, aguardem)

Boa sorte!

Requisitos: Tipo-Valor e Tipo-Referência.

Você deve estar careca de saber o que é um valor null (nulo), o que você não deve saber é que no C# um valor nulo é ele próprio uma referência e você não pode atribui-lo a uma variável tipo-valor, como por exemplo um inteiro, legal né?

Moto biz04 = new Moto();
Moto biz04-02;

if (biz-02 == ????)
      biz04-02 = biz04

Bem se não existisse valores nulos nós não poderiamos verificar se um um objeto está vazio, ou seja não referenciando para lugar algum ou com algum valor atriubuido, como acima.

Agora vamos fazer certo:

Moto biz04 = new Moto();
Moto biz04-02 = null;

if (biz04-02 == null){
      biz04-02 = biz04 //Se o objeto biz04-02 for nulo atribui a referência de biz-04
}

Agora, analise a seguinte instrução:

int p0 = null;

Se você acha que isso vai compilar está muito enganado, como você leu anteriormente o “null” é uma tipo-referência, e não tem como nós colocarmos um tipo-referência dentro de um tipo-valor, para isso existe o tipo-valor nullable.

O C# utilizar um modificador que define uma variável como um tipo-valor nullable, ele é o ponto de interrogação “?”.

int? p0 = null;

if (p0 == null){
int = 0;
}

Observação importante: você não pode atribuir o valor de uma variável nullable para uma variável normal

int? p0 = null;
int p1 = 125;

p0 = 250;

p0 = p1; // copia o valor de p1 (125) para p0 que deixa de ser 250 e vira 125

p1 = p0; // ERRO!

Você também não poderá utilizar o valor de uma variável nullable em um método que espera receber um tipo-valor normal.

O tipo nullable implementa algumas propriedades a mais, como “HasValue” e “Value”

int? p0 = null;

if(!p0.HasValue) // Sim você também poderia usar p0 == null
           p0 = 125;
else
          Console.WriteLine(p0.Value); // Sim de novo você pode usar apenas a variável p0

HasValue retorna null se ele realmente for nulo, e Value retorna o conteúdo da variável, parece ridículo ter essas propriedades, mas um dia lhe serão de grande valia meu nobre.

Simples assim (a operadora telefônica OI é uma merda)

try
            {
            return new SubSonic.Select("nome").From("clientes")
                .WhereExpression("nome").Like("%"+nm+"%")
                .ExecuteAsCollection<ClienteCollection>();
             }catch(SubSonic.SqlQueryException ex)
            {
                throw new SubSonic.SqlQueryException(ex.ToString());
            }finally{
 Connection().Close();
}

1º o try ele vai fazer o que está la dentro
2º se houver algum erro ele captura com o catch
3º independente se houver erro ou não ele executa o que esta no finally

Lógico que podemos colocar algo mais gostoso e complexo ai, mas não é o que estamos tentando abordar neste post… =P

Simples Assim…

Continuando o embalo do último Post (Tipo-Valor e Tipo-Referência), vamos ver o que é um Método que usa parâmetros por referência.

Primeiro vamos relembrar o que é um método que usa parâmetro por valor (provavelmente você já uso muito em funções):

class DiarioDeCodigos{

public static int inteiro;

public static void PassarValor(int param){

this.inteiro = param++;

}

}

A cima está claro que o valor passado é um inteiro, como vimos no último post o int é um tipo-valor, ao executar essa classe e passar qualquer variável como valor ela logicamente não será modificada, apenas o campo inteiro da classe DiarioDeCodigos será modificado.

static void Main(String args[]){

int inteiroTeste = 5;

DiarioDeCodigos.PassarValor(inteiroTeste);

Console.WriteLine(“O valor da variável inteiroTeste é: {0}”, inteiroTeste); //imprimi 5

Console.WriteLine(“O valor da do campo inteiro da classe DiarioDeCodigos é: {0}”, DiarioDeCodigos.inteiro); // imprimi 6

}

Nota: Observe que a classe DiarioDeCodigos não foi instânciada, a palavra-chave static me permite usar um método ou campo de uma classe sem instânciar.

Agora um exemplo de método que utiliza tipo-referência:

class Moto {

public int qtdTanqueGasolina;

public string nomeMoto;

public Moto(){

// Construtor padrão da classe Moto

this.nomeMoto = “SemNome”;

}

public Moto(string nomeMoto){

// Construtor sobrecarregado

this.nomeMoto = nomeMoto;

// Note que o nome do parâmetro é igual ao nome da variável, se você esquecer de
// colocar a palavra-chave “this” para dizer que aquela variável é um campo da classe
// esse código retornaria um erro

}

public void GetNomeMotoAntiga(Moto motoVelha){

Console.WriteLine(“O nome da moto da minha moto antiga é: {0}”, motoVelha.nomeMoto;

}

} // Fim da classe

Moto intruder92 = new Moto(“Intruder 250cc – Antiga”);

Moto intruder09 = new Moto(“Intruder 125cc – Nova”);

intruder09.GetNomeMotoAntiga(intruder92); // imprimi: “Intruder 250cc – Antiga”

No código a cima existe uma classe Moto e essa classe tem um método que recebe a referência de um outro objeto Moto para pegar o atributo nomeMoto de sua antiga Moto.

Ao executar o método GetNomeMotoAntiga pega a referência do campo nomeMoto da instância do objeto passado como parâmetro e imprimi na tela, o nome de sua antiga moto, esse é um exemplo de parâmetro de referência.

Simples assim.

Tipo-Valor (ou “value type” em inglês) é o coletivo dos tipos int, float, double e char, quando você declara uma variável tipo-valor o compilador gera instruções para alocar um bloco de memória grande o suficiente para o conter o valor correspondente.
Por exemplo, quando você declara alguma variável do tipo int o compilador gera as instruções para alocar 4 bytes (32 bits) de memória, quando você atribui algum valor a int o compilador faz com que o mesmo seja copiado para esse bloco, alocado anteriormente, na memória.

int algumInteiro; // aloca 4 bytes na memória
algumInteiro =  125; // O valor “125” é copiado para dentro do espaço alocado

Tipo-Referência (reference type), é o tipo “classe” (definição de um objeto), são tratados diferentemente aos Tipo-Valor. Quando você declara uma classe, o compilador não gera instruções para alocar memória suficiente para armazenar a classe declarada, mas sim para alocar apenas uma pequena parte da memória para armazenar uma referência para outro bloco de memória que tenha a classe em si.
Resumindo tudo: Um endereço aponta para outro bloco na memória.
O armazenamento do objeto só é realmente alocado quando a a palavra-chave new é usada para instanciar um objeto (lembre-se que um objeto é a instância de uma classe). Uma classe é um exemplo de Tipo-Referência. Tipos referência contém referência a blocos de memória.

class Moto {
    public int qtdTanqueGasolina;

    public Moto(){
        // Construtor padrão da classe Moto
    }
} // Fim da classe

Moto intruder; // Aloca um pequeno espaço na memória para armazenar a referência do objeto intruder
intruder = new Moto(); // Agora a objeto Intruder é alocado para a memória onde está sendo referenciada pela instrução anterior.

Lembre-se que o tipo string não é um Tipo-Valor! O tipo string, ou melhor a palavra-chave “string” é apenas um alias para a classe System.String, consequentemente ela não é um tipo primitivo.

Quando você declara a variável primeiroInt como int e aloca a constante 150, na memória existe um pedaço só para a variável primeiroInt se você declara a variável segundoInt e executar a instrução “segundoInt = primeiroInt” você atribui o valor do primeiroInt ao segundoInt, embora eles tenham o mesmo valor existe dois blocos diferentes na memória, um para cada variável, assim logicamente se você modificar o valor do primeiroInt para 98 o segundoInt continuará tendo o valor 150 no seu outro espaço da memória.

Com variáveis do Tipo-Refência, acontece diferente, se você instanciar o objeto intruder da classe Moto você está referenciando a classe Moto com Intruder, ao declarar o objeto shadown e tentar passar o valor de intruder à shadown, como abaixo:

Moto intruder = new Moto();
Moto shadown = intruder;

Você está alocando na memória a variável shadown que é uma referência para o mesmo objeto que a variável intruder referencia.

Sendo desse jeito, se você mudar no objeto intruder o valor do campo qtdTanqueGasolina de “0″ (zero) para “8″ (oito) esse valor também será mudado no objeto shadown!. Porque shadown está apontando para o mesmo objeto que intruder, ou seja shadown e intruder são a mesma Moto, com dois nomes diferentes.

Até a próxima…

ele vai de boa mas em c# existem algumas diferenças:

Exemplo:

você tem 2 construtores na classe abstrata:
//contrutor 1
protected RelatorioAbstrato(int cnt, int total,DataSet dataset,
DateTime data)
        {
            this.cont = cnt;
            this.total = total;
            this.dt1 = data;
            this.ds = dataset;

        }
//contrutor 2
protected RelatorioAbstrato(int cnt, int total, DataSet dataset,
DateTime data1, DateTime data2)
        {
            this.cont = cnt;
            this.total = total;
            this.dt1 = data1;
            this.dt2 = data2;
            this.ds = dataset;
        }

Como utilizar esse construtor?

//subclasse 1
public RelatoriosUm(int cnt, int total, DataSet dataset
                          , DateTime data)
            : base(cnt, total, dataset, data) { }

//subclasse 2
public RelatoriosMais(int cnt, int total,DataSet dataset
                              , DateTime data1,DateTime data2)
            : base(cnt, total, dataset, data1,data2) { }

ao inves de usarmos “super(args[])” usamos “:base(args[])”

simples assim

Pronto =D

public abstract ReportDocument criarRelatorio(); //na super classe

Para reescrever esse metodo nas subclasses:

public override ReportDocument criarRelatorio()//tem q por o override senao da erro
        {

               this.carregaRelatorio();
               MyReport.SetDataSource(Ds);
               MyReport.SetParameterValue("total_rows", this.Cont.ToString());
               MyReport.SetParameterValue("total", this.Total);
               MyReport.SetParameterValue("dataini", this.Dt1);
               MyReport.SetParameterValue("datafim", this.Dt2);

               return MyReport;

        }

Pronto =D!