Para aqueles que não participaram da reunião de hoje (04/03/2008) vimos um pouco do Visual Studio 2005 e lançamos um projeto. A descrição do mesmo segue abaixo:

DESCRIÇÃO DO PROJETO

Implementação em C# de um sistema eletrônico de apuração (urna eletrônica) e contagem de votos.

Funcionalidades do sistema:

• Cadastramento nos Cartórios Eleitorais

• Identificação do Eleitor nas Seções de Votação

• Votação em Cabina Indevassável

• Apuração dos votos de cada Seção

• Totalização dos Votos de todas as Seções

Os usuários do sistema de apuração, integração e contagem de votos (eleitores e funcionários dos tribunais eleitorais regionais) deverão ter acesso apenas as operações definidas pelo TSE, através de uma interface interativa segura, clara (de fácil entendimento) e eficiente.

ASSUNTOS A SEREM ABORDADOS

· Uso de estruturas básicas

· POO

· Enumeradores

· Coleções

· Windows Forms

 

*A ídéia para esse desafio foi baseada no projeto proposto por Clarissa na disciplina Programação II

Por Lucélia Brito

A célula acadêmica Soft.Net, criada e formada por estudantes do curso de Ciências da Computação da Católica, está completando um ano de diversas conquistas. O interesse dos alunos de Ciências da Computação participantes da Soft.NET levou alguns deles a escrever artigos para grupos de discussão da tecnologia .NET (como o SharpGame), além dos estudantes Ana Carolina Lima, Felipe Pimentel e Walby Felix terem obtido a certificação internacional da Microsoft.

Participando da célula acadêmica Soft.NET, os alunos estabelecem uma relação diferenciada com a Microsoft, compartilham conhecimentos, mantêm-se atualizados para o mercado de trabalho e repassam o que aprendem para outros estudantes, através de palestras, seminários e eventos organizados pela Soft.NET. O grupo formado na Católica é liderado pela aluna Ana Carolina Lima e conta com o auxílio do ex-aluno de Ciências da Computação e estudante embaixador da Microsoft, Marcelo Diniz.

As Células Acadêmicas são apoiadas pela Microsoft, que fornece gratuitamente o material de apoio aos estudos (arquivos para download, livros, CD’s, apostilas, um sistema de gerenciamento pela Internet) e promove encontros, palestras e competições. Mais informações pelo site www.softdotnet.com.br.

Link da matéria: http://www.unicap.br/assecom2/boletim/2008/fevereiro/boletim_26.02.2008.html#2

É com grande prazer que gostaria de informar que temos agora um quarto participante que conseguiu obter a certificação, Luciano José, a notícia foi recebida depois da entrevista por isso não foi mencionado.

Parabénss Luciano !!!!!

 

Olá,

Nesta terça (26/02) a célula acadêmica Soft.NEt voltará com suas atividades, com novas metas
e muitas novidades. A reunião será toda terça, na sala 105 do Bloco A, tendo inicio às 17:00hs.

Um célula acadêmica é focada em capacitar alunos de cursos de TI,
possibilitando que o aluno fiquei mais antenado nas novas tecnologias da Microsoft e fornece material de estudo e orientação.

Até Terça.

Atenciosamente
Ana Carolina Lima
Líder Soft.NET
Microsoft Certified Professional
http://anacarolima.spaces.live.com/

Blog de férias !!!

heiuhuehueueh =)

Té mais !!

 

Olá, segue abaixo a especificação do projeto do banco 24 horas. O que vale é tentar !! =)

Boa sorte a todos.

Data da entrega : 18/01/2008

Projeto C#

Esta etapa do curso é constituída pelo desenvolvimento de um projeto, no qual o participante poderá apresentar todos os conceitos aprendidos durante o curso. Esta etapa tem como objetivo possibilitar uma avaliação individual de cada participante, nos quesitos: empenho, conteúdo assimilado, compreensão do projeto, etapas concluídas e qualidade do projeto entregue (boas práticas de programação).

DESCRIÇÃO DO PROJETO

Elaborar um sistema para a gestão operacional (atendimento eletrônico) de um Banco 24 horas. As funcionalidades do sistema (verificação de senha, consulta a saldo, déposito, saque, etc) serão estabelecidas pelo banco contratante (Banco do Brasil, Bradesco, Real, Safra, Unibanco, Itaú etc). Os clientes do Banco 24 horas deverão ter acesso a todas as operações financeiras, definidas pelo banco contratante, através de uma interface interativa clara (de fácil entendimento) e eficiente.

DETALHES

O objetivo deste projeto é o de desenvolver uma aplicação de controle de transações bancárias, sendo estas:

· Saldo

· Depósito

· Transferência

· Saque

Saldo:  Deverá fornecer o saldo da conta em questão.

Depósito: Deverá efetuar um depósito na conta em questão.

Transferência: Deverá efetuar uma transferência entre contas, para isto deve ser verificado se o saldo é suficiente como também se é possível fazer a tranferência para a conta em questão.

Saque: Deverá efetuar o saque da conta em questão, para isto deve ser verificado se o saldo é suficiente.

ASSUNTOS A SEREM ABORDADOS

Será conferido se o grupo compreendeu as aulas do programa de capacitação, deverá ser cobrado o uso de alguns conceitos:

· Uso de estruturas básicas

· POO

· Enumeradores

· Coleções

· Windows Forms

Avaliação

Cada turma será avaliada durante o desenvolvimento do projeto.

Pontos de avaliação:

· Cronograma;

· Utilização das tecnologias necessárias;

 

Os conceitos de classe e objeto formam a base da para o desenvolvimento de sistemas orientados a objetos.

Quando vemos esta figura o que vem em nossa mente ? Muitos de nós responderia que esta figura se refere a uma bicicleta, mas alguém poderia ver nesta figura uma motocicleta. A questão que podemos analisar é: porque a reposta dada geralmente é bicicleta ? Podemos dizer que esta resposta é mais comum porque as características básicas de uma bicicleta são vistas nessa figura, como rodas, guidon, etc. A partir dessas descrições são geradas verdadeiras bicicletas que poderemos utilizar, que terão determinada cor e tamanho para essas características que enumeramos.

