DotNet Framework e Orientação a Objetos 1 - Introdução

Framework .Net e Orientação a Objetos 1
Introdução
(Baseado na Certificação Microsoft)

Geração TEC – Talentos empreendedores para o
mundo da tecnologia

Lorival Smolski Chapuis

Agenda geral
• Introdução a plataforma .Net
• Primeiros princípios de código limpo
• Fundamentações do .Net Framework
– Tipos por valor e referência
– Manipulando sistemas de arquivos
– Manipulando Strings
– Expressões regulares
– Coleções e princípios de lambda
• Introdução a Orientação a objetos
– Definição de classe e objeto
– Entendendo métodos e propriedades
• Práticas de Coding Dojo
– Revisão linguagem C#
– Novas práticas aprendidas
• Utilização do gerenciador de código fonte GitHub e desenvolvimento
orientado a testes.

Agenda: Aula 1 - Terça-feira
• Plataforma .Net
– Histórico
– Arquitetura
– Vantagens
– Aplicações
– Projeto Mono
– Curiosidades
• Revisão geral
– Visual Studio: Criação de projetos / dependências
– Linguagem C#: Estrutura de decisão / Estrutura de repetição /
Variáveis, constantes e enumeradores/ Funções, vetores e matrizes
• Coding Dojo – Apresentação feita para Udesc
• Princípios de desenvolvimento orientado a testes
• Prática de Coding Dojo

Agenda: Aula 2 - Quarta-feira
• Desenvolvimento prático de uma calculadora.
– Aplicar desenvolvimento orientado a testes.
– Aplicar ideias de código limpo.
– Criação de 3 projetos:
• ClassLibrary
• Testes
• WindowsForm

• Objetivo principal: conhecer o que veremos e como faremos algumas
atividades daqui para frente.

Agenda: Aula 3 – Quinta-feira
• Código limpo
– Discussões sobre código limpo
– O que é um código limpo?
• Princípios de código limpo
– Nomes significativos
– Valores por tipo
– Definição de classe e objetos
• Exercícios dirigidos

Agenda: Aula 4 – Sexta-feira
– Valores por referência
– Convertendo entre tipos
– Comentários

• Início do desenvolvimento da lista de exercícios
– Desenvolver somente a parte de processamento, ou seja, não é
necessário NESTE MOMENTO fazer a parte de tela pois estaremos vendo
isto mais a frente;
– Preferencialmente fazer em duplas;

Agenda: Aula 5 – Segunda-feira
– Tipos Nullable
– Navegando pelo sistema de arquivos
• Feedback da semana

Agenda: Aula 6 – Terça-feira
• Discussões sobre o curso
• Gerenciador de fontes GitHub

Agenda: Aula 7 – Quarta-feira
• Usando GitHub
– Manipulando sistema de arquivos

Agenda: Aula 8 – Quinta-feira
• Manipulação de Strings
– Concatenação
– StringBuilder
– StringFormat

Agenda: Aula 9 – Sexta-feira
• Tempo para desenvolvimento da lista de exercício.
• Auxílio nos desenvolvimentos.
• Revisão de assuntos que ficaram com dúvidas.

Agenda: Aula 10 – Segunda-feira
• Expressões regulares: introdução
– O que são
– Como criá-las e manipulá-las
– Como utilizar expressões regulares em C#
• Revisão e dúvidas

Agenda: Aula 11 – Terça-feira
– Introdução a coleções
– Introdução a expressões lambdas aplicado a coleções
• Revisão da semana e feedback

Requisitos para próximas etapas
• Criar uma conta no GitHub: http://www.github.com
– Criem um usuário com um nome expressivo e guardem a senha =)

Material auxiliar para este módulo

• Livro Programando com C# e
Visual Studio 2005;
• Livro 100% prático;
• Desde declaração de variáveis até
criação de telas WindowsForm.

Framework .Net: Aula 1 - Terça-feira

Agenda
• Plataforma .Net
– Histórico
– Arquitetura
– Vantagens
– Aplicações
– Projeto Mono
– Curiosidades
• Revisão geral
– Visual Studio: Criação de projetos / dependências
– Linguagem C#: Estrutura de decisão / Estrutura de repetição /
Variáveis, constantes e enumeradores/ Funções, vetores e matrizes
• Coding Dojo – Apresentação feita para Udesc
• Princípios de desenvolvimento orientado a testes
• Prática de Coding Dojo

Plataforma .Net - Histórico
O .Net Framework é uma plataforma para desenvolvimento de
aplicações, criada pela Microsoft em 1999 e lançada oficialmente em
2002;

Version Lançamento Visual Studio Windows
1.0 13 de fevereiro de 2002 Visual Studio XP, Tablets
1.1 24 de abril de 2003 Visual Studio 2003 Server 2003
2.0 07 de novembro de 2005 Visual Studio 2005 Server 2003 R2
3.0 06 de novembro de 2006 Visual Studio 2005 Vista, Server 2008
3.5 19 de novembro de 2007 Visual Studio 2008 7, Server 2008 R2
4.0 12 de abril de 2010 Visual Studio 2010 7
4.5 Lançamento oficial previsto final 2012 Visual Studio 2012 8, Server 2012

Plataforma .Net - Arquitetura
– A plataforma .Net disponibiliza uma vasta biblioteca de
funcionalidades e componentes, fornecendo interoperabilidade com
uma gama de linguagens de alto nível;

– O desenvolvedor não se preocupa inteiramente com o dispositivo ao
qual está destinada sua aplicação e sim com a plataforma de
desenvolvimento.

– A interoperabilidade de ambiente é semelhante à plataforma
Java, usando uma máquina virtual independente de
linguagem, chamado Common Language Runtime ou CLR. Em Java é a
JVM.

– Pode ser executada em vários dispositivos atualmente, desde um
smartphone, tablet, Xbox 360, computadores desktops até servidores
dedicados ou não;

– Com isto abstrai do desenvolvedor a necessidade de usar apenas uma
única linguagem, tendo hoje mais de 30 opções, sendo algumas delas
• C#, C++, Boo, F#, COBOL, Fortran, Haskell, Lua, Object
Pascal, Perl, PowerBuilder, Python, Ruby, Smalltalk, Visual
Basic, entre outras.

– As aplicações são duplamente compiladas, sendo uma para uma
linguagem intermediária, Common Intermediate Language (IL) ou
Microsoft Intermediate Language (MSIL), e outra para linguagem de
máquina.

.NET Framework

VB C++ C# JScript ...

Common Type System (CTS)

Visual Studio .NET
ASP .NET: Web Services
Windows Forms
e Web Forms

ADO .NET: Data e XML

.NET Framework Base Class

Common Language Runtime (CLR)

• Código gerenciado (.Net Framework)
– Código Fonte
– Compilador
– Código Intermediário (IL): .DLL ou .EXE
– Requer o ambiente CLR para executar
– Código de Máquina (Binário)

• Código não gerenciado (Específico para o SO)
– Código Fonte
– Compilador
– Código de Máquina (Binário)

Obs: NÃO requer o ambiente CLR para executar

Plataforma .Net – O que é o CLR mesmo?
• O Common Language Runtime (CLR) é o
componente encarregado de gerenciar aplicações
desenvolvidas em .NET.

• O compilador de cada linguagem segue uma série de
especificações, conhecidas como Common Language
Infrastructure (CLI).

• Estas especificações são abertas (ECMA-335, ISO/IEC
23271), assim permitem a interoperabilidade entre
outras linguagens e plataformas.

Plataforma .Net – Como é mesmo?
Código
VB C# C++
Fonte

Componente
Compilador Compilador Compilador
Não Gerenciadol

Código
Gerenciado Assembly - Código IL

Common Language Runtime (CLR)

Compilador JIT

Código Nativo

Serviços do Sistema Operacional

Plataforma .Net – Vantagens
• Interoperabilidade
– Possibilita executar funcionalidades de qualquer linguagem disponibilizada
na plataforma e até fora da plataforma usando acesso COM.
• Portabilidade
– A Microsoft não implementou o .Net para outros Sistemas Operacionais
diferentes do Windows, porém a plataforma foi criada e disponibilizada
para ser possível fazer isso por terceiros.
• Segurança
– Trata algumas vulnerabilidades comuns e fornece um modelo de
segurança para as aplicações.
• Deploy simplificado
– Possui ferramentas que auxiliam na criação de instaladores de acordo com
os padrões e seguranças requeridos, de forma fácil e flexível.
• Biblioteca de funcionalidades comuns
– Existem várias funcionalidades disponíveis independentes da linguagem
que esteja sendo utilizadas, desde manipulação de arquivos, acesso a
base de dados, criptografia, fórmulas matemáticas, processamento gráfico
até gerenciamento paralelo de aplicações.

Plataforma .Net – Aplicações
– Aplicações SmartClient – Aplicações console
– Aplicações Client/Server – Bibliotecas de funcionalidades
– Aplicações web – Extender componentes
– Serviços Web existentes e melhorá-los
– Serviços Windows conforme necessidades
– Aplicações para dispositivos – Criar plugin para o Visual Studio
móveis – Criar aplicações RIA
– Aplicações distribuidas – E várias outras...
– Testes automatizados
– Plugins para aplicações Obs: Para fazer qualquer item acima
Microsoft como Office é necessário ter o Visual Studio
– Aplicações Cloud
– Aplicações baseadas em
Workflow

