Essa vale a pena compartilhar. Basta imprimir uma folha e ter uma WebCam que você poderá ver ser PaperToy “Virtual”. Veja abaixo o que você pode fazer:

Papervision - Augmented Reality (extended) from Boffswana on Vimeo.

Para pegar o arquivo necessário para imprimir e ver o flash montar esse Papertoy “Virtual” acesse o link e veja o quanto essa aplicação é interessante.

Vou mostrar hoje como utilizar Linq To SQL juntamente com o MVC para .NET Framework.

Não irei abordar neste post detalhes do que é Linq To SQL, nem mesmo aspectos relativos ao MVC para .NET, pois, a internet está cheia dessas informações. O principal objetivo deste post é mostrar como realizar o mapeamento de uma tabela, listar as informações, inserir, alterar e excluir registros usando Linq To SQL.

Irei dividir o post em duas partes:

Parte I

• Criação do projeto;
• Criação da classe Linq to SQL;
• Mapeamento do banco;

Parte II

• Inserção de valores;
• Atualização;
• Exclusão;
• Listagem de informações

Criação do projeto

Bom, vamos começar criando um projeto, no meu caso irei criar um projeto MVC Web application, mas você pode ficar a vontade e criar o projeto que quiser, pois, o processo de utilização do Linq é o mesmo.

Criação da Classe Linq to SQL

Assim que criarmos o projeto, devemos criar uma classe do tipo Linq to SQL. Para isso, clique com o botão na pasta Models (criada automaticamento com o MVC Web Application, ou se for um projeto comum crie dentro do App Code), Add new item, clique no sub-item Data e escolha um objeto do tipo Linq to SQL Classes. Dê o nome do arquivo de Estudo.dbml.

Mapeamento da tabela do projeto

Assim que criarmos uma classe do tipo Linq to SQL Classes, devemos criar a conexão com banco de dados.

Use o Server Explorer para conectar a base de dados, assim que a conexão for estabelecida, abra o item tables e arraste a tabela que deseja mapear. Para mapear diferentes tabelas basta arrastá-las para o Estudo.dbml (LinqToSQL Classes)

No meu caso, eu mapeie uma tabela que possui a seguinte estrutura:

Nome da Tabela: tb_cidade
Campos: cidade_pk, nome_cidade.

Com isso encerramos a primeira parte. Aguarde pela Parte II em breve, onde iremos listar, inserir, alterar e excluir informações usando LinqToSQL.

Espero que tenham gostado.

Neste novo artigo da série C# para iniciantes, irei falar sobre Operadores. No C# temos os seguintes tipos de operadores:

• Atribuição;
• Aritméticos;
• Relacionais;
• Lógicos.

Operadores de Atribuição

Operadores de atribuição são utilizados para setar valores a determinadas váriaveis. No C# possuímos os seguintes operadores de atribuição.

= (Atribuição simples)
+= (Atribuição aditiva)
-= (Atribuição Subtrativa)
*= (Atribuição Multiplicativa)
/= (Atribuição de divisão)
%= (Atribuição de módulo)

Exemplos:

//Atribuição Simples
// Define-se um valor para a variavel i, neste caso 50
int i = 50;

//Atribuição de Adicição
//Este operador "+=" equivale a (i = i + x), portanto o valor de i será 100
int i = 50;
int x = 50;

i += x;

//Atribuição de Subtração
//Este operador "-=" equivale a (i = i - x), portanto o valor de i será 0
int i = 50;
int x = 50;

i -= x;

//Atribuição de Multiplicação
//Este operador "*=" equivale a (i = i * x), portanto o valor de i será 2500
int i = 50;
int x = 50;

i *= x;

//Atribuição de Divisão
//Este operador "/=" equivale a (i = i / x), portanto o valor de i será 1
int i = 50;
int x = 50;

i /= x;

//Atribuição de Módulo ou Resto
//Este operador "%=" equivale a (i = i % x) onde neste será retornado o resto da divisão, portanto o valor de i será 0
int i = 50;
int x = 50;

i %= x;

Operadores Aritméticos

Como o próprio nome sugere, esses operadores são utilizados para realizar cálculos aritméticos. No C# possuímos os seguintes operadores aritméticos:

+ (Adição)
- (Subtração)
* (Multiplicação)
/ (Divisão)
% (Módulo/Resto)

Exemplos:

//Adicição
//A váriavel i possui o valor 60
int i = 50 + 10;

//Subtração
//A váriavel i possui o valor 40
int i = 50 - 10;

//Multiplicação
//A váriavel i possui o valor 500
int i = 50 * 10;

//Divisão
//A váriavel i possui o valor 5
int i = 50 / 10;

//Módulo ou Resto
//A váriavel i possui o valor 0
int i = 50 % 10;

Operadores Relacionais