Em orientação a objetos, todas as coisas que podemos definir são objetos. Uma bicicleta, um monitor de TV, uma pessoa. Todos esses objetos pertencem a classes, cada uma delas com características que irão definir os elementos que podem pertencer a elas. Ou seja, os objetos que pertencem à classe bicicleta irão conter todos as mesmas características. O mesmo ocorre para os objetos pertencentes à classe monitor de TV, pessoa e carro, entre outras. Mesmo os objetos pertencentes a mesma classe irão possuir características próprias que o identificam dentre os demais objetos. Por exemplo, duas pessoas, mesmo gêmeas idênticas, são ainda pessoas diferentes. Uma característica que poderia distingui-las seria seu código genético. Uma TV poderia ter seu número de série, etc, ou seja, todos os objetos possuem sua identidade, distinguindo-os dos demais objetos que pertencem a sua classe.

Rumbaugh descreve uma classe como "um grupo de objetos com propriedades semelhantes, o mesmo comportamento, os mesmos relacionamentos com outros objetos e a mesma semântica". Ou seja, uma classe nada mais é do que uma abstração, ela não existe propriamente, sendo apenas uma definição. Os objetos, por sua vez, são a instanciação de uma classe. Eles existem e podem ser manipulados.

As características, ou propriedades, de um objeto são chamadas de Atributos. Os atributos guardam valores úteis para a definição e representação de um objeto. Por exemplo, caso definamos as propriedades Altura, Nome, Peso, Idade e Cor para a classe Pessoa, poderíamos atribuir a um objeto dessa classe os valores 1.70, "José", 50, 75 e "Branca", respectivamente. O exemplo acima mostra algumas características dos atributos de uma classe.

Além dos atributos, vimos que as classes podem definir comportamento para os seus objetos. O comportamento de uma classe é definido através de seus métodos. Em linguagens puramente orientadas a objetos a forma que os objetos possuem para modificar os valores de seus atributos é através das chamadas aos seus métodos.

Por exemplo, podemos definir um método FazAniversario para a classe Pessoa. A função do método FazAniversario é a de aumentar o valor do atributo Idade dos objetos dessa classe. Para aumentarmos o valor do atributo idade, não deveríamos fazer acesso direto ao seu atributo, mas sim, chamar o método FazAniversario.

Um aspecto importante que devemos observar em relação a definição dos métodos é que ela é feita para a classe, sem levar em consideração objetos isoladamente. Ou seja, quando definimos o método FazAniversario pertencente à classe Pessoa, não estaremos levando em consideração um objeto e sim a classe de objetos que ele manipula.

Herança

Imaginemos agora que quiséssemos criar uma nova classe chamada Trabalhador. Poderíamos pensar nessa classe como possuindo os mesmos atributos da classe Pessoa, uma vez que todo trabalhador é uma pessoa. Porém um trabalhador possui atributos e métodos que pessoas de uma forma geral não possuem como, por exemplo, o salário, o cargo que ocupam, e a possibilidade de um aumento salarial.

Seria uma perda de tempo termos de rescrever todo o código que já foi escrito anteriormente para a classe Pessoa. O ideal seria que pudéssemos aproveitar todo o código previamente escrito e simplesmente de tivéssemos de escrever o código restante ou aquele que porventura tivesse sido alterado, ou seja, deveríamos apenas nos preocupar com o que realmente caracteriza a nova classe que estamos definindo. A boa notícia é que podemos fazer isso, graças a um conceito de orientação a objetos chamado de Herança.

O conceito de herança dentro da orientação a objetos é bastante semelhante ao conceito que temos em nossa vida cotidiana. Por exemplo, da mesma forma que os filhos herdam características dos seus pais, que por sua vez herdaram características de seus próprios pais através de uma "hierarquia genética", assim são os objetos. Os objetos podem herdar características e comportamento, ou seja atributos e métodos, de outros objetos atendendo, também, a uma "hierarquia genética". A definição dessa hierarquia não é feita através dos objetos, mas sim através das classes as quais eles pertencem.

Em nosso exemplo, para definirmos a classe Trabalhador e aproveitarmos todos os atributos e métodos previamente definidos para a classe Pessoa, devemos em sua definição informar que a nova classe, a classe Trabalhador, é uma subclasse, também chamada classe filha, de uma outra classe. A classe Pessoa será, portanto, a classe pai, também chamada de super-classe, da classe Trabalhador.

Encapsulamento

Um outro conceito importante dentro da orientação a objetos é o de Encapsulamento. Para garantir um melhor funcionamento dos programas, principalmente devido a herança de código entre as classes, seria aconselhável que os detalhes da implementação de cada um dos métodos escritos ficassem isolados dos desenvolvedores. Para que um desenvolvedor venha a utilizar ou herdar uma classe criada por outro desenvolvedor, bastaria que ele soubesse os atributos e métodos que compõe a classe-pai e não a implementação de cada um deles. O encapsulamento nada mais é do que esse conceito.

Quando criamos a classe Trabalhador já havia sido declarado e codificado o método FazAniversario. Nós tínhamos conhecimento apenas de sua existência e que deveríamos utilizá-lo quando desejássemos aumentar de 1 a idade de um objeto da classe Pessoa e, por conseqüência, da classe Trabalhador. Não saberíamos, ou melhor, não seria necessário que soubéssemos como esse método foi implementado para que pudéssemos utilizá-lo.

É bem verdade que, como desenvolvedores de sistemas, ficamos acima de tudo curiosos para verificar como o código escrito para um determinado método funciona antes de utilizá-lo, porém isso não é necessário. Dessa forma, o código que utilizamos fica protegido contra qualquer alteração indevida. Basta que saibamos o que cada método executa sem termos de nos preocupar com a possível complexidade existente nesse código.

Polimorfismo

Polimorfismo significa que uma chamada de método pode ser executada de várias formas (ou polimorficamente). Quem decide "a forma" é o objeto que recebe a chamada. Essa última frase é muito importante, pois ela encerra a essência do polimorfismo. Ela significa o seguinte: Se um objeto "a" chama um método xpto() de um objeto "b", então o objeto "b" decide a forma de implementação do método. Mais especificamente ainda, é o tipo do objeto "b" que importa. Para concretizar melhor, digamos que xpto() seja grita(). Então a chamada b.grita() vai ser um grito humano se "b" for um humano e será um grito de macaco, se o objeto "b" for um macaco. O que importa portanto, é o tipo do objeto receptor "b".

 