Plataforma .Net – Projeto MONO
– Mono é uma plataforma open source que implementa os padrões do .Net
Framework definidas na ECMA (European Computer Manufacturers
Association agora Ecma Internacional) para C# e CLR.
– Atualmente o compilador C# tem suporte ao C# 1.0,2.0,3.0 e 4.0 (ECMA).
– Multi-plataformas:
• Linux;
• Microsoft Windows;
• Mac OS X;
• BSD e Sun Solaris;
• Nintendo Wii;
• Sony Play Station 3;
• IOS;
• Android;
– A IDE para desenvolvimento é a MonoDevelop

Plataforma .Net – Curiosidades (C#)
História da linguagem C#
• Foi criado junto com a arquitetura .NET. Embora existam várias
outras linguagens que suportam essa tecnologia (como VB.NET,
C++, J#), C# é considerada a linguagem símbolo do .NET pelas
seguintes razões:
– Foi criada praticamente do zero para funcionar na nova
plataforma, sem preocupações de compatibilidade com
código de legado.
– O compilador C# foi o primeiro a ser desenvolvido.
– A maior parte das classes do .NET Framework foram
desenvolvidas em C#.
• A criação da linguagem, embora tenha sido feita por vários
desenvolvedores, é atribuída principalmente a Anders Hejlsberg.
Anders era desenvolvedor de compiladores na Borland, e entre
suas criações mais conhecidas estão o Turbo Pascal e o Delphi.

Plataforma .Net – Curiosidades: Nome C#
• Muitos pensam que o nome C# viria de uma sobreposição de 4
símbolos "+" dando a impressão de "++++". Na verdade o "#" de C#
refere-se ao sinal musical (sustenido), que aumenta em 1/2 tom uma
nota musical.

• O símbolo real seria o ♯ e não o #, porém, devido a limitação de
telas, fontes e alguns browsers, no momento da normalização junto a
ECMA, fora especificado apenas que o nome da linguagem seria uma
letra C maiúscula (U+0043) e o sinal "#" (U+0023), facilitando
assim, publicações e artigos com um caracter encontrado facilmente
dos layouts de teclado padrões.

• Desta forma, caso o nome fosse usado em português, seria "C-
Sustenido" (ou "Dó-Sustenido"), e não "C-cerquilha".

Plataforma .Net – Curiosidades: Atenções
• Aplicações compiladas diretamente para o Sistema Operacional origem
e sendo não gerenciadas possuem mais desempenho... A pergunta é a
que custo...

• Como as DLLs e EXE são IL, é possível facilmente fazer engenharia
reversa. É necessário usar alguns softwares para dificultar este
processo, quando necessário.

• As versões 3.5 para cima não vem pré-instaladas no SO, ou seja, é
necessário baixar a instalar, tendo que ter alguns cuidados no deploy
de aplicações.

Plataforma .Net – Curiosidades: SO C#?
• Singularity
– Entre 2003 e 2010 o Microsoft Research criou um Sistema Operacional
experimental chamado Singularity desenvolvido em C#.
– Foi desenvolvido o Kernel, device drivers e até um SDK para desenvolvimento de
aplicações que pode ser encontrado no codeplex: http://singularity.codeplex.com/
– Não está mais em andamento, mas serviu de base para várias outros do mesmo
gênero.

• Cosmos C#
– É um sistema operacional open source desenvolvido em C# convertendo as
instruções IL para instruções nativas.
– Suporta arquitetura x86.
– Possui sistema de arquivos e interface de rede suportando algumas funcionalidades
TCP/IP.
– Possui o Cosmo User Kit para desenvolvedores usarem o Visual Studio.
– Está a todo vapor no codeplex: http://cosmos.codeplex.com/

Plataforma .Net – Prática de Coding Dojo

http://dojopuzzles.com/problemas

Framework .Net: Aula 2 - Quarta-feira

Plataforma .Net – Prática
• Desenvolvimento passo-a-passo de uma calculadora usando
desenvolvimento orientado a testes e ideias de código limpo.

• Não será usado conceitos de orientação a objetos.

• Criação de um projeto ClassLibrary, um projeto para testes e um para
WindowsForm.

Objetivo principal: conhecer o que
veremos e como faremos algumas
atividades daqui para frente.

Framework .Net: Aula 3 – Quinta-feira

Agenda
• Código limpo
– Discussões sobre código limpo
– O que é um código limpo?
– Nomes significativos
– Valores por tipo
– Definição de classe e objetos

Plataforma .Net – O código

Jamais nos livraremos dele!

Plataforma .Net – Código ruim

Jamais nos livraremos dele?

Plataforma .Net – Custo do código ruim

Código complexo aumenta, produtividade diminui.

Plataforma .Net – “A” nova versão

Código complexo apenas torna “A” nova versão um looping.

Plataforma .Net – Atidude

Atitude com responsabilidade mudam o ambiente de desenvolvimento.

Plataforma .Net – O que é código limpo?
“Gosto de meu código elegante e
eficiente. A lógica deve ser direta
para dificultar o encobrimento de
bugs, as dependências mínimas
para facilitar a manutenção, o
tratamento de erro completo de
acordo com uma estratégia clara e
o desempenho próximo do mais
eficiente de modo a não incitar as
Bjarne Stroustrup, criador do C++ e pessoas a tornarem o código onfuso
autor do livro “A linguagem de com otimizações sorrateiras. O
programação C++”. código limpo faz bem apenas uma
coisa.”

“Um código limpo é simples e
direto. Ele é tão bem legível quanto
uma prosa bem escrita. Ele jamais
torna confuso o objetivo do
desenvolvedor, em vez disso, ele
está repleto de abstrações claras e
linhas de controle objetivas.”

Grandy Booch, autor do livro
“Análise e Projeto de Sistemas
Orientados a Objetos”

“Ele tem testes de unidade e
aceitação, nomes significativos; ele
oferece apenas uma maneira e não
várias de se fazer uma tarefa;
possui poucas dependências as
quais são explicitamente declaradas
e oferecem um API mínimo e claro.
O código deve ser inteligível já que
dependendo da linguagem, nem
David A. Thomas, fundador da toda informação necessária pode
Object Technology International estar expressa no código em si. ”
(IBM OTI Labs), responsável pelo
início do desenvolvimento do
“Eclipse IDE”.

“Eu poderia listar todas as
qualidades que vejo em um código
limpo, mas há uma predominante
que leva a todas as outras. Um
código limpo sempre parece que foi
escrito por alguém que se
importava. Não há nada de óbvio
no que se pode fazer para torná-lo
melhor. Tudo foi pensado pelo autor
Michael Feathers, autor de do código, e se tentar pensar em
“Trabalhando efetivamente com algumas melhorias, você voltará ao
código legado”. inicio, ou seja, apreciando o código
deixado para você por alguém que
se importa com essa tarefa.”

Plataforma .Net – A regra de escoteiro
“Deixe a área do acampamento mais limpa do que como você a
encontrou”.

A história do apartamento sujo...

Plataforma .Net – Princípios código limpo
Nomes significativos
– Nomeamos variáveis,
– Nomeamos funções,
– Nomeamos parâmetros,
– Nomeamos classes,
– Nomeamos arquivos,
– Nomeamos diretórios,
– Nomeamos e nomeamos...

Plataforma .Net – Nomes significativos
• Escolher bons nomes leva tempo, mas economiza
mais.

• O nome de qualquer coisa no código deve lhe dizer
porque existe, o que faz e como é usado.

• Se um nome requer um comentário, então ele não
revela seu propósito:

Int d; // tempo decorrido em dias

• Nomes devem ser simples e compreendidos
facilmente:

Int tempoEstimadoEmDias;
Date dataEmissao;
String nomeArquivoBackup;
Int AnoArquivoEmDias;

public List<int[]> retornaItens(){
List<int[]> lista1 = new List<int[]>();
foreach(int[] x in listaGeral){
if (x[0] == 4)
lista1.add(x);
}
return list1;
}

public List<int[]> retornaItens(){
List<int[]> lista1 = new List<int[]>();
foreach(int[] x in listaGeral){
if (x[0] == 4)
lista1.add(x);
}
return list1;
}

Função de um jogo de “Campo minado”

public List<int[]> retornaCelulasMarcadas(){
List<int[]> celulasMarcadas= new List<int[]>();
foreach(celula[] x in tabuleiro){
if (celula[STATUS] == MARCADA)
celulasMarcadas.add(x);
}
return celulasMarcadas;
}

Apenas mudamos os nomes... Vamos continuar...

public List<celula> retornaCelulasMarcadas(){
List<celula> celulasMarcadas= new List<celula>();
foreach(Celula celula in tabuleiro){
if (celula.estaMarcada())
celulasMarcadas.add(celula);
}
return celulasMarcadas;
}

Apenas trocando os nomes e fazendo uma simples
refatoração o código ficou muito mais legível.

for (int j=0; j<50; j++){
s += (t[j]*4)/5;
}

O que faz isso?

• Evite informações erradas:
– Evite usar palavras cujos significados podem se desviar do
desejado, ex: hp, aix, sco. Mesmo que tiver programando
uma hipotenusa, hp pode parecer uma boa opção, mas
pode ser interpretado como um comando Unix.
– Não coloque o nome de lista se não for efetivamente uma
lista.

• Use nomes pronunciáveis:
– Tente discutir com alguém sobre um programa com
variáveis não pronunciáveis: “Olha, aqui no bê cê erre três
cê ene tê, temos um pê esse zê quê int...”

• Use nomes passíveis de busca:
– Nomes de uma só letra ou com números possuem um
problema na hora de ser localizados no código;
– Buscas são o último recurso e quando você precisa dela
quer que funcione;

• Evite o mapeamento mental:
– Utilize nomes que façam sentido para o “negócio” ou para
a “solução” do problema e evite assim que o leitor
desenvolvedor precise ficar decorando o que faz uma
variável para entender um código 3 linhas abaixo.

• Notação Húngara: não faça isto!
– Exemplos:
• s_nomeCliente ou str_nomeCliente ou strNomeClient
• i_idade ou int_idade ou intIdade
– A um bom tempo atrás tínhamos algumas características nas
linguagens que não temos hoje:
• Versões anteriores do Basic só permitiam uma letra mais um dígito;
• O Fortran forçava codificações ao tornar a primeira letra uma indicação para o
tipo;
• Não ter variáveis tipadas.
– Nas linguagens atuais, neste curso tratamos de C#, os objetos já são o
próprio tipo e o ambiente detecta a utilização inadequada de um tipo,
como colocar uma string dentro de um inteiro.
– Resumo: Notação Húngara vai dificultar a nomenclatura e podem até
induzir ao erro se mal colocado. Evitem ao máximo e se possível nunca
usem.

• Métodos (Funcionalidades):
– Os nomes de métodos devem ter verbos;
• Errado: void lista();
• Certo: void retornaLista();
• Certo: void retorneLista();
– Preferível. Imagine que você esteja “ordenando” uma ação.
– Não coloque os parâmetros no nome do método;
• Errado: void retornaListaPeloCnpjEPeloID(String
cnpj, int id);
• Certo: void retornaLista(String cnpj, int id);

• Selecione uma palavra por conceito:
– Você quer retornar um dado e usa métodos assim por
todo código:
• pegarHora();
• recuperarData();
• obterNome();
• retornarSobrenome();
– Escolha um conceito e use sempre:
• obterHora();
• obterData();
• obterNome();
• ObterSobrenome();

• PascalCase:
– TodasAsPalavrasIniciamComLetraMaiuscula
– Classes, Enumeradores, Eventos, Fields estáticos,
Interface, Métodos, NameSpaces, Propriedade,
Field público.
• CamelCase:
– apenasAPrimeiraPalavraIniciaComLetraMinuscula
– Parâmetros, Fields privados, Variáveis.

• O C# é case-sensitive, diferente de Visual
Basic.

• Desenvolvedores VB criam variáveis iniciando
com underline para poder ter propriedades
com o mesmo nome.

• Não faça isto em C#, a linguagem é case-
sensitive, aproveite isto.

Plataforma .Net – Fundamentações .Net
• Tipos por valor
– O que são e quem são
– Criando tipos por valor
– Trabalhando com enumeradores
• Tipos por referência
– O que são e quem são
– Criando tipos por referência
• Convertendo entre tipos
– Boxing e Unboxing

Plataforma .Net – Tipos por valor
• Tipos por valor são tipos que permitem armazenar realmente
o valor definido e não um “ponteiro” para um local da
memória onde está o valor.

• Os valores das variáveis dos tipos por valor são armazenados
em uma área chamada “stack”, onde em tempo de execução
consegue ser lido, gravado e atualizado rapidamente sem
causar overhead (processamento em excesso).

• Exemplo:
int valor1 = 1;
int valor2 = valor1;
valor2++;

Qual resultado de valor1???

• Exemplo:
int valor1 = 1;
valor2++;

Qual resultado de valor1??? 1

Porque?

• Exemplo:
int valor1 = 1;
valor2++;


Porque? Pelo simples fato de ao armazenar o valor “1” na variável
“valor1” e armazenar “valor1” na variável “valor2”, o valor é
COPIADO para a variável “valor2” e ambos estão separados dentro
da memória stack.

Tipo Utilização Bytes Faixa Usado para
System.SByte SByte/sbyte 1 -128 até 127 Bytes negativos e
positivos
System.Byte Byte/byte 1 0 até 255 Apenas Bytes
positivos
System.Int16 Short/short 2 –32768 até 32767 Números
pequenos
System.Int32 Integer/int 4 –2147483648 até 2147483647 Número inteiros
e contadores
System.UInt32 UInteger/uint 4 0 até 4294967295 Apenas números
positivos
System.Int64 Long/long 8 –92372036854775808 até Números
9223372036854775807 grandes
23

System.Single Single/float 4 –3.402823E+38 até Números
3.402823E+38 decimais (pontos
flutuantes)
System.Double Double/double 8 – Grandes
1.79769313486232E+30 números
8 to decimais
1.79769313486232E+30
8
System.Decimal Decimal/decimal 16 – Cálculos
79228162514264337593 científicos ou
54 que requerem
3950335 to grande precisão
79228162514264337593
5439
50335

• Boas práticas:
– Em tempo de execução é otimizada a utilização de inteiros
32 bits (Int32, Uint32).

– Para ponto flutuante o mais eficiente é o Double que tem
suas operações otimizadas pelo hardware.

System.Char Char/char 2 Não tem Apenas 1
caracteres
unicode
System.Boolean Boolean/bool 4 Não tem Valor Verdadeiro
(True) ou False
(False)
System.IntPtr Não tem Depende da Não tem Ponteiro para
plataforma endereçamento
de memória
System.DateTime Date/date 8 1/1/0001 Data e hora
12:00:00 AM até
12/31/9999
11:59:59 PM

• Existem quase 300 tipos por valor, mas os tipos mostrado aqui cobrem a
maioria das necessidades.

• Quando você atribui um valor para uma variável de um tipo assim os
dados são copiados para ele como já vimos.

• Este comportamento é diferente do de tipos de referência, que serão
discutidos mais adiante.

• Mesmo que tipos por valor, muitas vezes representam valores simples,
eles ainda funcionam como objetos. Em outras palavras, podemos chamar
métodos neles. De fato, é comum utilizar o ToString(), por exemplo.

• Todos os tipos são derivados de System.Object. Esse relacionamento ajuda
a estabelecer o sistema de tipo comum utilizado para todos os tipos.

Resumo
• É armazenado na memória Stack. (Pilha)
• Stack é uma área da memória onde podemos armazenar e
gerenciar dados.
• É extremamente eficiente, porém, cabem poucas duzias de
kilobytes.
• É manipulada conforme uma pilha.
• Não pode ser nulo.
• Trabalha com dados diretamente. Stack
• Exemplos:
Idade = 15
• Inteiros;
• Decimais; Estudante = 1 (Sim -> 0 = Não; 1 = Sim)
• Datas; Salário = 501,52
• Booleanos; ...
• Enumerações

Plataforma .Net – Enumeradores
• Enumerações são símbolos relacionados que têm valores fixos. Use enumerações para
fornecer uma lista de opções ao invés de valores fixos diretamente.

• Exemplo:
public void metodoQualquer()
{
string nomeCidade = obtemNomeCidade();
if (nomeCidade == "Joinville")
{
//-- Faça algo para Joinville
}
else if (nomeCidade == "Blumenau")
{
//-- Faça algo para Blumenau
}
}

enum Cidade
{
Joinville,
Blumenau
}

• Para criar um enumerador é bem simples, basta colocar enum e o nome dele. Dentro das
chaves defina a lista de opções e pronto, seu enumerador está criado.

• Importante: o enumerador é apenas uma representação estática de um número. A lista
começa sempre em zero então neste caso Joinville é o número zero e Blumenau é o número
1.

• Vamos aplicar este enumerador ao nosso exemplo anterior e ver como fica?

public void metodoQualquer()
{
Cidade cidade = obtemCidade();
if (cidade == Cidade.Joinville)
{
//-- Faça algo para Joinville
}
else if (cidade == Cidade.Blumenau)
{
//-- Faça algo para Blumenau
}
}

• Melhorou? Agora não precisamos de Strings fixas, reduzimos a possibilidade de um erro e
deixamos o código mais claro.
• Tem como definir os índices para os enumeradores?

enum Cidade
{
Joinville=20,
Blumenau=30
}

• Pronto, agora nossos itens do enumerador possuem seus próprios números e não iniciam
mais em zero.

Plataforma .Net – O que é uma classe?
• Classe é a representação escrita de um tipo de
objeto.

• A classe está para um objeto assim como uma
“planta baixa” está para um prédio.

• É a definição formal de um objeto.

Plataforma .Net – Definição de objetos
• Objetos são abstrações do mundo real afim de
definir comportamentos e atributos.

• Todo objeto, no mundo real, possui
comportamentos (ações) e atributos
(propriedades).

• Quais são os ações e propriedades dos itens a
seguir?

• Cite ações e propriedades:
– Carro;
– Pessoa;
– Cadeira;
– Calculadora;
– Martelo;
– Pudim;

– Carro;
• Ações: ligar, acelerar, frear, buzinar...
• Propriedades: cor, tamanho, aro da roda...
– Pessoa;
• Ações: andar, correr, comer, falar, ouvir, dançar...
• Propriedades: altura, peso, forma, cor do cabelo...
– Cadeira;
• Ações: ...
• Propriedades: Quantidade de pernas, tipo de acento,
tamanho...

– Calculadora;
• Ações: somar, multiplicar, subtrair, dividir
• Propriedades: cor, tamanho dos botões, tipo do visor...
– Martelo;
• Ações: Bater, arrancar prego... (quem bate? Quem arranca?)
• Propriedades: Comprimento, peso da “cabeça” do martelo...
– Pudim;
• Ações: estragar...
• Propriedades: cor, tamanho, formato...

Plataforma .Net – Pudim

Objeto: pudim

Classe: define o pudim

Objeto: pudim

Plataforma .Net – Pudim
• Ações e propriedades:
– Pudim;
• Ações: estragar...
• Propriedades: tamanho, formato...

Plataforma .Net – Classe Pudim
Public class Pudim
{
public string Tamanho { get ; set ; }
public string Formato{ get ; set ; }

public void Estragar()
{

}
}

Public class Pudim
{
public Nome da Formato{ get ; set ; }
string
classe (inicia
com letra
maiúscula)

{

}
}

Public class Pudim
{
Acesso
dapublic string Formato{ get ; set ; }
classe.
Todo
mundo
tem
{
acesso.

}
}

Public class Pudim
{
Propriedades

{

}
}

Public class Pudim
{
Set = Podemos definirTamanho { get ; set ; }
public string o valor
Get = Podemos obter Formato{ get ; set ; }
public string o valor

{

}
}

Public class Pudim
{

{
Ações
}
}

Public class Pudim
{
public string Cor { get ; set ; }

{
Void: não retorna
valor.
} Podemos retornar
qualquer tipo de
} dado/objeto

Plataforma .Net – Objeto Pudim
Pudim pudim = new Pudim();
pudim.tamanho = “médio”;
pudim.formato = “redondo”

Pudim pudim2 = new Pudim();
pudim2.tamanho = “grande”;
pudim2.formato = “quadrado”

Operador de
criação de
um objeto

pudim2.tamanho = “grande”;


Definição dos
pudim2.tamanhodas “grande”;
valores
=
propriedades


pudim.Estragar();

Invocação do
método
estragar.

Plataforma .Net – Classe Calculadora
Public class Calculadora
{
public int Valor1 { get ; set ; }
public int Valor2 { get ; set ; }

public int Somar()
{
return this.Valor1 + this.Valor2;
}
}

Plataforma .Net – Objeto Calculadora
Calculadora calculadora = new Calculadora();
calculadora.Valor1 = 3;

int resultado = calculadora.Somar();

Criamos o
calculadora.Valor2 = 5; objeto
calculadora



Definimos
propriedades



Invocamos
ações.

Framework .Net: Aula 4 – Sexta-feira

Agenda
– Valores por referência
– Convertendo entre tipos
– Comentários
• Início do desenvolvimento da lista de exercícios
– Desenvolver somente a parte de processamento, ou seja, não é
necessário NESTE MOMENTO fazer a parte de tela pois estaremos vendo
isto mais a frente;
– Preferencialmente fazer em duplas;

Plataforma .Net – Tipos por referência
• Tipos de referência armazenam o endereço de seus dados, também
conhecidos como um ponteiro.

• Os dados reais que se refere ao endereço é armazenado em uma
área de memória chamada “heap”.

• Não precisamos nos preocupar com gerenciamento de memória
dos tipos de referência, o .Net Framework cuida disso para nós.

• Um processo chamado “Garbage Collector” automatiza o
gerenciamento de memória, fazendo o “trabalho sujo” de eliminar
os tipos que não são mais referenciados por ninguém e liberando
memória.

• Exemplo:
StringBuilder valor1 = new StringBuilder(“oi”);
StringBuilder valor2 = valor1;
valor2.Append(“ tchau”);


• Exemplo:

Qual resultado de valor1??? “oi tchau”

Porque?

• Exemplo:


Porque? Pelo simples fato de ao armazenar o valor “oi” na variável
REFERENCIADO para a variável “valor2” e não COPIADO e o valor
mesmo está na memória HEAP.

Tipo Usado para
System.String Valor texto. Com a ressalva que para o .Net
Framework o valor de uma String é imutável.
Veremos com mais detalhes isto quando
trabalharmos com StringBuilder.
System.Text.StringBuilder Valores textos dinâmicos.
System.Array Vetor de dados. Esta é a classe básica para
todos os arrays.
System.Exception Lançar ou tratar exceções. Veremos isto em
tratamento de exceções.
... ...

Existem mais de 2 500 tipos por referência dentro do .Net Framework.

Resumo
• É armazenado na memória Heap. (Monte)
• Heap é uma área da memória onde podemos armazenar e gerenciar
dados dinamicamente.
• É alocada e liberada em blocos, o que muitas vezes se torna burocrático
e mais lento.
• Permite qualquer tipo inclusive nulo.
• Trabalha com dados ponteiros (referência de memória).
• Exemplos:
Stack
• Vetores;
Nome = #123456abc (endereço)
• Textos;
...
• Instância de classes; Heap
#123456abc = “Geração”
...

Plataforma .Net – Tipos:Valor vs Referêcia
• Exemplo:


Porque? Pelo simples fato de ao armazenar o valor “oi” na variável
REFERENCIADO para a variável “valor2” e não COPIADO e o valor
mesmo está na memória HEAP.

Plataforma .Net – Boxing e Unboxing
• Boxing é o processo de converter um tipo por valor para um
tipo por referência.

• Unboxing é o processo de converter um tipo por referência
em um tipo por valor.

• Ambos processos são computacionalmente caros. Quando um
tipo por valor é convertido em um tipo por referência (boxing)
um novo objeto deve ser alocado e contruído.

Plataforma .Net – Boxing e Unboxing
int inteiro = 123; // Tipo por valor
object objeto; // Tipo por referência
objeto = inteiro; // Causa “boxing”
string texto = objeto.ToString() // Chama via O
int novoInteiro = (int)objeto // Faz “unboxing”

Stack Heap
inteiro 123

objeto 123

novoObjeto 123

Plataforma .Net – Evite Cast
• É chamado de Cast a conversão forçada de um tipo em outro.
– Exemplo:
String valor = “1”;
int numero = (int)valor;

• Evite a utilização de cast. Ele é caro computacionalmente.

• Apenas use quando for realmente necessário.

• Sempre procure métodos de conversão como por exemplo:
int inteiro = 123; // Tipo por valor
object objeto = inteiro; // Causa “boxing”
int novoInteiro = Convert.ToInt32(objeto);

Plataforma .Net – Comentários

“Não insira comentários num código ruim, reescreva-o.”
Brian W. Kernighan (PhD em Ciência da Cmputação...) e P.J.
Plaugher (Autor e empresário...)

• Comentários são um “mal necessário” e vamos entender um pouco mais
sobre como utilizar melhor esta ferramenta de auxílio ao código.

• “Se nossas linguagens de programação fossem expressivas o suficiente ou
se tivéssemos o talento para manipular com destreza tais linguagens de
modo a expressas nossa intenção, não precisaríamos de muitos
comentários, quiçã nenhum.

• Para compensar nosso fracasso em nos expressar no código temos que no
mínimo usar adequadamente os comentários.

• Mude o que mudar, falem o que falar, briguem o que brigar, cantem o que
cantar, chorem quem quiser chorar: a verdade está no código.

Comentários compensam código ruim?

• Acabamos de construir um código que tá difícil de entender, qual a
primeira coisa que vem na mente? Hmmmm... Vou deixar bem comentado
este código. Pare agora! Código limpo!

• Códigos limpos e expressivos com poucos comentários são de longe
superiores a um amontoado e complexos cheios de comentários.

• Não gaste tempo criando comentários para explicar a bagunça que você
fez, use-o para limpar a zona que ficou.

• Vamos ver alguns exemplos de como e quando NÃO FAZER comentários.

Plataforma .Net – Comentários,não assim
Comentários dizendo exatamente o que se está fazendo:

// Somente executa se a pessoa tiver mais que 18 anos e for do sexo
feminino
// para ver se pode entrar no banheiro feminino
if (pessoa.idade >= 18 && pessoa.sexo == Sexo.Feminino){
banheiroFeminino.Entre(pessoa);
}

Bobeira isso? Não! Existe e muito! Não seria mais simples assim?

if (pessoa.PodeEntrarBanheiroFeminino()){
}

Controle de fonte no código.

// 01/01/2012: Alterado por Fulano para fazer tal coisa.
// 06/02/2012: Alterado por Ciclano para fazer outra coisa.
// 29/03/2012: Alterado por Beltrano para desfazer alteração do Fulano

Há muito tempo, havia um om motivo para preservar estas informações. Hoje
não se desenvolve mais sem um controle de fontes como o SVN, TFS ou GIT.

Deixe a responsabilidade de controlar as alterações e quem as alterou para o
devido responsável: o controle de fontes.

Quer deixar sua maca no código colocando seu nome? Faça um código bem
feito e deixe sua marca na sua vida profissional.

Comentários sem total necessidade, apenas “para comentar”:

// Construtor padrão *** não, tá brincando que ele é o contrutor padrão.
Public Pessoa(){ }

// Dia do mês *** achei que fosse quantidade de caracteres...
Private int diaDoMes();

// Retorna o dia do mês *** para! Agora tá de sacanagem...
Public int ObtemDiaDoMes(){
return diaDoMes;
}

Qualquer desenvolver que leia este código vai ignorar estes comentários, logo
não perca tempo escrevendo-os. Vamos piorar a situação agora...

Comentários mentem:

// Somente executa se a pessoa tiver mais que 18 anos e for do sexo
feminino
// para ver se pode entrar no banheiro feminino
if (pessoa.sexo == Sexo.Feminino){
}

Quando uma alteração no código é executada, dificilmente seu comentário é
alterado, fazendo com que se torne falso.

Regra básica: quanto maior e mais longe o comentário do código destino,
mais falso ele pode ser. No final você pode confiar apenas no código.

Excesso de comentários no famoso Ctrl + C, Ctrl + V:

/** Name. */
Private String name;

/** The Version. */
Private String version;

/** Licence Name. */
Private String licenceName;

/** The Version. */
Private StringInfo;

Este é um código de uma biblioteca de código livre bem conhecida...
Se nem os autores não prestarem atenção na hora de comentar, porque os
leitores deveriam?

Comentários para fechar tag “chaves”:

...
try{
while( ... ) {
...
...
...
} //while
...
...
} // try
...

Isso até pode faze sentido em funções longas com muitas estruturas
aninhadas. Antes de faze este tipo de comentário, tente refatorar e diminuir as
linhas. Um método (função) deve fazer uma única tarefa.

Informações excessivas e o pior se desculpando...:

/*
* Na década de 90 o fulado de tal criou uma tarefa para fazer uma
alteração mas acabou não fazendo, então ficou para mim a pendência de
fazer. Eu não conheço bem esta parte do sistema e fiz o que pude,
desculpe se não ficou da melhor maneira possível, todo mundo estava
ocupado e ninguém conseguiu tempo para me ajudar. No final eu
também não quis atrapalhar ninguém. A alteração foi simples, eu troquei
o if que verificava a flag de ativo por um if que verifica se a data de
alteração é menor que 90 dias atrás. Com isto resolveu o problema e
tudo deu certo, espero que não aconteça nenhum efeito colateral.
*/

Depois das discussões anteriores, nem precisamos falar nada sobre isto...

Conexões nada óbvias:

/*
* começa com um array grande o bastante para conter todos os pixels (
mais
* os bytes de filtragem) e 200 bytes extras para informações no cabeçalho.
*/
this.pngBytes = new byte[((this.width + 1) * this.height * 3) + 200]

• O que é um byte de filtragem?
• Ele tem a ver com o “+1” ou com o “*3” ou ambos?
• Um pixel é um byte? Porque 200?

“O objetivo de um comentário é explicar o que o código não consegue por si
só. É uma lástima quando um comentário também precisa ser explicado.”

Plataforma .Net – Comentários, assim
Certos comentários são necessários ou benéficos. Veremos alguns que valem
a pena utilizar QUANDO NECESSÁRIO.

Comentários Legais:

Muitas vezes, dentro do desenvolvimento corporativo é necessário colocar
comentários com informações sobre direitos autorais simplesmente por
questões legais.

Só não vale colocar todo o arquivo de licença no código fonte. Se necessário
referencie o arquivo onde se encontra todas as informações de licença:

/* Direitos autorais © 2010,2011,2012 por Empresa XXXX. Todos os direitos
* reservados.
* Distribuído sob os termos da versão 2 ou posterior da Licença Pública
Geral
* da GNU
*/

Comentários informativos:

Quando criamos um método, podemos descrever algumas informações sobre
ele e facilitar quem for utilizar aquele método através das 3 barras (///). Veja:

Comentários de atividades pendêntes (TODO):

• Muitas vezes estamos lendo um código e encontramos algo que deveria ser
melhorado mas não temos tempo de fazer isto no momento, ou até mesmo
estamos trabalhando em um método que precisa ser melhorado mas por
algum motivo não podemos fazer no momento.

• Para não esquecer, criamos o comentário TODO, assim podemos gerar uma
lista de todos os locais que possuem um TODO e corrigi-los ou melhorá-los
quando o tempo permitir.

Escrever comentário
// TODO: o que você quer

Visualizar comentário:
• Menu View – Task List
• Selecione a opção “Comments”

Explicação de intenção: usada para identificar “Jabutis”

• As vezes, por motivos de compatibilidade com código legado ou clientes
temos que manter um código de uma determinada forma até uma
próxima versão, conseguir autorização de alguém que permita alteração
de impacto ou até mesmo eternamente.

• Quando isto ocorrer comente a intenção e explique resumidamente o que
aconteceu para caso outra pessoa tente alterar não crie novos problemas.

• Podemos concordar que o melhor seria refatorar, mas no mundo real nem
sempre conseguimos fazer isto sempre que queremos...

// Essa é a melhor tentativa de conseguir uma condição de repetição sem
// problema com threads executando a mesma instância da classe XXX. Por
// isto fazemos new ao invés de usar uma instância estática.

Plataforma .Net – Exercícios

Framework .Net: Aula 5–Segunda-feira

Agenda
– Tipos Nullable
– Navegando pelo sistema de arquivos
• Feedback da semana

Plataforma .Net – Tipos Nullable
• Vimos que tipos por valor não suportam salvar valores nulos.

• Em alguns casos, necessitamos salvar um tipo por valor nulo, como
“Temperatura não definida”. Temperatura é um número inteiro e não
pode ser zero, pois zero é uma temperatura válida.

• Para nos ajudar existe um tipo chamado Nullable. Este tipo permite
estender os tipos primitivos (tipos bases do .Net Framework) e possibilitar
ter valores por tipo aceitando nulo.

• Utilização:
Nullable<int> temperatura = null;
temperatura = 10;
temperatura = null;
temperatura = 50;

Plataforma .Net – Sistemas de arquivos
• Dentro do namespace System.IO existem um conjunto de classes usadas
para navegar e manipular arquivos, diretórios e discos.

• As classes são separadas em 2 tipos:
– Informativas (Herdam de FileSystemInfo)
• FileInfo
• DirecoryInfo
• DriveInfo

– Utilitárias
• File
• Directory
• Path

Plataforma .Net – FileSystemInfo
• Fornece informações sobre o sistema de arquivos:
– Principais propriedades
• CreationTime: Data de criação do arquivo ou diretório que foi
criado.
• Exists: Determina se o arquivo ou diretório existe.
• FullName: Caminho completo, com nome, do arquivo ou diretório.
• Extension: Mostra a extensão do arquivo .
• Name: Nome do arquivo ou diretório.
– Principais métodos
• Delete: Remove arquivo ou diretório do sistema de arquivos.
• Refresh: Atualiza os dados referente a informações do sistema de
arquivos.

Plataforma .Net – FileInfo
Pegando informações de arquivos

FileInfo file = new FileInfo(@"c:arquivo.txt ");
if (file.Exists)
{
MessageBox.Show("Filename : " + file.Name);
MessageBox.Show("Path : " + file.FullName);
}

Simples assim...

Plataforma .Net – FileInfo
Como copiar um arquivo...

FileInfo file = new FileInfo(@"c:arquivo.txt ");
if (file.Exists)
{
file.CopyTo(@"c:arquivo.csv");
}

Simples assim...

Plataforma .Net – DirectoryInfo
Pegando informações de diretórios

DirectoryInfo directory = new DirectoryInfo(@"c:temp");
MessageBox.Show("Directory: " + directory.FullName);
foreach (FileInfo file in directory.GetFiles())
{
MessageBox.Show("File: " + file.Name);
}

Simples assim...

Plataforma .Net – DriveInfo
Pegando informações de discos

DriveInfo unidade= new DriveInfo(@"c:");
MessageBox.Show(drive.Name);

Simples assim...

Agenda
• Discussões sobre o curso
• Gerenciador de fontes GitHub

Plataforma .Net – Gerenciador de fontes
• É uma aplicação com a responsabilidade de armazenar e gerenciar fontes
desenvolvidos em diversas linguagens.

• Vantagens:
– Histórico de tudo que foi desenvolvido;
– Desenvolvimento por mais de um desenvolvedor simultaneamente;
– Controle de versão;

• Existem duas grandes linhas de gerenciadores de fontes:
– Distribuídos
• Cada computador é um repositório/servidor de fontes.
• Exemplos: Git, Mercurial e Bazaar
– Centralizados
• Existe um servidor com todos os fontes e os computadores são
apenas clientes do servidor.
• Exemplo: Microsoft Team Foundation Server e SubVersion

Plataforma .Net – Conceito de Commit
• Um commit é um agrupador de alterações relacionada a um usuário;
• Exemplos:
– Commit 1: Criação da classe calculadora e suas funções. [João]
• Lista de arquivos:
– Calculadora.cs
– CalculadoraTest.cs
– Commit 2: Criação da classe pessoa e suas funções. [Pedro]
– Pessoa.cs
– PessoaTest.cs
– Commit 3: Efetuada tela da calculadora. [Carlos]
– FrmCalculadora.cs
– Commit 4: Correção do método somar da calculadora. [Pedro]
– Calculadora.cs

Arquitetura básica de um gerenciador Centralizado:

Servidor
(Repositório)

Desenvolvedor 2

Desenvolvedor 1 Desenvolvedor 3

Operações básicas de um gerenciador Centralizado:

Servidor Servidor
(Repositório) (Repositório)

Download e/ou Trava Upload de todos os
arquivos somente para arquivos alterados
ele alterar (commit)

Desenvolvedor Fonte
Modifica ou cria
arquivos

Plataforma .Net – Commit centralizado
• O commit é efetuado quando vamos enviar os arquivos ao servidor. Todos os
arquivos alterados são agrupados em um mesmo commit. Dependendo do
caso podemos ter um commit com mais de uma dezena de arquivos.

• Exemplo:
– Commit 1: Criação da classe calculadora e suas funções. Criação da classe
pessoa e suas funções. Efetuada tela da calculadora. Correção do método
somar da calculador. [João]
– Calculadora.cs
– Pessoa.cs
– PessoaTest.cs

Arquitetura básica de um gerenciador Distribuido:

Servidor
(Histório/Backup)

Desenvolvedor Desenvolvedor
(Repositório) (Repositório)

Desenvolvedor
(Repositório)

Operações básicas de um gerenciador Distribuido:

Servidor
Servidor
(Repositório)

Refaz o ciclo para cada
conjunto de alterações.
Download
Upload

Desenvolvedor Salva Desenvolvedor
Fonte
Modifica ou alterações
cria arquivos (commit)

Plataforma .Net – Commit distribuido
• O commit é efetuado no momento que finalizamos a alteração de uma alteração. Não
enviamos um conjunto de arquivos para o servidor e sim um conjunto de commits.
Quando menos arquivos em um commit melhor.

• Exemplos:
– Commit 1: Criação da classe calculadora e suas funções. [João]
– Calculadora.cs
– Commit 2: Criação da classe pessoa e suas funções. [João]
– Pessoa.cs
– PessoaTest.cs
– Commit 3: Efetuada tela da calculadora. [João]
– Commit 4: Correção do método somar da calculadora. [João]
– Calculadora.cs

Plataforma .Net – Git
• É um sistema de controle de versão distribuido, criado
inicialmente por Linus Torvalds, para o desenvolvimento do
Kernel do Linux.

• É fornecido como software Livre.

• Disponível para:
– Windows;
– Linux;
– Mac OS X;

Plataforma .Net – Quem usa Git?

Plataforma .Net – Hospedagens Git

Plataforma .Net – Github
• É um serviço de hospedagem para o sistema de controle de
versão Git.

• É escrito em Ruby on Rails e possui planos comerciais gratuitos
para repositórios públicos e planos pagos para repositórios
privados.

• Possui conceito de rede social, estimulando “social coding” ou
compartilhamento de códigos entre os integrantes.

• Disponível para:
– Windows;
– Linux;
– Mac OS X;

Plataforma .Net – Ambiente Git
• Utilizem a versão convencional para este curso, não “for
Windows”, baixada em: http://git-scm.com/downloads;

• Efetue a instalação;

• Inicie o Git Gui e clique
No menu Ajuda – Mostrar chave SSH;

• Utilizem a versão convencional para este curso, não “for
Windows”, baixada em: http://git-scm.com/downloads;

• Efetue a instalação;

• Inicie o Git Gui e clique
No menu Ajuda – Mostrar chave SSH;

• Clique no botão gerar chave;

• Após isto clique no botão “Copiar
para área de transferência.

• Abra www.github.com e efetue login;

• Clique em Account Settings;

• Clique no menu SSH Keys;

• Clique no botão “Add SSH Keys”;

• Digite um título para a chave
(nome do seu computador) e
cole o que está na sua área de
Transferência com o “Ctrl + V”.

• Clique no botão “Add Key”;

Plataforma .Net – Utilização Git
• Passo 1: Commit
– Execute o Git Gui e abra seu repositório local;
– Clique no botão “Atualizar” para ver os arquivos que foram alterados;
– Selecione os arquivos clicando no ícone dos mesmos;
– Digite uma descrição e clique no botão “Salvar revisão”;

• Passo 2: Baixar “novidades” do servidor
– Clique no menu Remoto – Receber de – Origem;
– Assim que finalizado clique em Fechar;
– Clique no menu Mesclar – Mesclar localmente;
– Se tiver algo na caixa de mesclagem, clique em Mesclar;

• Passo 3: Enviar minhas alterações
– Na tela do Git Gui Clique no botão Enviar;
– Clique no botão “Enviar”;

Framework .Net: Aula 7 - Quarta-feira

Agenda
• Usando GitHub
– Manipulando sistema de arquivos

Plataforma .Net – Path
• Combinando diretórios

Path.Combine("diretorio1", "diretorio2")
Resultado: diretorio1diretorio2

• Renomeando extensão

Path.ChangeExtension(@"c:temparquivo.txt", "csv");
Resultado: arquivo.txt renomeado para arquivo.csv

Plataforma .Net – Lendo arquivos
Lendo arquivos...

FileStream file;
StreamReader reader;
try
{
file = File.Open(@"C:arquivo.txt", FileMode.Open, FileAccess.Read);
reader = new StreamReader(file);
MessageBox.Show(reader.ReadToEnd());
}
finally
{
reader.Close();
file.Close();
}

Vamos melhorar este código.

Lendo arquivos...

using (FileStream file = File.Open(@"C:arquivo.txt", FileMode.Open,
FileAccess.Read))
{
using (StreamReader reader = new StreamReader(file))
{
MessageBox.Show(reader.ReadToEnd());
}
}

Ou podemos simplificar para:

File.ReadAllText(@"C:somefile.txt")

Lendo arquivos...

using (FileStream file = File.Open(@"C:arquivo.txt", FileMode.Open,
FileAccess.Read))
{
using (StreamReader reader = new StreamReader(file))
{
while (!reader.EndOfStream)
{
MessageBox.Show(reader.ReadLine());
}
}
}

Agora lendo linha a linha.

Plataforma .Net – Escrevendo arquivos
Escrevendo arquivos...

using (FileStream file = File.Create(@"C:arquivo.txt”))
{
using (StreamWriter writer = new StreamWriter(file))
{
writer.WriteLine(“Oi”);
}
}

Ou podemos simplificar para:

File.WriteAllText(@"c:somefile.txt", “Oi");

Plataforma .Net – Diretórios
Criando diretórios...
Directory.CreateDirectory(@"c:teste");

Apagando diretórios...
Directory.Delete(@"c:teste");

Verificando existência de diretório...
Directory.Exists(@"c:teste“);

Framework .Net: Aula 8 – Quinta-feira

Agenda
• Manipulação de Strings
– Concatenação
– StringBuilder
– StringFormat

Plataforma .Net – Textos
• Processamento de texto é uma das tarefas mais comuns no desenvolvimento
de software, as vezes necessitamos fazer
pesquisas, concatenações, formatações, enfim manipular textos em geral.

• Existem algumas formas de concatenar Strings, uma para cada tipo de
situação, vamos conhecer e saber quando aplicar qual obtendo maior
desempenho em nossos códigos.

• Para extração de dados de textos o mais comum é a utilização de expressões
regulares. Estas estão presentes em diversas linguagens e ferramentas
sempre que falamos em formatação de textos. Desde uma validação de e-
mail até buscas avançadas dentro de longos arquivos de textos.

Plataforma .Net – Concatenação
• Concatenação de Strings é muito comum no dia-a-dia e quanto maior é a
String para concatenar maior é o cuidado que temos que ter com o
desempenho.

• É muito comum desenvolvedores não se preocuparem com o desempenho e
fazer todos os tipos de concatenação da mesma forma.

• Ponto de partida: a String é um tipo por referência especial, ela é imutável. O
conteúdo de uma string não pode ser alterado depois que o objeto é criado,
embora a sintaxe possa fazer parecer isto.

Plataforma .Net – Concatenação
• Concatenar é unir duas cadeias de caracteres (strings) em uma.
– Objetivo: “palavra1” concatenada com “ - palavra2”;
– Resultado: “palavra1 – palavra2”;
– Resumo: Fizemos apenas uma concatenação.

• A concatenação é uma operação binária, quando fazemos uma concatenação
de 3 strings estamos, na verdade, fazendo duas concatenações.
– Objetivo: “palavra1” concatenada com “ - palavra2” concatenada com “ – palavra3”;
– Operação: “palavra1 – palavra2” concatenada com “ – palavra3”;
– Resultado: “palavra1 – palavra2 – palavra3”;
– Resumo: Fizemos duas concatenações.

• Quando concatenamos um conjunto grande de strings, estamos construindo
uma string.

• Quando definimos um padrão para a ordem que as strings são
concatenadas, estamos formatando a string.

Plataforma .Net – Operador “+”
• O operador “+” é utilizado para concatenação.
– Exemplo:
string concatenacao = " palavra1 " + "palavra2";

• Quando um dos itens da concatenação é uma string, não necessita converter
explicitamente o outro item.
• Exemplo:
string concatenacao = 1.ToString() + "palavra2"; (funciona, não
precisa)
string concatenacao = 1 + "palavra2"; (isto é o suficiente)

• É o operador mais eficiente para concatenação, porém não é eficiente para
construção de strings. Funciona muito bem para concatenação, mais de uma,
na mesma instrução.

Plataforma .Net – StringBuilder
• O StringBuilder é utilizado para construção de Strings, ou seja, efetuar várias
concatenações de forma a obter o máximo de desempenho.
– Exemplo:
string concatenacao = new StringBuilder().Append(1).Append("palavra2")
.Append("palavra3").ToString();

• É o operador mais eficiente para construir Strings, não é indicado para
pouquíssimas concatenação, quanto mais melhor.

• Se souber qual será o tamanho mínimo da String final, então pode ser
definido o número no construtor do StringBuilder aumentando ainda mais o
desempenho.
string concatenacao = new
StringBuilder(17).Append(1).Append("palavra2")
.Append("palavra3").ToString();

Plataforma .Net – StringFormat
• O StringFormat é utilizado para formatação de Strings, ou seja, definir um
padrão para a ordem que as Strings serão concatenadas.
– Exemplo:
string concatenacao = string.Format("{0} {1} {2}", "1", "palavra2",
"palavra3");

• É muito útil para definir de forma simples a formatação de uma string
independente de seus valores.

• Internamente utiliza StringBuilder para efetuar a construção da string.

• Ajuda em alguns casos que queremos armazenar a “formatação” em outro
local que não no código, como no banco de dados ou arquivo, por exemplo.

Plataforma .Net – Demonstração
• Vamos efetuar uma demonstração de desempenho identificando qual melhor
operador para efetuar concatenação.

• Esta demonstração pode ser alterada para identificar o melhor operador para
construção de strings, ou seja, efetuar várias concatenações para uma mesma
string.

• O objetivo é simular a ocorrência de várias concatenações em uma grande
aplicação.

• O objetivo não é simular um grande número de concatenações, apenas a
concatenação ocorrida diversas vezes.

• Cuidados:
– Deve estar atendo as diversas demonstrações em blogs na internet.
Verifiquem sempre a experiência do profissional que está “blogando”.
– Deve ser montado um ambiente o mais controlado possível, cuidando do
gerenciamento de memória para cada operador.

//--# Força eliminação de todos os objetos não usados e retorna o total de memória usada
long memoriaInicial = System.GC.GetTotalMemory(true);

DateTime horaInicial = DateTime.Now;

for (int iteracao = 0; iteracao < 90000; iteracao++)
{
string concatenacao = "Indice “ + iteracao + " palavra1 “ + "palavra2";
}

DateTime horaFinal = DateTime.Now;

//--# Retorna o total de memória usada sem eliminar nada
long memoriaFinal = System.GC.GetTotalMemory(false);

long memoriaUtilizada = memoriaFinal - memoriaInicial;
TimeSpan tempoDecorido = horaFinal - horaInicial;

MessageBox.Show("Usou " + memoriaUtilizada + " de memória e demorou " + tempoDecorido.Milliseconds + “ms");


{
string concatenacao = new StringBuilder().Append("Indice ")
.Append(iteracao).Append(" palavra1 ").Append("palavra2").ToString();
}





Plataforma .Net – StringFormat

{
string concatenacao = string.Format("{0} {1} {2} {3}", "Indice", iteracao, "palavra1", "palavra2");
}





Plataforma .Net – Resultados

Operador Memória utilizada Tempo decorrido
+ (mais) 606744 14ms
StringBuilder 3048628 23ms
StringFormat 1720620 27ms

Vamos definir o tamanho do baffer inicial para o StringBuilder e tentar aumentar o
desempenho.


{
string concatenacao = new StringBuilder(30).Append("Indice ")
.Append(iteracao).Append(" palavra1 ").Append("palavra2").ToString();
}





Plataforma .Net – Resultados

Operador Memória Memória Tempo decorrido Tempo decorrido
utilizada antiga utilizada antigo
+ (mais) 606744 606744 15ms 15ms
StringBuilder 3048628 2229004 23ms 18ms
StringFormat 1720620 1720620 27ms 28ms

Vamos alterar agora para utilizar o operação “+” para concatenação em várias linhas
e fazer uma tabela final para verificar quem é efetivamente mais rápido.



{
string concatenacao = "Indice “;
concatenacao = concatenacao + iteracao;
concatenacao = concatenacao +" palavra1 “;
concatenacao = concatenacao + "palavra2";
}





Plataforma .Net – Conclusão
• Operador + é o melhor para concatenação, em uma mesma linha, devido
a otimização.

• StringBuilder é o melhor quando precisa construir strings. Nem pense em
fazer concatenação em várias linhas. O StringBuilder ocupa mais memória
mas é mais rápido.

• StringFormat é o melhor para formatar Strings.

• O importante é usar cada operador para seu respectivo objetivo.

Plataforma .Net – Conclusão
• Vai concatenar várias strings em uma mesma linha? Use o operador “+”.
String concatenacao = “palavra1” + “palavra2”;

• Vai concatenar várias strings em várias linhas? Não use o operador “+”:
String concatenacao = “palavra1”;
concatenacao = concatenacao + “palavra2”;

• Vai concatenar várias strings em várias linhas? Use o StringBuilder:
String concatenacao = new
StringBuilder().Append(“palavra1”).Append(“palavra2”).ToString();

• Quer formatar uma string? Use o string.format
String concatenacao = string.format(“{0} {1}”, “palavra1”, “palavra2”);

Framework .Net: Aula 10 – Segunda-feira

Agenda
• Expressões regulares: introdução
– O que são
– Como criá-las e manipulá-las
– Como utilizar expressões regulares em C#
• Revisão e dúvidas

Plataforma .Net – Expressões regulares
Introdução
Definição
Origem
Aplicações
Metacaracteres
– Representantes
– Quantificadores
– Âncoras
Let´s code
Debate e esclarecimentos

Quantos de nós já necessitaram fazer manipulação ou pesquisas em textos?
Quantos perderam horas com ifs e fors tentando procurar palavras baseadas
em um determinado padrão?

As expressões regulares, quando bem aplicadas e refinadas, permitem
manipular textos de forma rápida e precisa.

Infelizmente não existe um vasto material sobre este assunto em português.
A maioria não é muito didática na hora de explicar os conceitos e aplicar na
prática.
Isto faz com que poucos desenvolvedores dominem este poderoso assunto
que bem aplicado economiza horas de desenvolvimento.

Um dos melhores materiais, didáticos, em português (se não o melhor) sobre este
assunto é o livro em que a maior parte teórica, sobre expressões regulares, desta
apresentação está embasada: Expressões regulares – Uma abordagem divertida de
Aurélio Marinho Jargas.

A maioria do material sobre expressões regulares em português encontrado na
internet é baseado no livro dele.

Esta apresentação irá introduzi-lo neste assunto, fazendo expressões como *[A-Za-z0-
9_]+:(.*)..$ se tornarem compreensivas e não lhe causar pânico.

Em toda apresentação, o que estiver entre aspas duplas foi copiado na integra do livro

“CURIOSIDADE: apesar de esse assunto ser antigo, o que vamos ver aqui basicamente
é o mesmo que um estudante veria há 15 anos atrás. É um conceito consistente, que
não sofre alterações com o passar do tempo.”

Plataforma .Net – ER: Definição
“Uma expressão regular é um método formal de se especificar um padrão de texto.”

De forma simplificada, uma regular expression, termo original, é uma composição de
símbolos e caracteres literais com funções definidas que quando agrupadas em
sequência formam uma expressão.
Essa, por sua vez, é interpretada, por um programa, como uma regra que resultará em
sucesso caso uma entrada de dados atenda suas condições.

Também podemos afirmar que é:
• “uma maneira de procurar um texto que você não lembra exatamente como é,
mas tem ideia das variações possíveis;
• uma maneira de procurar um trecho em posições específicas como no começo ou
no fim de uma linha, ou palavra;
• uma maneira de um programador especificar padrões complexos que podem ser
procurados e casados em uma cadeia de caracteres”;

Plataforma .Net – ER: Origem
Surgiu em 1943 com um estudo que
teorizava o funcionamento dos nossos
neurônios

Em 1968 foi para o computador em um
algoritmo de busca para um editor
chamado qed

O qed virou ed (Editor Unix) que devido a
seu comando de executar expressões
regulares originou o famoso grep que por
sua vez originou o egrep.

Plataforma .Net – ER: Aplicações
“Basicamente servem para você dizer algo abrangente de forma específica. Definido seu
padrão de busca, você tem uma lista (finita ou não) de possibilidades de casamento. Em um
exemplo rápido, [rgp]ato pode casar rato, gato e pato. Ou seja, sua lista "abrange
especificamente" essas três palavras, nada mais.”

Sempre que precisar efetuar buscas ou validações em textos, as expressões regulares
funcionam muito bem. Alguns exemplos de buscas por padrões, em textos, são:
• data
• horário
• número IP
• endereço de e-mail
• endereço de Internet
• dados na coluna N de um texto
• dados que estão entre <tags></tags>
• campos específicos de um texto tabulado
• número de telefone, RG, CPF, cartão de crédito

Plataforma .Net – ER: Metacaracteres
São símbolos com funções específicas utilizados para montar as expressões regulares.

Existem vários tipos de metacaracteres, os básicos serão estudados nesta apresentação:
– Representes: representam um ou mais caracteres
– Quantificadores: indicam o número de repetições permitidas para o caractere anterior
– Âncoras: marcam uma posição específica na linha

Plataforma .Net – ER: Representante
Ponto: o necessitado .

“O ponto é nosso curinga solitário, que está sempre à procura de um casamento, não importa com
quem seja. Pode ser um número, uma letra, um TAB, um @, o que vier ele traça, pois o ponto casa
qualquer coisa.”

Lembre-se: o ponto aceita qualquer caractere.

Lista: a exigente [...]

“Bem mais exigente que o ponto, a lista não casa com qualquer um. Ela sabe exatamente o que
quer, e nada diferente daquilo, a lista casa com quem ela conhece.”

No exemplo anterior, com a palavra não, a expressão n.o, poderia aceitar várias palavras como n
o, n1o, noo, njo...
Para deixá-la mais específica poderíamos usá-la assim: n[ãa]o



No exemplo anterior, com a palavra não, a expressão n.o, poderia aceitar várias palavras como n
o, n1o, noo, njo...

O ponto não aceita
qualquer coisa?
Dentro da lista, todos
os caracteres são
normais



No exemplo anterior, com a palavra não, a expressão n.o, poderia aceitar várias palavras como n o,
n1o, noo, njo...

O ponto não aceita
qualquer coisa?
Dentro da lista, todos
os caracteres são
normais, exceto o
traço.


O traço, dentro da lista, é usado para definir intervalos: [0123456789] é igual a [0-9]

Estes intervalos podem ser usados para letras também: a-z, A-Z, 5-9, a-f, :-@, ...

“Os intervalos respeitama ordem numérica da tabela ASCII”

Como colocar o traço e os colchetes
dentro da lista se eles são
metacaracteres?

O traço colocamos no final da lista sozinho;
O colchete de abertura ( [ ) pode colocar em qualquer lugar;
O colchete de fechamento ( ] ) deve ser colocado no começo da lista;

Exemplo: [ ][ - ]


O traço, dentro da lista, é usado para definir intervalos: [0123456789] é igual a [0-9]

Estes intervalos podem ser usados para letras também: a-z,a-z não entram ...
Peraí! Na tabela ASCII A-Z, 5-9, a-f, :-@,
as palavras acentuadas, e agora?
“Os intervalos respeitama ordem numérica da tabela ASCII”
Dá para resolver isto com alguns
Como colocar o traço e os colchetes
curingas, mas...
dentro da lista se eles são
...Vamos conhecer as metacaracteres?
classes de
caracteres POSIX
O traço colocamos no final da lista sozinho;
O colchete de abertura ( [ ) pode colocar em qualquer lugar;
O colchete de fechamento ( ] ) deve ser colocado no começo da lista;

Exemplo: [ ][ - ]


Os colchetes fazem parte
da classe POSIX.

Uma classe dentro de
uma lista ficaria assim:
[[:upper:]]

IMPORTANTE: As classes
POSIX levam em
consideração a
localidade.

Lista negada: a experiente [^...]

“Não tão exigente quanto a lista nem tão necessitada quanto o ponto, temos a lista negada, que
pelas suas más experiências passadas, sabe o que não serve para ela casar.”

A lista negada é igual a lista comum, a única diferença é que ela aceitará todos os caracteres que
NÃO tiverem dentro da lista.
Ex: l[^aeioAEIO]a – lua, l1a, lpa...

Importante: A lista negada não casa com espaço vazio. No exemplo acima ela NÃO aceitaria “l a” (l
espaço a).

Como colocar o ^ dentro da lista se ele também é um metacaracter?

Deve ser colocado no final. Ex: [^a-z123^]

Plataforma .Net – ER: Quantificador
Opcional: o opcional ?

“O opcional é um quantificador que não esquenta a cabeça, para ele pode ter ou não a ocorrência
da entidade anterior, pois ele a repete 0 ou 1 vez.”

Já estamos aceitando algo abrangente de forma específica. Lembra do slide “Aplicações”?

Asterisco: o tanto faz *

“Se o opcional já não esquenta a cabeça, podendo ter ou não a entidade anterior, o asterisco é
mais tranqüilo ainda, pois para ele pode ter, não ter, ou ter vários, infinitos. Em outras palavras, a
entidade anterior pode aparecer em qualquer quantidade.”

Um curinga na manga
Vimos o metacaractere . (ponto) que aceita qualquer caractere. Agora vimos o metacaractere *
(asterisco) que aceita em qualquer quantidade. Olhe e pense na seguinte expressão:

.*

Mais: o tem-que-ter +

“A única diferença [do mais e do asterisco] é que o mais não é opcional, então a entidade anterior
deve casar pelo menos uma vez, e pode ter várias.”

Simples, não?!

Chaves: o controle {m,m}

“Aqui Chaves não é o au?tor mexicano preferido de 10 entre 10 brasileiros. As chaves são a solução
para uma quantificação mais controlada, onde se pode especificar exatamente quantas repetições
se quer da entidade anterior.”

EX: a{1,2} – a, aa
b{0,2}a – a, ba, bba

Plataforma .Net – ER: Âncora
Circunflexo: o início ^

“O nosso amigo circunflexo (êta nome comprido e chato) marca o começo de uma linha. Nada
mais.”

Dentro da lista (e no início) o ^ tem o objetivo de negar seu conteúdo. Fora da lista ele serve para
marcar que a palavra deve ser encontrada exatamente no início da linha. EX: ^[a-zA-Z].

Este metacaractere só é especial se tiver no começo da expressão regular. Se eu quiser procurar
uma palavra que começe com ^ poderia fazer assim:

^^

Plataforma .Net – Testando memória
Iremos fazer a seguir 4 exercícios simples de fixação. A resposta estará no próximo slide.
Tente resolve-los antes de prosseguir.

Escreva uma expressão regular que:

1. Reconheça a palavra carro minúscula, no plural, singular e em qualquer parte de um
texto.

2. Reconheça a palavra casa em qualquer combinação de maiúscula, minúscula e em
qualquer parte de um texto.

3. Reconheça um número de IP, que aceite 999.999.999.999
Dica: O metacaracter “” torna outro metacaractere literal.
OBS: Sabemos que não existe um IP assim, foi usado aqui apenas para iniciar de forma
simples o entendimento da aplicação de expressões regulares e os operadores aprendidos
nesta parte.

Plataforma .Net – Testando memória
Iremos fazer a seguir 4 exercícios simples de fixação. A resposta estará no próximo slide. Tente resolve-
los antes de prosseguir.

Escreva uma expressão regular que:

1. Reconheça a palavra carro minúscula, no plural, singular e em qualquer parte de um texto.
carros?

2. Reconheça a palavra casa em qualquer combinação de maiúscula, minúscula e em qualquer parte de
um texto.
[cC][aA][sS][aA]

3. Reconheça um número de IP, que aceite 999.999.999.999
Dica: O metacaracter “” torna outro metacaractere literal.
OBS: Sabemos que não existe um IP assim, foi usado aqui apenas para iniciar de forma simples o
entendimento da aplicação de expressões regulares e os operadores aprendidos nesta parte.
[0-9][0-9]0-9].[0-9][0-9]0-9].[0-9][0-9]0-9].[0-9][0-9]0-9]

Plataforma .Net – ER em C#

using System.Text.RegularExpressions;

string texto= “Conteúdo a ser lido";
Regex regex = new Regex(“expressao_regular");
if (regex.IsMatch(texto))
// Encontrou
else
// Não encontrou

No site existe um exemplo para download codificando o trecho de código acima.

Framework .Net: Aula 11 - Terça-feira

Agenda
– Introdução a coleções
– Introdução a expressões lambdas aplicado a coleções
• Revisão da semana e feedback

Plataforma .Net – Vetores
• Vetor ou array é uma estrutura de dados estáticas, ou seja, é criada com
um número determinado de itens.

• Quando criamos um vetor de 100 posições, por exemplo, é alocado em
memória os 100 espaços que será utilizados.

• O tempo de acesso a um vetor é bem rápido, porém ao redefinir o
tamanho de um vetor temos uma considerável perda de desempenho, pois
é necessário realocar dentro da memória o novo tamanho do vetor.

• É recomendado o uso de vetores para itens que não mudarão ao longo da
utilização da aplicação.

String[] colecao = new String [10]; // Array de Strings

Plataforma .Net – Listas
• Listas é uma estrutura de dados dinâmicas, ou seja, é criada sem saber o número
total de itens.

• Quando criamos uma lista e adicionamos um valor (uma posição), por exemplo, é
alocado em memória apenas 1 espaço que é justamente o que foi utilizado.

• O tempo de acesso a uma lista é um pouco maior que um array, porém ao redefinir
o tamanho, ou seja adicionar novos itens, não ocorre perda de desempenho, pois
não é necessário realocar a lista na memória e sim apenas criar um novo item.

• As listas genéricas podem ser usadas com qualquer tipo de dado sem problema de
boxing e unboxing, permitem uma leitura mais legível e disponibiliza recursos que o
array não tem. Vamos conhecer mais...

List<String> colecao = new List<String>(); // Lista de Strings

Plataforma .Net – Usando listas
• Criando uma lista
List<String> colecao = new List<String>();

• Adicionando um valor
colecao.Add("valor");

• Removendo um valor
colecao.Remove("valor");

• Descobrindo o tamanho da lista
int tamanho = colecao.Count;

• Adicionando um valor em uma determinada posição
colecao.Insert(0, "valor");

• Convertendo para um array
string[] novaColecao = colecao.ToArray();

• Verificando se um item existe na lista
bool existeItem = colecao.Contains("valor");

Plataforma .Net – Percorrendo listas
• Usando for
for (int i = 0; i < colecao.Count; i++)
{
String item = colecao[i];
}

• Usando foreach
foreach (String item in colecao)
{

}

Plataforma .Net – Introdução a lambda
• Desde a versão 3.0 do C# é utilizado um recurso extremamente útil para
trabalhar com coleções e com linq.

• De forma simplista uma expressão lambda é uma função escrita de uma
forma simplificada, sem nome e representada em uma instrução de uma
linha.

• Forma básica de uma expressão lambda:
( parâmetros de entrada ) => { expressão baseada nos parâmetros }

• Vamos ver na prática para entendermos melhor como funciona.

List<String> colecao = new List<String>();

colecao.Add("valor");

• Verificando se um item existe na lista usando lambda
bool existeItem = colecao.Exists(item => item == "valor");

• Descobrindo índice de um valor na lista usando lambda
int indice = colecao.FindIndex(item => item == "valor");

List<Pessoa> colecao = new List<Pessoa>();

colecao.Add(new Pessoa(“Fulano”, Sexo.Masculino));

• Verificando se uma pessoa do sexo masculino existe na lista usando lambda
bool existeItem = colecao.Exists(pessoa => pessoa.sexo == Sexo.Masculino);

• Buscando uma pessoa com nome igual a Fulano e sexo masculino
Pessoa pessoa = colecao.Find(pessoa => pessoa.nome == “Fulano“ &&
pessoa.sexo = Sexo.Masculino);

Referências
• Web:
– http://www.msdn.com
– http://www.portaleducacao.com.br/informatica/artigos/6137/historia
-e-caracteristicas-da-linguagem-c
– http://en.wikipedia.org/wiki/.NET_Framework
– http://en.wikipedia.org/wiki/Singularity_(operating_system)
– http://en.wikipedia.org/wiki/Cosmos_(operating_system)
– http://www.mono-project.com/Main_Page
– http://singularity.codeplex.com
– http://cosmos.codeplex.com/
– http://geekswithblogs.net/BlackRabbitCoder/archive/2010/05/10/c-
string-compares-and-concatenations.aspx

Referências
• Livros
– Código limpo – Habilidades Práticas do Agile Software (Robert Martin)
– Certificação .Net: Application Development Foundation (Microsoft)
– Expressões regulares – Uma abordagem divertida

DotNet Framework e Orientação a Objetos 1 - Introdução

Mais conteúdo relacionado

Mais procurados

Semelhante a DotNet Framework e Orientação a Objetos 1 - Introdução

Mais de Lorival Smolski Chapuis

Último

DotNet Framework e Orientação a Objetos 1 - Introdução