Os operadores relacionais são utilizados nas expressões relacionais, estas sempre retornam um valor booleano: Verdadeiro ou Falso. O C# possui os seguintes operadores relacionais:

== (Igualdade)
> (Maior)
< (Menor)
<= (Menor igual)
>= (Maior igual)
!= (Diferente)

Exemplos:

int i = 30;
int x = 20;

//Igualdade
//O resultado será Falso
i == x

//Maior
//O resultado será Verdadeiro
i > x

//Menor
//O resultado será Falso
i < x

//Maior ou igual
//O resultado será Verdadeiro
i >= x

//Menor ou igual
//O resultado será Falso
i <= x

//Diferente
//O resultado será Verdadeiro
i != x

Operadores Lógicos

Os operadores lógicos são utilizados para combinar diferentes comparações. Esses são os operadores lógicos do C#:

&& (E)
|| (OU)

Exemplos:

int i = 1;
int x = 3;

//Operador && (E)
//Utilizando o operador && (E), esta condição será Falso
bool resultado = i > x && x < 5;

//Operador || (OU)
//Utilizando o operador || (OU), esta condição será Verdadeiro
bool resultado = i > x || x < 5;

Ainda existem os operadores de Incremento (++) e Decremento (–), estes são responsáveis por adicionar/subtrair o valor 1, a uma determinada váriavel.
Espero que tenham gostado. Em breve tem mais.

Bom, pode até parecer estranho, mas eu nunca precisei enviar um e-mail com autenticação, isso até hoje.
Me deparei com este simples problema e acho interessante compartilhar com todos como pode ser feito o envio de e-mails em servidores de SMTP que requerem autenticação.
Utilizando a namespace System.Net.Mail ficou muito simples o envio com autenticação. Veja o exemplo abaixo:

//Crie o email
MailMessage mail = new MailMessage();

//Adicione os endereços de e-mail
mail.From = new MailAddress("teste@teste.com.br");
mail.To.Add("teste@teste.com.br");

//Adicione o conteúdo do e-mail
mail.Subject = "Este é o Assunto";
mail.Body = "Este será o corpo do e-mail.";

//Crie o STMP de acordo com suas configurações
SmtpClient smtp = new SmtpClient("localhost");

//Para autenticar, basta setar o usuário e a senha do servidor de SMTP
smtp.Credentials = new NetworkCredential("usuario", "senha");

//Envie o e-mail
smtp.Send(mail);

Bem simples hein! Espero que tenham gostado.
Em breve tem mais.

Dando sequência a série de post’s sobre POO iremos abordar agora sobre conceitos essenciais da POO e para falar sobre esse assunto irei dividi-lo nas seguintes partes:

• Objeto;
• Herança;
• Encapsulamento;
• Polimorfismo;
• Classes;
• Relacionamentos;
  • Agregação;
  • Generalização;
  • Associações N(Árias)
  • Abstração

Neste post iremos detalhar os seguintes itens: Classe e Objeto, já no próximo post serão descritos os itens: Herança, Encapsulamento e Polimorfismo e os demais itens em sequência.

No post Programação Orientada a Objeto - O início nós já percebemos que a POO, veio para auxiliar a solução de problemas, através da modelagem do problema no meio computacional. Essa modelagem é feita através de objetos.

Nosso mundo é composto por objetos e cabe a nós desenvolvedores entendermos quais são os objetos necessários na resolução de um determinado problema.

Bom, mas como definimos um objeto? Basta dizer que um objeto é do tipo de uma determinada classe.

Antes que isso fique complicado, vamos tentar explicar de uma forma mais simples a idéia básica do assunto.

Primeiro definimos quais são as classes do nosso sistema (Ex: Carro, Pessoa, Movimento). Assim que as classes forem definidas podemos utilizar os itens herança e polimorfismo para conseguirmos um melhor mapeamento dessas classes. A partir do momento em que você utiliza classes para criar uma instância da mesma (Ex: Carro meuCarro = new Carro() - a sintaxe não é a mesma para qualquer linguagem de programação), então você tem um objeto de um determinado tipo, neste caso um objeto do tipo Carro.

Vamos agora detalhar um pouco mais cada um desses itens.

Classe

No mundo atual existem carros e cada carro possui uma particularidade, mas todos possuem a mesma estrutura e comportamento. A definição de um modelo que descreve essa estrutura e esses comportamentos é nomeado como uma Classe.

Por exemplo, a classe Carro possui a estrutura com: cor, altura, comprimento. Os comportamentos que um carro pode ter são: andar(), virarDireita(), virarEsquerda(), parar().

Objeto

Uma vez definida a classe do tipo Carro, fica mais fácil criar objetos que utilizem desta mesma estrutura. Basta instanciar N objetos do tipo Carro que teremos, carros diferentes, porém, com estrutura e comportamento iguais.