Array

Arrays são usados para gerenciar grande quantidade de informações. Para utilizar arrays você deve declará-los antes de utilizar. Os arrays respeitam as mesmas regras de escopo que as variáveis, ou seja, se são declaradas dentro do procedimento, ficam disponíveis apenas para o procedimento em que foram declaradas.

Declarando um array

int[] MeuArrayDeInteiros;

Instanciando um array

int[] nome_da_variável = new int [tamanho do array];

Ex.: int[] numeros = new int[3]; //Array de 3 posições 0,1,2

Inicializando um array

int[] numero = {30,45,10,36};

Collections

• São classes usadas para agrupar e gerenciar objetos relacionados e que permitem armazenar, buscar e interagir com estes objetos;
• As Collections possuem mais funcionalidades do que uma array, facilitando sua utilização.
• O Namespace System.Collections contém diversos tipos de collections. Estas collections são responsáveis por agrupar e organizar grandes quantidades de dados.

• ArrayList é mais simples, flexível, aceita qualquer tipo de objeto;
• Hastable por padrão é mais rápida para grandes quantidades de dados;
• ListDictionary é mais rápida para pequenas quantidades de dados;
• HibridDictionary é a mais rápida;

ArrayList

• Encontra-se no namespace System.Collections;
• ArrayList é uma coleção sem tamanho fixo, não ordenada e que aumenta conforme a necessidade do programador;
• É possível adicionar qualquer tipo objeto na ArrayList, desde int, stringat é objetos de classes que você mesmo tenha
• Criar uma ArrayList é muito simples. Ela é instanciada como
• um objeto qualquer.
• Existem duas maneiras de se adicionar itens em uma ArrayList. A primeira é utilizando os métodos Add(object item), para adicionar apenas um valor, e AddRange(object lista), para adicionar vários itens, que normalmente vem de uma Arrayou de outra collection.

ArrayList alist= new ArrayList();

• O método AddRange() aceita adicionar itens de qualquer objeto que suporte a interface ICollection.
• Os métodos Add() e AddRange() adicionam itens na última posição da ArrayList.
• Para adicionar um ou vários objetos em uma posição específica da ArrayListutilize o método Insert(int index,object objeto)
• Para adicionar para vários itens utilize InsertRange(int index,
• object lista).

Existem ainda outros métodos que podem ser úteis:

• IndexOf(object item), que retorna o índice do objeto passado como parâmetro;
• Contains(object item), que verifica se o objeto existe na lista. Se existir, retorna True;
• Clear(), que apaga todos os itens da lista;
• Sort(), que ordena a lista;
• Count(), que retorna o número de itens na lista.

 

Todas as linguagens da plataforma .NET possuem os mesmos tipos primitivos, podendo ter nomes diferentes, mas a mesma estrutura.

O CTS (Common TypeSystem) define quais tipos a plataforma .NET possui, como eles são declarados, usados e gerenciados em tempo de execução.

CTS (Common Type System)

É a definição de tipos de dados onde tudo é um objeto e deriva da classe System.Object, que é o núcleo do sistema de tipos. Pensando que tudo é um objeto, logo tudo deriva da classe System.Object e, por isso, os projetistas da .NET organizaram o sistema de tipos de dados de duas formas:

· Tipos Valor: variáveis deste tipo são alocadas na pilha e têm como classe base System.ValueType, que por sua vez deriva da System.Object.

· Tipos Referência: variáveis deste tipo são alocadas na memória heap e têm a classe System.Object como classe base.

Tipos por Valor

São variáveis que contém seus dados diretamente instanciados em vez de conter uma referência aos dados. Os tipos por valor são armazenados em uma área da memória chamada pilha em vez do Heap, ou seja, estão acessíveis mais rapidamente pelo código em execução. São os tipos mais simples que existem no .NET Framework e incluem todos os tipos de dados numéricos, booleanos, Char e Date, estruturas e enumeration.

Tipos gerais :

• Built-in
• User-defined
• Enumerations

Cada um desses tipos derivam do System.Value

Built-in

Quando você atribui tipos por valor entre variáveis, os dados são copiados de uma variável para outra e armazenados em dois locais diferentes na pilha. Mesmo que tipos por valor representem freqüentemente valores simples, funcionam ainda como objeto, ou seja, você pode chamar métodos neles. Um fato comum é chamar o método ToString ao indicar valores como texto. ToString deriva do tipo fundamental System.Object.

Como declarar tipos por valor

Tipos por valor possuem construtores implícitos, você não precisa incluir a palavra chave new, o construtor tem valor default igual a null ou 0.

//C#

bool b = false;

int x = 0;

O Nullable é um novo tipo no .NET 2.0, chamado de Tipo por valor nulo, ele permite criar variáveis de Tipos de Valor que aceitam valores nulos. Exemplo, se você estiver armazenando dados de um formulário de perguntas sim/não e o usuário ao responde a pergunta, você deve armazenar um valor nulo. O seguinte código permite que uma variável booleana seja verdadeira, falsa ou outra:

//C#

Nullable <int> x = null;

Ou ainda:

int? x = null;

Desta forma evitamos o (mais que) comum erro “Cannot convert null to 'int' because it is a value type”. Ao declararmos uma variável como Nullable torna disponíveis os membros HasValue e Value, que tornam possível determinar se esta variável tem um valor nulo e, no caso de não ter, ler o seu valor.

if (x.HasValue) // Boa, o valor de x não é nulo!

      Console.WriteLine(“O valor de x é {0}”), x.Value);

else // Ooops, o valor de x é nulo!

      Console.WriteLine(“x é nulo!”);

Como criar um User-Defined

User-defined são chamados de structures ou simplesmente struct. Comportam-se semelhantes as classes, mas ao invés de gerar tipos por referência como as classes, geram tipos por valor. Podem ter os mesmos membros que as classes, só não podem ter herança. São criadas como as classes, porém precisam da palavra chave em C# struct, em VB structures.

//C#

//Exemplo1

struct Pessoa
{
  public string Nome;
  public string Endereco;

public int Idade;
}

//Exemplo2

struct SerHumano

{

public float altura;

public float peso;

public short idade;

public SerHumano (float _altura, float _peso, short _idade)

{

altura = _altura;

peso = _peso;

idade = _idade;

}

public override string ToString()

{

return “Este Ser Humano mede “ + altura + " m, pesa " + peso + " kg e tem " + idade + “ anos.”;

}

}

Como criar Enumeration

Enumerations são símbolos relacionados que tem valor fixo. Use enumerations para prover uma lista de escolhas para usar no desenvolvimento de suas classes.São criadas com a palavra chave enum, seguido de um nome e ,entre chaves, no bloco de código da enumeração, os valores pré-definidos para ela separados por vírgula. Por exemplo:

C#

//Declaração do enum

enum Dias

{

Segunda,

Terça,

Quarta,

Quinta,

Sexta,

Sábado,

Domingo

};

A utilização do enum segue a regra NomeEnum.Valor, por exemplo, Dias.Segunda, Dias.Domingo.

Tipos por referencia

Os Tipos por Referência armazenam o endereço da sua informação na stack e também são conhecidos como apontadores (pointers). E o que quer isto dizer? Quer dizer que os dados propriamente ditos estão armazenados na heap, mas existe uma referência à sua localização na stack (um apontador),  uma área da memória que está acessível mais rapidamente pelo código em excução..

O ambiente de execução gerência a memória armazenada na heap utilizando um processo denominado Garbage Collection (“Coletor de Lixo”), que consiste em ir liberando a memória periodicamente, com a eliminação de objetos à medida que estes deixam de ser referenciados.

Existem aproximadamente 2500 tipos de referência feitos para .NET Framework. Os Tipos por Referência abaixo são os mais comuns, sendo que muitos outros Tipos por Referência derivam destes:

· System.Object. Este é o tipo mais genérico existente na .NET Framework. Qualquer tipo pode ser convertido para este Tipo.

· System.String. Este é um dos tipos mais utilizados na .NET Framework e serve para armazenar dados de texto.

· System.Text.StringBuilder. Armazena dados de texto de uma forma dinâmica.

· System.Array. É utilizado para arrays de dados sendo a classe base para todos os arrays.

· System.IO.Stream. Trata-se de um buffer para operações de Input/Output de ficheiros, dispositivos e rede. Trata-se de uma classe base abstracta.

· System.Exception. É utilizada para tratar excepções. Esta classe gere sobretudo excepções de Sistema, sendo que excepções específicas de tarefas em execução herdam deste tipo.

Strings

Tipos são mais que apenas container para dados, eles fornecem meios para manipular dados através seus membros. O System.String fornecem membros para trabalhar com textos.

Como criar e organizar Arrays