O objeto é alguma coisa com limites bem definidos e significados bem claros dentro de uma aplicação, ou seja, é a instancia de alguma classe.

Grady Booch colocou uma definição para objeto: “Um objeto possui um Estado, Comportamento e uma Identidade”.

Entendendo esses 3 pontos:

1. Identidade: Todo objeto possui uma identidade. Por exemplo, um novo objeto - Carro meuCarro = new Carro() - é um objeto com a identidade meuCarro;
2. Estado: O estado são as estruturas de um objeto. Por exemplo, o objeto meuCarro possui o atributo cor. Quando definimos um valor para esse atributo, nós definimos isso como estado. meuCarro.cor = Azul;
3. Comportamento: Acima, nós também vimos os comportamentos de um objeto (andar, virarDireita). Quando nós chamamos esses ‘métodos’ de um objeto, ele realiza a ação que lhe foi solicitada. meuCarro.virarDireita();

Fechamos assim a descrição desses 2 pontos que são de muita importância na POO. É claro que estes conceitos são bem básicos, até mesmo porque esse assunto é bastante complexo.

Em breve estarei falando um pouco de Herança, Polimorfismo e Encapsulamento.

Até o próximo post.

Continuando a série de post’s para guia de consulta rápida, iremos finalizar a série de estrutura de dados falando sobre estruturas de repetição.

Diferente das estruturas condicionais, onde um determinado código é executado apenas uma vez, as estruturas de repetição tem como objetivo executar um determinado bloco de código até que uma determinada condição seja alcançada.

Bom, existem 4 estruturas de repetição no C#, são elas:

Estrutura de Repetição

For

Toda estrutura For é constituída de uma variável de inicialização, uma condição e o incremento. No exemplo abaixo podemos observar a inicialização: int i = 0, a condição: i < 10 e o incremento i++, sendo o “;” separador desses atributos.
Exemplo:

for (int i = 0; i < 10; i++)
{
   ... código ...
}

While

A estrutura While é bem mais simples que o for, pois, nele não é necessário declarar uma variável de inicialização, nem mesmo o incremento, somente é necessário declarar a condição de parada da repetição. Mas lembre-se que apesar de você não precisar declarar o incremento, você tem que preocupar com a condição, pois, caso a condição não seja falso em algum momento, você irá criar um loop infinito.
Exemplo:

while(i < 10)
{
   ... código ...
}

Do … While

O Do … While é muito semelhante à estrutura While, tendo como principal diferença a inicialização da estrutura, pois no While existe a possibilidade do código não ser executado nenhum vez (lógico que isso será vinculado ao resultado da condição), já no Do … While o código escrito dentro da estrutura será executado pelo menos uma vez, isso porque a verificação é realizada apenas no final da estrutura.
Exemplo:

do
{
   ... código ...
}
while(i != 10);

Foreach

A estrutura Foreach é utilizada para percorrer coleções ou arrays. Sua estrutura é formada pelo tipo de dado: string (porque estamos percorrendo um array de strings), o nome da variável: marca e a lista a ser percorrida: carros.
Exemplo:

string[] carros = {"Mercedes", "Ferrari", "Gol", "Palio"};
foreach (string marca in carros)
{
   Console.WriteLine("{0} ", marca);
}

Bom, com isso fechamos a estrutura de dados no C#. Podemos é claro misturar estruturas condicionais e estruturas de repetições para criar algoritmos cada vez melhor.

Espero que tenham gostado. Até o próximo post.

Seguindo a idéia de post’s para guia de consulta rápida, irei falar um pouco da estrutura de dados do C#, mais especificamente Estruturas Condicionais.

A criação de algoritimos visá à manipulação de dados para obter algum tipo de informação. Quando estes dados estão organizados de forma coerente, caracterizam uma forma, ou seja, uma estrutura de dados.

Estruturas Condicionais

If Then Else

Exemplo:

if (condição)
{
  ...código...
}elseif(condicao){
  ...código...
}else{
  ...código...
}

No C# existe também o IF-Inline:

Exemplo:

/***
* If-inline é definido da seguinte forma:
* Se condição for VERDADEIRA, então
* retorna valor1, senão
* retorna valor2
***/

int NumeroPar = 2;
int NumeroImpar = 3;

int numero = (NumeroPar > NumeroImpar) ? NumeroPar : NumeroImpar;
int numero = (condicao) ? valor1 : valor2;

Switch/Case

Exemplo:

int Numero = 2;
switch(Numero){
	case 1:
		..código...
	        break;
        case 2:
                ..código...
                break;
        case 3:
                ..código...
                break;
        default:
                ..código...
                break;
}

Estas estruturas sempre são utilizadas quando necessitamos tomar algum fluxo, mediante a uma condição ou um valor pré-definido.