Arrays são declarados utilizando parênteses (VB) ou colchetes (C#). String.Array fornece membros para trabalhar com dados. Por exemplo

//C#

//Declarando e inicializando array

int[] vet= {3,1,2} ;

//Ordenando o array

Array.sort(vet);

Como usar Streams

Streams são outro tipo muito comuns porque eles são meios para ler e escrever no disco e comunicação através da rede. Por intermédio das streams é possível transportar dados como voz, vídeo, imagem, entre outros. As streams suportam leituras e escritas síncronas e assíncronas.O tipo System.IO.Stream é tipo base para todo stream.

As classes mas simples do stream são StreamReader e StreamWriter que permitem ler e escrever textos em arquivos. Você pode passar um nome de um arquivo como parte de um construtor permitindo que você abra um arquivo com uma simples linha de código. Depois que você processar o arquivo chame o método Close para fechá-lo.

Existem vários tipos de streams:

·         FileStream, para ler e escrever a partir de arquivo.

·         MemoryStream, para ler e escrever a partir da memória.

·         StreamReader, para ler dados de uma stream.

·         StreamWriter, para escrever dados para uma stream.

//C#

//Criando e escrevendo para um arquivo de texto

StreamWriter sw= new StreamWriter(“text.txt”);

sw.WriteLine(“Hello, Wolrd !!”);

sw.Close();

//Ler e mostrar um arquivo texto

StreamReader sr = StreamReader(“text.txt”);

Console.WriteLine(sr.ReadToEnd());

Sr.Close();

Conversões entre tipos

Conversões entre tipos é uma das tarefas mais comuns em programação orientada a objetos. Várias vezes é necessário converter uma variável de um tipo para outro antes de a passar como parâmetro de um método ou para executar determinado cálculo.

Existem dois tipos de conversões: implícitas e explícitas. Em C# só é possível efetuar conversões implícitas entre tipos se não existir perda de precisão. Isto significa que é possível efetuar conversão implícita em C# se, e somente se o tipo de destino puder aceitar todos os valores possíveis para o tipo de origem. Isto é denominado de conversão generalista (widening conversion):

int i = 1;

double d = 1.0001;

d = i; // Conversão implícita permitida

Se o campo de conversão ou precisão do tipo de origem excede o do tipo de destino, a operação denomina-se de conversão de estreitamento (narrowing conversion) e normalmente necessita que a conversão seja explícita. Existem várias formas de realizar uma conversão explícita:

·      System.Convert: Converte entre tipos que implementem o Interface System.IConvertible;

·      (tipo)cast: Converte entre tipos que definem operadores de conversão;

·      tipo.ToString e tipo.Parse: Converte entre objectos do tipo string e objetos de tipos base. Se a conversão não for possível, a operação resulta numa exceção;

·      tipo.TryParse e tipo.TryParseExact: Converte entre um objeto do tipo string e um objeto de um tipo base. Se a conversão não for possível, devolve um valor false;

Os métodos TryParse, TryParseExact e TryCast são novos na .NET Framework 2.0. Conversões explícitas falham se o valor de origem exceder o campo de valores aceitos pelo tipo de destino ou se a conversão entre os tipos não estiver definida, por isso este tipo de conversões deve ser incluído entre blocos Try ou utilizando os métodos TryCast ou TryParse para ser possível verificar o valor de retorno.

Boxing e Unboxing

Numa linguagem totalmente orientada a objeto, tudo seria objeto inclusive tipos simples que não precisam de tanto overhaed nade memória. Caso precisássemos somar dois números em uma linguagem totalmente orientada a objeto, precisaríamos criar um objeto que representasse o primeiro número , outro que representasse o segundo número e outro que representasse o resultado da soma. Seria gasto assim muito processamento para uma operação simples.

Em C# o uso de boxing e unboxing buscam resolver esse problema, deste modo ocorre transformações automáticas de tipos durante o processo. Boxing converte de tipo por valor para tipo por referência automaticamente, já o unboxing é o processo de volta.

Boxing

Neste processo ocorre que um novo objeto é alocado na memória e o valor da variável é copiado para ele, ou seja, pegamos o tipo por valor e colocamos dentro de um novo objeto. A partir desse momento podemos usar o nosso tipo por valor como um tipo por referência.

Unboxing

O unboxing trás de volta o tipo por valor, funcionando como se tivéssemos retirado o envoltório da nossa variável e a deixássemos apenas com o seu valor.

As operações de Boxing e Unboxing implicam um acréscimo de processamento,por isso devem ser evitados quando se programam tarefas que se repetem de uma forma intensa. Boxing também ocorre quando são chamados métodos virtuais de uma estrutura que herde de System.Object como, por exemplo, o método ToString().

Tabela de Conversão de tipos

 

Características

• Orientada a Objetos
• Estruturação em blocos
• Instruções são separadas por ‘ ; ’
• Comentários de uma linha com: ‘ // ’
• Comentários de mais de uma linha entre ‘ /* ’ e ‘ */ ’
• Documentação XML: ‘///’
• Case Sensitive

Tipos de dados

Operadores

Sintaxe

• Para ajudar a migração entre as linguagens do .NET,existem os Code Snippets (IntelliSense);
• Os Code snippets (fragmentos de código) do IntelliSense constituem uma das novas características do Visual Studio 2005. Code snippets podem ser personalizados de várias formas e foram idealizados para realizar rapidamente tarefas, desde as mais simples até as intermediárias. Podemos rapidamente inserir trechos de código prontos, bastando pressionar algumas teclas. Por exemplo, existem estruturas prontas para as principais construções da linguagem usada, como um bloco Select Case. Ou mesmo para realizar tarefas comuns do desenvolvimento, como ler um arquivo.
• São estruturas de como implementar por exemplo,um forou uma exception;
• É possível você criar os seus próprios Snippets.

Declaração de Classes

classPorta{

...

}

Declaração de Objetos

Portaporta = newPorta();

Exceptions

• Analisa e trata exceções (não necessariamente é um erro) do fluxo normal do processo.
• Erros são vistos como objetos.
• Mensagem de erro: referencia a classe que gerou o erro e o caminho até o erro.
• Bloco Try: tenta executar o código, se houver algum erro executa o Catch.
• Bloco Catch: trata o erro.
• Finally: executa sempre mesmo com erro ou não.
• Throw : cria uma instância para um erro, cria condições, regras que se foram cumpridas ocasionaram erro.

Try

{

...

}

Catch ( tipo de erro que trata)

{

...

}

Catch ( tipo de erro que trata)

{

...

}

Catch ( Exception ex) //Pega qualquer erro

{

...

}

Herança

• Constrói classes baseadas em classes/interfaces já existentes;
• Polimorfismo.
• Palavras chave :
  • Abstract: Pode ser herdado
  • Virtual: Possibilita a redefinição
  • Sealed: Não pode ser herdado
  • This: Se refere a um elemento da própria classe
  • Base: Se refere a um elemento do pai
  • Override: Redefinição

Interface

• Definem membros comuns para todas as classes que as herdam;
• Permite “herança múltipla”.
• Possui somente métodos abstratos
• Interfaces Comuns :

· IComparable :Interface para tipos que possam ser ordenados

· IDisposable:Interface para tipos que possa se dispor manualmente

· IConvertible:Interface para tipos que possam ser convertidos

· ICloneable:Interface que suporta a copia de um objeto

· IEquatable:Interface que permite comparar instancia de um objeto

por igualdade (if(a==b))

· IFormattable:Interface que habilita converter o valor de um objeto para uma string formatada. Mais flexivel que o método ToString()

Partial Class

• Permite dividir a definição de uma classe (linha de código) em diversos arquivos;
• Windows Form: Form1.cs e Form1.Designer.cs.

Generics Class

• Permite definir uma classe sem especificar o tipo dos parâmetros ou o tipo dos membros da classe;
• Acaba com a necessidade de Boxing e UnBoxing;
• Boxing = transforma um tipo por referência em um tipo por valor;
• Unboxing = transforma um tipo por valor em um tipo por referência ;
• Para criar um objeto da classe genérica:

class Generic<T, U>

{

private T t;

private U u;

public Generic(T t, U u)

{

this.t = t;

this.u = u;

}

}

Generic<int,float> gen = new

Generic<int,float>(3, 4.5f);

Conversão

• Utilizando “cast”

doublenum1 = 10.2;

intnum2 = (int)num1;

• Utilizando “Convert”

doublenum1 = 10.2;

intnum2 = Convert.ToInt32(num1);

• Utilizando a conversão de classes específicas

stringnum1 = “32”;

intnum2 = int.Parse(num1);

 

O que é . NET?

É uma plataforma, não uma linguagem, que visa o desenvolvimento e execução de sistemas e aplicações. Todo e qualquer código gerado em .NET, pode ser executado em qualquer dispositivo ou plataforma que possua o .NET Framework.

Vantagens do .NET

· Conjunto rico de bibliotecas com os mais variados usos;

· Controle de versão: fim do “DLL Hell”;

· Facilidade de desenvolvimento de aplicações ;

· Facilidade na instalação e na distribuição de aplicações;

· Orientada a objeto;

· Alta escalabilidade para ambientes de missão crítica;

· Interoperabilidade entre plataformas e componentes desenvolvidos em outras linguagens .NET;

· Tecnologia baseada em máquina virtual;

· Rotina automática de “coleta de lixo” que permite remoção de variáveis e objetos que não são mais utilizados;

· Novo ambiente de desenvolvimento acelerado (RAD);

Desvantagens do .NET

• É um novo paradigma, e requer aprendizado de novas técnicas;
• Requer a distribuição do Framework;
• Em alguns casos de migração, requer reengenharia ou reescrita completa do código. Por exemplo, a implementação de estrutural para OO é um pouco mais complicada;

A plataforma .NET é executada sobre uma CLR (Common Language Runtime) que interage com uma coleção de bibliotecas unificadas, que juntas formam o próprio framework. Esta CLR é capaz de executar, diferentes linguagens de programação, interagindo entre si como se fossem uma única linguagem.

Múltiplas linguagens de programação

• Compilação de uma linguagem para código intermediário;
• O código intermediário é comum para a plataforma .NET;
• Possibilidades: VB.NET, C#, J#, Pascal (Delphi), Perl, Python, Cobol …

Coleta de lixo

• Mecanismo de limpeza e desalocação de memória ;
• Limpa as informações que não estão sendo mais chamadas;
• Destrói e limpa automaticamente objetos que saíram de referência;
• Termina com o problema da referência circular (Um chama outro e ninguém deste ciclo consegue chamar);
• Termina com problema de objetos órfãos que ocupam memória.

Orientado a objetos

• Uso real de herança, polimorfismo e sobrecarga;
• Fácil extensão de funcionalidades;

Fim da “DLL Hell”

• O problema
• Problemas de versões de DLL: aplicações deixavam de funcionar ao atualizar versões;
• Difícil de rastrear modificações quando é necessária a instalação de muitos programas.

• A solução
• Versões diferentes de um mesmo .dll podem está numa pasta específica do Windows
• As DLLs podem ser compartilhadas ou podem ser apenas copiadas para uma pasta;
• Versão e assinatura: DLLs podem ter o mesmo nome,versões diferentes e rodar lado-a-lado.

Plataforma .NET – Funcionamento e Arquitetura

Para permitir uma maior integração entre as linguagens que suportam a plataforma .NET, foi criado o CLS (Common Language Specification). O CLS é uma especificação comum que contém as funcionalidades básicas necessárias para as linguagens, ou seja, a CLS define funcionalidades que todas as linguagens possuem.

Uma linguagem para ser considerada dentro da plataforma deve aderir as especificações da CLS e CTS. Assim ela poderá ser “nomeada” como X.NET.

Funcionamento - Processo de compilação

Na plataforma .NET o código é duplamente compilado:

Primeira compilação

Ao compilarmos nosso código para gerar uma DDL, ou um arquivo EXE, o compilador da linguagem em que trabalhamos é chamado e este transforma nosso código em uma linguagem chamada MSIL (Microsoft Intermediate Language), esta linguagem é semelhante ao Assembly x86. Qualquer código compilado em .NET é chamado de assembly.

Segunda compilação

A segunda compilação é feita no momento em que o aplicativo é executado pela primeira vez ou quando sua DLL é referenciada pela primeira vez. O .NET Framework, através do CLR(Common Language Runtime) chama o compilador Just-in-Time (JIT compiler) que compila o código MSIL em código nativo do computador. O JIT compila o código sob demanda e joga o código resultante em cache, de forma que esse código não precise ser recompilado quando houver uma nova invocação do mesmo método.

Percebemos então que não importa se o MSIL veio de C#, VB.NET ou de COBOl já que é a mesma linguagem(MSIL). Uma observação importante é que C++ nos permite compilar diretamente para a arquitetura que queremos e pular todos os de MSIL e JIT

O JIT compila para o processador, vista disso podemos dizer que há um ganho de performance, visto que ele gera o cógido para a arquitetura especifica, assim não teremos problemas com diferentes versões de processadores.

Arquitetura

Common Language Runtime (CLR)

É o ambiente de execução das aplicações .NET, a base de toda arquitetura da plataforma. Funciona como uma aplicação em plano de fundo que gerencia, aloca e desaloca memória, carrega os APIs necessários e executa o código. O CLR cuidará do gerenciamento de memória através do Garbage Collector.

Abriga o JIT Compiler um componente que interpreta a IL e gera a linguagem de máquina na arquitetura do processador. Sem o CLR não há execução do código .NET por isso é necessário a instalação do .NET Framework.

.NET Class Library

Conjunto de funcionalidades prontas para facilitar o desenvolvimento e evitar reescrita de código. Na Class Library temos as APIs (Application Programming Interface ou Interface de Programação de Aplicativos ) para acesso a Banco de Dados (ADO.NET), programação para Web (ASP.NET), segurança, comunicação, etc. Para permitir uma melhor organização do código a Class Library é toda organizada em namespace. Segue no Anexo1 Principais Namespaces do .NET Class Library

 

Class Library Support

Faz a integraçãocom a .NET Class Library

Thread Support

Fornece classes e interfaces para a ultilização de thread

COM Marshaler

Permite que objetos COM sejam usados em .NET e vice-versa

Type Checked

Não permite casts inseguros. Fortemente tipado

Exception Manager

Security Engine

Debug Engine

Permite debug e tracing

IL to Native Compilers

Converte MSIL para código nativo (compilação JIT)

Code Manage

Gerencia a execução do código

Garbage Collector

Gerencia o tempo de vida dos objetos, apagando da memória objetos que não são mais importantes

Class Loader:

Carrega os componetes que serão usados na memória e gerencia meta-dados

Namespace : Organização lógica do código do sistema, permite que o código seja dividido em partes para melhor compreensão da aplicação. Vale salientar que a organização é lógica e não física, podemos ter um sistema todo em um único assembly, mas com vários namespaces no mesmo arquivo ou até mesmo um único nmamespace dividido entre vários assemblies. Com o uso do namespace podemos, por exemplo, colocar todo o código rede referente a interface gráfica em um um namespace chamado “GUI”, outro namespace pode conter todo o código refrente ao acesso ao bando de dados, chamando-o de “Dados”.Toda .NET Class Library está organizada em namespaces hierárquicos. O namespace principal é o System, que contem tipos primitivos da linguagem, funcionalidades que nos permite ler e escrever na tela, converter tipos, etc.

CTS (Common Type System)

É a definição de tipos de dados onde tudo é um objeto e deriva da classe System.Object, que é o núcleo do sistema de tipos. Pensando que tudo é um objeto, logo tudo deriva da classe System.Object e, por isso, os projetistas da .NET organizaram o sistema de tipos de dados de duas formas:

• Tipos Valor: variáveis deste tipo são alocadas na pilha e têm como classe base System.ValueType, que por sua vez deriva da System.Object.
• Tipos Referência: variáveis deste tipo são alocadas na memória heap e têm a classe System.Object como classe base.

-- System.Object
--Tipos valor
------ Estruturas
------ Tipos Enumerados
-- Tipo Referência
------ Objeto
------ Interface
------ Ponteiros

CLS (Common Language Specification)

Define um conjunto de regras que as linguagens que implementam a .NET devem seguir para que a CLR possa gerar a IL. Esse é um dos motivos de podermos criar sistemas em diferentes linguagens e interagir entre elas dentro da .NET. No momento da compilação é gerado um código único intermediário (IL) e todas essas linguagens suportadas pela .NET seguem as regras da CLS, para que depois de gerado a IL, ela seja interpretada corretamente pela CLR, como já dito acima.

VES (Virtual Execution System )

É um processo de compilação e é aqui onde o JIT é ativado quando uma aplicação .NET é chamada. O Windows identifica que esta é uma aplicação .NET e uma runtime Win32 passa o controle para a runtime do .NET. Neste momento a compilação do Portable Executable é efetuada e só então o código assembly próprio da arquitetura do processador é gerado para que a aplicação possa ser executada.

Portable Executable
Isto significa que o fonte gerado poderá ser interpretado (executado) em qualquer plataforma que tenha suporte .NET, sem necessidade de recompilação do fonte.

 

Principais Namespaces do .NET Class Library

Namespace

Descrição

System

Este namespace é a raiz dos tipos de baixo-nível requerido pelo .Net Framework. Contém classes fundamentais e básicas que definem valores e referências de tipos de dados usados rotineiramente, além de processamento de exceções, interfaces e eventos.

System.CodeDom

Namespace que contém classes que podem ser utilizadas pra representar os elementos e estruturas de um documento de código-fonte.

System.Collections

Possui interfaces e classes que definem várias coleções de objetos, como listas, filas, array de bits e também dicionários.

System.ComponentModel

Este namespace possui classes que são usadas para implementar o comportamento do ambiente de tempo de execução e tempo de design de componentes e controles.

System.Configuration

Fornece classes e interfaces que permitem o acesso programático às configurações do .Net Framework e manipular erros nos arquivos de configuração.

System.Data

Namespace que contém classes necessárias para acessar e manipular banco de dados.

System.EnterpriseServices

Namespace que fornece uma infra-estrutura importante para aplicações da empresa. O COM+ fornece uma arquitetura dos serviços para os modelos de programação do componente distribuído em um ambiente de empresa. O principal objetivo do namespace é fornecer objetos .Net e o acesso aos serviços do COM+, tornando os objetos .Net mais práticos para aplicações da empresa.

System.Globalization

Namespace com classes que definem informação relacionada à cultura, incluindo a linguagem, o país, a região, os calendários em uso, os padrões de formatos de datas, moeda corrente, números e ordens para ordenção de strings.

System.IO

Neste namespace temos classes responsáveis para a leitura e gravação de arquivos.

System.Messaging

Fornece para o programador classes que aceitam que você se conecte, monitore e administre as filas de mensagem na rede, além de enviar, receber e resgatar mensagens.

System.Net

Namespace que fornece uma simples interface de programação para diversos protocolos utilizados em rede atualmente, assim você pode desenvolver aplicações que usem recursos de internet sem se preocupar sobre os detalhes específicos de protocolos individuais.

System.Reflection

Contém classes e interfaces que fornecem uma visão gerenciada dos tipos, métodos e campos com a habilidade para dinamicamente criar e invocar tipos.

System.Resorces

Importante namespace que fornece classes que permitem ao programador ou desenvolvedor criar, gravar e gerenciar recursos utilizados na aplicação.

System.Security

Fornece a estrutura subjacente do sistema de segurança do CLR, incluindo classes bases para permições.

System.Threading

Contém classes que permitem a implementação de multithreading dentro de suas aplicações.

System.Timers

Fornece um componente Timer que permite a você disparar um determinado evento em um intervalo de tempo especifico.

System.Web

Fornece classes e interfaces que permitem a comunicação cliente, que se dá através do browser, e servidor, que se da através do servidor IIS. O namespace ainda fornece diversas outras classes com diversas características.

System.Windows.Forms

Namespace que contém classes capazes de criar aplicações baseadas em Windows que podem utilizar a vantagem da disponibilidade de funcionalidades para aplicações com clientes.

System.XML

Fornece suporte para a utilização de arquivos ou objetos XML.

System.Drawing

Namespace que fornece funcionalidades da GDI+ e fornece classes que facilitam a renderização de gráficos.

 

Pessoal, a partir de hoje estarei postando os assuntos vistos no Curso de C# básico da Poli.

Atencisamente,

Ana Carolina Lima

Faz tempo que não posto algo, mas assim que tudo ficar mais calmo postarei com maior frequência. Inspirada no post de Waldyr que li hoje pela manhã queria falar  sobre o Curso de C# que ministraremos na POLI.

Copiando e colando do post dele:

O curso terá 30h de duração e serão abordados assuntos como funcionamento do Framework .NET, Orientação a Objetos com C# e Windows Forms.

A grade do curso que será ministrado em duas semanas (de 7 à 18 de janeiro) pode ser encontrada em detalhes no site da POLI Junior:

http://www.polijunior.poli.br/

Assim como ele disse estamos trabalhando fortemente para fazer um excelente curso, os alunos elaborarão um projeto no final do curso e com o patrocinio da Soft.NET teremos premiações para os melhores projeto. Recomendo a todos.

Aviso a todos os participantes da célula acadêmica Soft.NET

Prezados,

Informo que a célula entrará em recesso devido as provas que serão realizadas a partir desta semana.
Em 2007 inauguramos a célula, muitos de nossos membros participaram com um excelente desempenho do Proform repetindo-se agora no Student To Buniess. Dois membros conseguiram tirar certificação da Microsoft. Criamos grupos de estudos de XNA, Mobile e ASP.NET. Conseguimos apoio da Universidade que efetuou a instalação do Visual Studio nos laboratórios. Tivemos uma série de eventos com palestras técnicas, contamos com a presença de palestrantes como André Furtando, Diogo Burgos, Marcelo Diniz, Fabiano Arruda, Edgar Figueredo, entre outros. Estamos formando equipes e estudando a idéia de participar da Imagine Cup como também damos suporte a quem deseja participar.

Encerramos esta etapa de 2007 com muitos avanços. Neste recesso aproveitaremos para reformular algumas coisas, como também estabelecer as metas para 2008.

Espero que todos aproveitem as férias para aprofundar seus conhecimentos na plataforma.

Retomaremos nossas atividades com o evento de boas vindas chamado .NET Day que ocorrerá em 2008.

Atenciosamente,
Ana Carolina Lima
Líder - Soft.NET

 

Foi com grande satisfação que vi este artigo no SharpGames "Aplicando Equacao do Primeiro Grau em Jogos com XNA". Queria parabenizar Luciano por esta iniciativa e por seu estudo e desempenho admirável em XNA, ele realmente inspira a todos da célula falando sobre as competições hehehehhe. Espero pode ver mais e mais artigos não só dele mas de todos da célula, fica ai meu recado.

Link para o artigo: http://www.sharpgames.net/Artigos/Aplicando+Equacao+do+Primeiro+Grau+em+Jogos+com+XNA.xna

Até mais pessoal, férias tão chegando vou poder postar mais !!!

A Partec, o grupo Sharp Shooters .NET e a Poli-UPE apresentam evento inédito em Recife focado em Windows Media Center, uma das apostas da Microsoft para a iminente era da TV Digital.

 

Dia: 20/11

Horário: 16:30 às 18:30

Local: Auditório da escola Politécnica da UPE

Link para inscrições: http://msevents. microsoft. com/CUI/EventDet ail.aspx? EventID=10323598 51&Culture=pt-BR

Orientações e detalhes: http://www.partecwe b.com.br/ wmc/

 

Palestras:

 

Oportunidades de Mercado com Windows Media Center

Nesta palestra, vamos apresentar para desenvolvedores de software e provedores de conteúdos as oportunidades de criação de soluções que interagem com a TV por meio do Windows Media Center, bem como sua integração com as tecnologias de TV Digital em implantação no Brasil.

 

Palestrante: Gustavo Andrade é gerente de projetos da Partec, mestre e bacharel em Ciência da Computação pela UFPE e campeão nacional da competição Microsoft Imagine Cup 2005. Desde 2006, trabalha com o desenvolvimento de software para TV, com aplicações que variam de serviços bancários a entretenimento digital.

 

Desenvolvendo Aplicações em Media Center Markup Language

Nesta palestra, vamos apresentar o Media Center Markup Language (MCML), linguagem de apresentação do Windows Media Center específica para a criação de interfaces ricas na TV e demonstrar sua utilização prática para a criação de um leitor de blogs na televisão.

 

Palestrante: Átila Bezerra é engenheiro de software da Partec no projeto MyTV e mestrando em Ciências da Computação pela UFPE. Desde 2005 atua em projetos de TV Digital, com tecnologias do SBTVD e de IPTV, tendo trabalhado com empresas como o Cesar e a Motorola.

 

O evento é gratuito. Colabore trazendo 1kg de alimento não perecível.

 

Fiquei pensando o que poderia postar nesse espaço e pensei muito muito, cheguei até a fazer um esboço do que queria falar em "Passos para uma cerificação", mas acabei não conseguindo postar nada, sou meio que reservada mas de tanto falarem acredito que deva falar um pouco sobre isso. Enfim para os que não sabem e também para os que sabem consegui tirar minha primeira certificação agora sou MCP. Tudo comçou a um tempo atrás quando minha irmã do nada veio me falar sobre um tal de Proform, encarei o desafio e fui fazer. Cada semana era uma prova e várias pessoas eram desclassificadas e eu continuava, foi um caminhoo meio que longo (A AESO é meio longe hehehehe) mas cheguei ao fim e pude então fazer minha prova de certificação. Como uma tipica brasileira fui estudar praticamente faltando uma semana para fazer a prova e realmente não acreditava que poderia passar mas me esforcei muito pois queria pelo menos ter a sensação que "fiz minha parte". E então encarei a prova e passei,  veio aquela sensação de dever cumprido misturado com um cansaço e felicidade. Mas valeu muito a pena. Agora é continuar a caminhada...

Pessoal, to meio sumida mas é que está tudo muito corrido devido a 1° Semana de Informática (SIC) realizada na Católica, como estou ajudando  na Exposição (Museu) dos Computadores, tive que me ausentar um pouco dos blogs, visual studio hehehheeh. Para manter as coisas devidamente atualizadas vai demorar um pouco mas vou fazer, acredito que deva dedicar um post sobre minha certificação, para quem não sabe conseguir tirá-la agora sou MCP hehheehhehe olha o bolado :P vou dedicar um post também a essa exposição super interessante que estamos fazendo na  Católica. Então acredito que daqui a umas duas semanas este espaço estará atualizado.

 

Dando continuidade as palestras tivemos nesta terça (09/11) Roberto Medeiros, engenheiro de software da Inove Informática, falando sobre LINQ( Language Integrated Query ). Não vou poder postar muita coisa sobre a palestra porque infelizmente estaja numa reunião gerencial da célula e não pude acompanhá-la até o fim, mas o pouco que vi foi sufiente para perceber a série de facilidades que essa nova tecnologia vai nos proporcionar.

 

(1) Roberto apresentando LINQ                                    (2) Pessoal conhecendo LINQ

(3) Pessoal ainda conhecendo LINQ                               (4) Tentando usar o temporizador da máquina deu trabalho heheheh

 

Mais informações sobre LINQ acessem o seguinte endereço http://msdn2.microsoft.com/en-us/netframework/aa904594.aspx

A partir do dia 15 de outubro, estão abertas as inscrições para o Student to Business, da Microsoft Brasil. O programa gratuito oferece treinamento em tecnologia da informação a estudantes do ensino médio, técnico e universitários.

Os cursos de especialização são oferecidos em dez Estados do Brasil e irão capacitar os participantes em infra-estrutura e desenvolvimento, além de ensiná-los a usar a tecnologia da empresa.

A plataforma .NET e a Microsoft Solutions Framework são exemplos do que os interessados conhecerão nas aulas voltadas a desenvolvimento. Os que buscam se especializar em infra-estrutura serão capacitados em administração de redes e no Windows Server 2003.

O programa ocorre em três etapas - a primeira é básica e as outras são voltadas à área de interesse. Ao final das duas primeiras fases são feitos testes para avaliar se o participante continuará o treinamento.

As inscrições devem ser feitas pelo site http://www.centrodeinovacao.org.br/