Mas quando utilizarmos cada uma delas? Sempre que nós soubermos os valores das condições devemos utilizar o Switch/Case, já quando necessitarmos realizar alguns testes lógicos ou testes aritiméticos onde o valor não é exatamente conhecido, devemos utilizar o If Then Else.

Na próxima iremos ver estrutura de repetição ou estrutura de loop. Espero que tenham gostado. Em breve tem mais.

Toda linguagem de programação possui seus tipos de dados primitivos, incluindo o C#. No Java existem somente 8 tipos de dados primitivos : Boolean , Char , byte , short , int , long , float , double.

Mas o que são os tipos de dados primitivos? Tipos de dados primitivos são os dados suportados diretamente pelo compilador. Esses dados possuem palavras chaves para facilitar sua utilização durante a implementação de um sistema.

Por exemplo, a palavra chave string mapeia diretamente o tipo System.String e o bom conhecimento destes tipos auxilia no desenvolvimento e pode impactar no desempenho de seu sistema.

Segue abaixo um tabela com as palavras chaves, tipos associados a cada uma delas e a faixa de valores que cada tipo aceita.

Bom, este post segue como um guia de consulta rápido e irei montar mais post nestes formatos em breve.

Espero que tenham gostado e aguardem por mais.

Hoje vou iniciar uma série de post’s que tem como objetivo introduzir os conceitos básicos de POO (Programação Orientada a Objeto), a plataforma .NET e em sequência alguns pontos mais avançados sobre esses assuntos.

Vou escrever essa série de post’s em virtude do meu trabalho (não posso entrar em detalhes agora, mas irei dar notícias a todos em breve). O principal foco dos post’s serão desenvolvedores que desconhecem programação orientada a objeto.

Não irei abordar neste post os conceitos de POO como Objeto, Herança e Classe, porque antes de entrar em detalhes sobre esses pontos, primeiro devemos entender o porque do surgimento da POO.

O início da POO

Um dos criadores deste conceito de linguagem de programação foi Alan Kay, também conhecido por ter criado a linguagem de programação Smalltalk.

A criação deste conceito se deve em grande parte as linguagens de programação mais antigas como Fortran, C, Pascal também conhecidas como linguagens de programação procedimentais, ou seja, imagine uma lista de instruções onde cada linha que é executada realiza uma tarefa, por exemplo, cria uma variável, adiciona uma valor a variável, exibe um resultado.

Esse contexto em uma situação onde se tem um sistema pequeno, talvez não seja um problema, mas a medida que o sistema cresce e consequentemente a lista de instruções cresce, a execução/manutenção desta lista poderá se tornar uma tarefa um tanto quanto difícil.

Uma tentativa de minizar o problema é dividir o código do sistema em pequenas partes, denominadas de funções. A quebra do código em funções e o agrupamento dessas funções pela semelhança de suas ações, são um dos fundamentos da programação estruturada e até mesmo este paradigma de programação mostra limitações a medida que o sistema cresce.

Com esse problema surgiu a necessidade da criação de uma linguagem de programação que resolvesse este problema. Aí surge o conceito de POO.

O problema e a solução

Bom, então já temos um problema: Situações que requerem um sistema um tanto quanto robusto e grande, possuem problemas para implementação de soluções com as linguagens de programação procedimentais ou pela programação estruturada. Então como resolver isso?

A utilização de programação orientada a objeto ou como alguns chamam modelagem orientada a objeto requer a identificação deste problema e o mapeamento da solução na forma de objetos.

A POO foi criada com o objetivo de tentar aproximar ao máximo o mudo real do mundo computacional. Mas como isso é feito? Mapeando todos os objetos.

O nosso mundo é constituído de objetos e esses objetos possuem estados, comportamentos e cada um tem sua própria identidade. A POO vem para auxiliar na descrição dos objetos de um problema da forma real, para a forma computacional.

Bom, então podemos definir como a principal característica da programação orientada a objeto a modelagem de um problema do mundo real, para um mapeamento dos objetos destes problemas no mundo computacional, visando facilitar a criação de uma solução.

Bom, espero que tenham gostado.

A Microsoft Patterns e Practices liberou a versão Beta 1 do Application Architecture Guide 2.0 que fornece orientação a nível de design para a arquitetura e design de aplicações desenvolvidas com base no Framework .NET.

Essa versão beta está dividida em 5 partes, sendo que estas partes possuem ao todo 24 capítulos:

Partes

Parte I: Fundamentals of Application Architecture;
Parte II: Design;
Parte III: Layers;
Parte IV: Quality Attributes;
Parte V: Archetypes - Design and Patterns;

Pra quem gosta do assunto e está interessado em fazer o download do livro segue o link. Eu particularmente ainda não tive tempo de ler, mas assim que possível irei ler.

Espero que tenham gostado.