INFOESTE 2011 – 23ª Semana de Computação e Informática da FIPP/Unoeste

Bom pessoal,

Faz um tempo que não passamos aqui pelo blog, realmente a correria está muito grande, graças a Deus com muito trabalho para todos nós.
Gostaríamos de informar (com atraso) sobre a 23ª INFOESTE que começou ontem!
Este evento é muito bom para que os alunos das instituições de ensino superior da região possam fortalecer seu networking além de participarem de diversos mini-cursos e palestras que ocorrem no evento.

Aproveitando o assunto, a WebFinal foi convidada pelo Coordenador do curso de Sistemas para Internet Marcelo Rosa para ministramos um minicurso no evento.
Gostaríamos de deixar formalizado aqui o nosso muito obrigado pelo convite e agradecer ao coordenador pelo reconhecimento pela nossa dedicação na área.

O minicurso que estaremos fornecendo terá a duração de 7horas e será ministrado hoje e amanhã das 19:00 as 22:30.

Segue abaixo um pouco sobre o que abordaremos no curso:
MC-029: Descomplicando o desenvolvimento de aplicações robustas utilizando as tendências da Web

Durante este curso serão apresentadas as novas tendências da WEB mostrando como elas podem nos auxiliar e fornecer uma melhor produtividade ao trabalho e no desenvolvimento de aplicações robustas. Será abordado o desenvolvimento para WEB utilizando HTML5 e CSS3 e tendo como linguagem de desenvolvimento e ferramenta de background todo o poder fornecido pelo ASP.NET MVC3 integrado ao Entity Framework 4

Aguardamos a presença de vocês lá e estaremos colocando todo material do minicurso no blog, conforme for se passando o tema.

Uma boa semana a todos!

Sexta .NET – Aula 14 – Ajax – Parte I

Bom pessoal, vamos aqui com mais uma Sexta .NET abordando um tema muito utilizado atualmente, o AJAX.

Para poder falar melhor sobre esta forma de desenvolvimento vamos fazer um roteiro.

Roadmap da Apresentação Visual

Convergência entre Web e Desktop

Aplicação Desktop

  • Interativa
  • Rápida
  • Difícil Implantação
  • Desatualizada
  • Roda no Cliente

Aplicação Web

  • Estática
  • Lenta
  • Fácil Implementação
  • Sempre Atualizada
  • Roda no Servidor

Experiência do Usuário

Perguntas…
A web hoje é dinâmica?
O mesmo conteúdo é apresentado a todos os usuários?

Aplicações Web ainda perdem de aplicações Desktop
Alternativas:
Java Applets
SilverLight
Macromedia Flash

Problemas em uma aplicação Web

  • Post-backs forçam que a página seja recarregada a cada clique.
  • Não mantém o estado da página naturalmente (stateless).
  • Interfaces ricas são de difícil concepção.
  • “Lenta” em relação a aplicações de clientes ricos (desktop).

Solução para aplicações Web

  • RIA – Rich Internet Application
  • Web 2.0

AJAX Conceitos

AJAX = “Asynchronous Javascript And XML”.

É um conjunto de recursos e tecnologias, presentes há algum tempo, nas linguagens e navegadores atuais.

AJAX não é tecnologia. É um conjunto de técnicas que tem como objetivo promover uma melhor e mais rica experiência de uso.

AJAX faz uso das características da linguagem JavaScript, da portabilidade e flexibilidade do padrão XML e dos recursos de chamada assíncronas que foram implementadas nos navegadores.

AJAX – XMLHttpRequest

Objeto que a linguagem Javascript implementa e está presente nos navegadores : Internet Explorer 5.0+, Safari 1.2, Mozilla 1.0 / Firefox e Netscape7.

Tem a capacidade de executar a leitura remota de dados de forma assíncrona, permitindo assim a execução de outras tarefas imediatamente após a chamada.

Retorna dados em formato XML e Texto.

http://www.w3.org/TR/XMLHttpRequest/

Framework ASP.NET AJAX
Framework para criação de uma nova geração de aplicações web, com interfaces ricas, interativas, personalizadas e baseadas em padrões
Biblioteca de scripts para cliente
Componentes para servidor
Integra funções do cliente com funções do ASP.NET
Desenvolvimento de aplicações com “estilo AJAX”

UM FRAMEWORK PARA DESENVOLVER UMA EXPERIÊNCIA NA WEB MAIS RICA, INTERATIVA E PERSONALIZADA

Produtividade incrementada
Menos conceitos e complexidade
Menos linhas de código

Fácil de criar, debugar e manter
Perfeitamente integrado as ferramentas de design e desenvolvimento

Bom pessoal, hoje ficamos apenas com os conceitos desta tecnologia.
Semana que vem iremos iniciar a apresentação aos componentes do AjaxControlToolkit.

Aguardo vocês!

Sexta .NET – Aula 12 – ASP.NET e C# – Parte III

Boa tarde, continuando a aula anterior conforme prometido, aqui vamos com:

Sexta .NET – Aula 12 – ASP.NET e C# – Parte III

Falaremos nesta aula sobre: Nullable Types

  • Recurso da versão 2.0.
  • Variáveis continuam a representar todos os valores do seu tipo, e mais um valor adicional null.
  • Permite uma integração melhor com bancos de dados, que podem conter valores null em seus campos.
  • Declaradas através da classe Nullable, ou através do operador ? adicionado ao tipo à ser utilizado.

Podem ser declaradas de duas formas:
System.Nullable variavel;
? variavel;

Onde T é o tipo da variável
Ambas notações funcionam de maneira equivalente
Declarando e usando uma variável inteira e anulável

int? clienteId;
clienteId = 10; //Ok
clienteId = null; //Ok, clienteId é anulável

Qualquer tipo por valor pode ser usado como Nullable Type

int? i = 10;
double? x = 3.14;
bool? flag = null;
char? letra = 'a';
int?[] MeuArray = new int?[10];

Os exemplos seguintes não são tipos por valor, portanto não são aceitáveis como Nullable Types

string? variavel = “tipos anulaveis”;
Cliente? umCliente = new Cliente?();

O operador as só pode ser utilizado com tipos por referência, então não pode ser usado com Nullable Types

int clienteId = 5;
object b = clienteId;
// Erro em tempo de compilação
int? c = b as int;

Uma instância de um tipo anulável possui duas propriedades read-only

  • HasValue: do tipo bool, retorna verdadeiro quando uma variável contém um valor não-nulo.
  • Value: do tipo equivalente ao tipo anulável utilizado, se HasValue é true, então Value contém um valor significativo, senão, ao tentar acessar Value será gerada uma exception.

Utilizando as propriedades de um tipo anulável

int? clienteId = 10;
if (clienteId.HasValue)
Console.WriteLine(clienteId.Value);
else
Console.WriteLine(“Identificação Indefinida!”);

Conversões explícitas

  • Um tipo anulável pode ser convertido para um tipo regular usando casts ou usando a propriedade Value.
  • Se o tipo anulável contém o valor null, será gerada uma exception.

Conversões explícitas

// Exemplos
int? clienteId = null;
// Não compila
int x = clienteId;
// Compila, mas será gerada uma exception se x for null
int x = (int)clienteId;
// Compila, mas será gerada uma exception se x for null
int x = clienteId.Value;

Conversões implícitas
A conversão de um tipo anulável para um tipo regular é implícita.

int produtosAdquiridos = 10;
// Conversão implícita
int? produtos = produtosAdquiridos;

Operadores
Quaisquer operadores existentes para tipos por valor podem ser utilizados com Nullable Types.
O operador produzirá null se os operandos forem nulos, caso contrário, usará o valor contido para calcular o resultado.

int? x = 10;
x++; // x agora é 11
x = x * 10; // x agora é 110
int? y = null;
x = x + y; // x agora é null

Quando são feitas comparações com Nullable Types, se ambos os Nullable Types são null, então a comparação sempre retornará false. O caso oposto retornará true.

int? x = 250;
int? produtosAdquiridos = null;
if (x >= produtosAdquiridos)
Console.WriteLine(“Adquiriu mais de {0} produtos.”,x);
else // Não é válido – Correto: adição de um else if (...)
Console.WriteLine(“Adquiriu menos de {0} produtos.”,x);

A conclusão contida na expressão else não é válida porque produtosAdquiridos é null, portanto, não contém nenhum valor. Logo, não pode ser maior ou menor que x.

O operador ??
Define um valor padrão que é retornado quando um tipo anulável é atribuído à um tipo não-anulável.

// Exemplo
int? produtosAdquiridos = null;
// Atribui o valor 0 à y se produtosAdquiridos for null
int y = produtosAdquiridos ?? 0;

Também pode ser utilizado com vários Nullable Types

int? limiteCredito;
int? valorDefault;
// Se limiteCredito não for null, z = limiteCredito.
// Se limiteCredito for null, z = valorDefault.
int? z = limiteCredito ?? valorDefault;

Na próxima aula falaremos sobre Coleções

Até a semana que vem!

Sexta .NET – Aula 11 – ASP.NET e C# – Parte II

Boa tarde Pessoal,

Primeiramente gostaria de justificar o fato de estarmos publicando com atraso a aula, esta semana estávamos em finalização e aprovação de dois projetos, o que fez que ficassemos totalmente focados na entrega das demandas e tivessemos que abrir mão das aulas.

Para tirar o atraso, aqui vamos com a continuação da última aula.

Sexta .NET – Aula 11 – ASP.NET e C# – Parte II

Nesta aula abordaremos:
Partial Types

Aqui vamos então:

  • Recurso da versão 2.0
  • Permite dividir a implementação de um determinado tipo em diversos arquivos.
  • Disponível para classes, estruturas e interfaces.
  • Definidos pela palavra-chave partial.

Quando podem ser utilizados:
Quando trabalhamos com código gerado automaticamente, código pode ser adicionado à classe sem ter que recriar o arquivo fonte.
Partial Types permitem que dois ou mais desenvolvedores trabalhem no mesmo tipo, enquanto ambos têm seus arquivos checados para edição, sem interferir um no outro.

Declarando uma classe parcial

ClienteP1.cs

public partial class Cliente
{
public int codigo;
public bool EClienteEspecial() { … }
}

ClienteP2.cs

public partial class Cliente
{
int produtosAdquiridos;
public int ProdutosAdquiridos {
get { … }
set { … }
}
}

Declarando uma classe parcial agrupada em uma classe

ClienteP1.cs

public partial class Cliente {
int produtosAdquiridos;
public partial class ClientesEspeciais {
static List lista = new List();
}
}

ClienteP2.cs

public partial class Cliente {
public partial class ClientesEspeciais {
public void Adiciona(Cliente c) {
if (c.EClienteEspecial)
ClientesEspeciais.lista.Add(c);
}
}
}

As partes de uma classe não podem definir aspectos contraditórios.
Uma classe (ou estrutura) pode ter dois tipos de aspectos ou qualidades: acumulativa e não-acumulativa.
Os aspectos acumulativos são aspectos que cada parte do tipo parcial pode escolher adicionar, como derivação de interfaces, propriedades, índices, métodos e variáveis.
Os aspectos não-acumulativos são aspectos que todas as partes do tipo parcial devem possuir.

Classes Acumulativas

public partial class Computador {} // CompP1.cs
public partial class Computador : IProduto {// CompP2.cs
public void Adiciona() {...}
public void Remove() {...}
}

Classes Não-Acumulativas

public class Pessoa {}
public class Funcionario {}
public partial class Vendedor : Pessoa {} // VendedorP1.cs
public partial class Vendedor : Pessoa {} // VendedorP2.cs
//Não compila
public partial class Vendedor : Funcionario {}

Todas as partes devem ter a mesma acessibilidade.
Além de todas as partes definirem as mesmas partes não-acumulativas, apenas uma parte pode fazer o override de um método virtual ou abstract, e apenas uma parte pode implementar uma mesma interface.
Ao usar Partial Types, é recomendável indicar no nome do arquivo que este contém partes de um tipo. Como por exemplo: MinhaClasseP1.cs, MinhaClasseP2.cs

Bom pessoal, esta aula fica por aqui, já acompanhem a sequencia com a tal aula perdida, englobando Nullable Types

Até lá!

Sexta .NET – Aula 10 – Asp.NET e C# – Parte I

Bom pessoal,

Passada mais uma semada de correria e muito trabalho e aqui estamos para mais uma aula do Sexta .NET.
Hoje vou cumprir minha “dívida” com vocês e colocarei a aula que estou devendo a mais.

Para iniciar as atividades desta noite vamos falar de Asp.NET e C #.
Iniciaremos hoje falando sobre UserControls, Eventos e Delegates.

User controls

  • Controle web criado por um usuário.
  • Possui extensão .ascx
  • Herda de System.Web.UI.UserControl
  • Simplificam a reusabilidade de código e componentes User interface (UI) dentro de uma aplicação Web
  • Contém HTML, mas não as tags <HTML>,<BODY> ou <FORM>
  • Contém código para gerenciar seus próprios eventos
  • Podem agregar vários controles em um componente reusável

Exemplo de User Control

Eventos e Delegates

Conceitos:
Evento: ação que pode ser gerenciada/manipulada através de código
Delegate: membro da classe responsável por “delegar” as ações correspondentes a ocorrência de um evento ao(s) manipulador(es) de eventos correspondentes
Manipulador de Evento: método responsável pela execução de ações em reação a ocorrência de um evento

Cinco passos para se trabalhar com eventos
Passo 1: declarar o delegate contendo a assinatura do manipulador de evento correspondente ao evento

public class Cliente
{
public delegate void delegateProdutos(int produtos);
}

Passo 2: declarar o evento (deve ser do mesmo tipo do delegate correspondente)

public class Cliente
{
public delegate void delegateProdutos(int produtos);
public event delegateProdutos EventoProdutos;
}

Passo 3: disparar o evento na chamada de algum método da classe

public class Cliente
{
...
public void MetodoEvento(int produtosAdquiridos) {
this.EventoProdutos(produtosAdquiridos); }
}

Passo 4: assinar o evento indicando o manipulador de eventos do mesmo através de uma instância de delegate

cliente.EventoProdutos += new Cliente.delegateProdutos(ManipuladorEvento);

Passo 5: implementar o manipulador de evento (deve respeitar a mesma assinatura definida pelo delegate do evento)

public void ManipuladorEvento(int produtos)
{
label1.Text = produtos.ToString();
}

Pessoal, por aqui ficamos nesta aula.
Foi curta mas é coisa importante e necessita de bastante prática.

Jajá libero a próxima aula.

Att,
Victor Santos

Sexta .NET – Aula 7 – Orientação a Objeto – Parte III

Boa tarde pessoal, aqui vamos com a aula da semana.

O conteúdo que veremos hoje complementa o que estamos acompanhando nas útltimas semanas, volto a dizer que é muito importante que sigam e treinem bastante a orientação a objeto, pois ela é crucial e pode ser um diferencial em sua carreira.

Vamos ao que interessa?

Sexta .NET – Aula 7 – Orientação a Objeto – Parte III

Membros de Classe
Pertencem à classe e não às instâncias
Podem ser atributos, propriedades e métodos

public class Cliente
{
public static string tipoEntidade = “Teste”;
public static void Excluir(int identificacao)
{
/* excluir cliente com essa identificação */
}
}
...
Console.WriteLine(“Tipo de Entidade: {0}”, Cliente.tipoEntidade);
...
int clienteId = 5;
Cliente.Excluir(clienteId);

Construtores de classe – estáticos, compartilhados, globais
São executados antes do primeiro objeto do tipo em questão ser criado ou do primeiro método de classe ser invocado
Não possuem parâmetros
Não apresentam modificadores de acesso
Podem co-existir com construtores de instâncias
Utilizados para inicializar uma classe

Construtores de Classe

public class Cliente
{
private static Random numeroRandomico;
public int senhaCliente;

static Cliente()
{
numeroRandomico = new Random();
}

public void CarregarSenha()
{
senhaCliente = numeroRandomico.Next();
}
}

Classes Abstratas

Pode acontecer que ao escrever um método para uma classe base você não saiba como ele será implementado. Neste caso, a implementação será feita pela classe que herdar o método (a classe filha).

Pode acontecer também que você saiba que um determinado método será sobreposto com certeza na classe filha; então, por que definir sua implementação se ela não será usada?

Nestes casos você apenas define a assinatura do método e deixa a definição por conta da classe que irá herdar a classe pai.

Estas classes são então chamadas classes abstratas, o método que você não implementou é chamado de método abstrato.

As classes abstratas não podem ser instanciadas através da palavra chave New.

Uma classe abstrata é uma classe base genérica
Contém métodos abstratos que devem ser implementados nas classes que derivam dela
Um método abstrato não apresenta implementação na classe base

public abstract class Pessoa {
public abstract void Cadastrar();
public abstract string Nome { get; set; }
public abstract int Id { get; }
public virtual void Viajar() { /* Ação */ }
}

Pode conter membros não-abstratos

Derivando a classe abstrata e implementando os membros abstratos

public class Diretor : Pessoa
{
public override void Cadastrar()
{ /* Ações */ }
public override string Nome
{
get { /* Implementação get */ }
set { /* Implementação set */ }
}
public override int Id
{
get { /* Implementação get */ }
}
}

Interfaces

Uma interface é parecida com uma classe abstrata, a diferença é que uma classe abstrata pode possuir métodos que não estejam implementados e pode possuir métodos que estejam implementados.

Uma interface possui somente métodos que não estão implementados e que devem ser implementados pela classe que usar a interface.

Como o C# não suporta herança múltipla as interfaces permitem que uma classe estenda múltiplas interfaces contornando o problema.

Uma interface no C# não pode conter atributos, somente pode ter métodos, propriedades e eventos. Todos os membros de uma interface são públicos e não podem usar um modificador de acesso.

A classe que implementa a interface deve possuir a definição de todos métodos existentes na interface. Esta definição deve possuir o mesmo nome e a mesma assinatura, retorno e parâmetros, do método na interface.

O nome da classe e o nome da interface são separados por dois pontos(:).
Uma interface define a mesma funcionalidade e comportamento à classes não relacionadas diretamente

Declarando a interface

public interface IProduto
{
bool EPerecivel { get; }
Fornecedor RecuperarFornecedor();
void RegistrarVenda(Cliente cliente);
}

Implementando a interface

public class Computador : IProduto
{
private bool ePerecivel;
public bool EPerecivel
{
get { return ePerecivel; }
}
public Fornecedor RecuperarFornecedor()
{
return new Fornecedor();
}
public void RegistrarVenda(Cliente cliente)
{
// Rotina para registrar vendas
}
}

IS e AS

if (computador is IProduto)
{
// ações
}

IProduto produto = computador as IProduto;

if (produto != null)
{
Fornecedor fornecedor = produto.RecuperarFornecedor();
}

Pode tornar o comportamento de seus objetos semelhante ao comportamento dos objetos da .NET Framework
Exemplos:
ICollection
IComparer
IDictionary
IEnumerable

public class Cliente : Pessoa, IComparable
{
...
}

Estruturas de Repetição

foreach
Esta estrutura de repetição é uma variação do for.
Sua diferença está no fato de ser necessário apenas especificar uma variável e a coleção ou array cujos registros serão percorridos.

int[] i = { 1, 3, 5, 7, 9 };
foreach (int j in i)
{
Response.Write(j);
Response.Write("
");
}

Estruturas

Estruturas são tipos por valor, que podem conter:
Um construtor
Constantes
Atributos
Métodos
Propriedades
Uso recomendado para representar objetos leves e/ou que eventualmente podem constituir arrays de grande dimensão.
Não podem ser herdados, porem podem implementar Interfaces.

Exemplo de uma estrutura:

struct Circulo {
private int _raio; // Atributo

public double Circunferencia // Propriedade
{ get { return 2 * _raio * Math.PI; } }
// Regra específica para retornar um valor.

public Circulo(int raio) // Construtor com um argumento
{ this._raio = raio; } // Atribuição do valor do argumento
} // para o atributo do objeto.

… Dentro do evento Page_Load

Circulo meuCirculo = new Circulo(10);
// Instancia de uma estrutura.
Response.Write(meuCirculo.Circunferencia);
// Imprime o valor de uma propriedade

}

Exemplo de overload de métodos:

... Dentro da mesma estrutura do exemplo anterior:

public void DiminuirRaio(){ // Método simples sem argumentos
if (_raio > 1)
_raio–;
}

public void DiminuirRaio(int valor){// Overload do método anterior
if (_raio – valor > 1) // com um argumento
_raio -= valor;
}

… Dentro do evento Page_Load

meuCirculo.DiminuirRaio(); // Chamando o método sem argumentos
meuCirculo.DiminuirRaio(2); // Chamando o overload
// do método anterior

Bom, o conteúdo preparado para este tema é muito extenso.
Vamos parar por aqui e na semana que vem continuamos!

Com todo o apresentado nas últimas semanas finalizamos o ciclo de Orientação a Objeto.
O próximo tema que abordaremos será Desenvolvendo para internet -Parte I

Aguardo vocês e bons estudos!

Sexta .NET – Aula 6 – Orientação a Objeto – Parte II

Boa noite pessoal,

Continuando nossa aula seguindo o tema iniciado semana passada aqui vamos.

Sexta .NET – Aula 6 – Orientação a Objeto – Parte II

Para dar sequencia ao conteúdo, falaremos hoje sobre Herança e Encapsulamento de dados.

Herança

A herança está relacionada às hierarquias e às relações entre os objetos.
É o mecanismo em que uma classe filha compartilha automaticamente todos os métodos e atributos de sua classe pai.
A herança permite implementar classes descendentes implementando os métodos e atributos que se diferenciam da classe pai.

Tipos de Herança

Simples
Quando uma classe herda as propriedades de uma única classe pai.

Múltipla
Ocorre quando uma classe tem mais de um pai.

Criando uma classe derivada

public class Pessoa
{
public string nome;
protected int id;

public void Cadastrar() { /* rotina para cadastrar */ }
}
public class Cliente : Pessoa
{
public void Comprar(int idProduto) { /* ação */ }
}
...
Cliente proximoCliente = new Cliente(“Rodrigo”);

proximoCliente.Cadastrar();
proximoCliente.Comprar(100);

Invocando um construtor da classe base na classe derivada

public class Pessoa
{
public Pessoa(string nome)
{ Console.WriteLine(“Construindo Pessoa de Nome {0}”,nome); }
}
public class Cliente : Pessoa
{
public Cliente(string nome) : base(nome)
{ Console.WriteLine(“Construindo Cliente”); }
}
...
Cliente proximoCliente = new Cliente(“Rodrigo”);
...
Construindo Pessoa de Nome Rodrigo
Construindo Cliente

Classes Seladas – são classes que não podem ser extendidas ou sobrescritas, ou seja, não podemos ter classes derivadas de classes seladas.

public sealed class Pessoa
{
// Membros da Classe Pessoa
}

Em C#, as seguintes palavras-chave são úteis para explorar o conceito de herança:

Polimorfismo

Polimorfismo significa: “Muitas Formas” e representa o fato de uma determinada característica ser diferente para cada filho.

Partimos de um objeto mais simples e que vai evoluindo. Os conceitos do objeto pai continuam a existir, mesmo que tenham sofrido modificações ou assumido novas formas.

Utilizando métodos virtuais

public class Pessoa {
public virtual void Viajar() {
/* Ação */ }
}
public class Diretor : Pessoa {
public override void Viajar() {
base.Viajar();
/* Ações Particulares da Classe Diretor */
}
}
public class Vendedor : Pessoa {
public override void Viajar() {
base.Viajar();
/* Ações Particulares da Classe Vendedor */
}
}

Encapsulamento

Encapsulamento é o ato de esconder do usuário informações que não são de seu interesse.
O objeto atua como uma caixa preta, que realiza determinadas operações mas o usuário não sabe e não precisa saber exatamente como.
Basicamente o encapsulamento separa os elementos visíveis de um objeto dos invisíveis.

Modificadores de Classes

  • Public: permite que a classe seja acessada por qualquer assembly.
  • Sealed: não permite que a classe seja herdada.
  • Partial: permite que a classe tenha seu escopo dividido em dois arquivos.
  • Static: especifica que a classe somente tem membros estáticos. Não pode ser instanciada.
  • Abstract: define moldes para classes filhas. Não pode ser instanciada.

Modificadores de membros

  • Public: permite que os membros das classes sejam acessados por qualquer outro escopo.
  • Private: acesso restrito ao escopo da classe.
  • Protected: acesso restrito a classe e as derivadas.
  • Internal: permite acesso somente por classes do mesmo assembly.
  • Static: permite acesso, sem necessidade do objeto ser instanciado.
  • Abstract: são métodos de classes Abstract que não possuem implementação.
  • Virtual: permite que os métodos sejam sobrescritos por classes filhas.
  • Readonly: limita acesso a somente leitura aos atributos da classe.

Propriedades

São métodos que protegem acesso aos membros da classe

public string Nome
{
get { return nomeCliente; }
set { nomeCliente = value; }
}

string nomeCliente = novoCliente.Nome;
novoCliente.Nome = “Steve Ballmer”;

Bom pessoal, ficamos por aqui.
Espero que verifiquem atenciosamente este material e o de semana passada pois são fundamentais para que possamos ser desenvolvedores conscientes e possuir um diferencial de mercado.

Aguardo vocês aqui para semana que vem, estaremos abordando mais sobre orientação a objeto.

Teremos Orientação a objeto – Parte III onde falaremos sobre:
Membros de Classe
Classes Abstratas
Interfaces

Até lá!

Att,
Victor Santos

Sexta .NET

Respeitável público informamos que teremos agora a “Sexta .NET”!

O que é isso?

Estaremos preparando para vocês um minicurso de .NET com C# abordando desde o básico até o nível mais avançado.
Será disponibilizado o material todas as sexta-feiras e conto com a colaboração de vocês!
Caso tenham algum tema que achem pertinentes e interessantes de se saber enviem um email para victor@webfinal.com.br que iremos preparar o conteúdo para vocês.

A princípio serão disponibilizandos Artigos e Apresentações PowerPowint com exercícios, caso vejamos que a galera está acessando com uma boa frequencia, poderei iniciar também a liberação de podcasts e screencasts.

Aguardamos a colaboração de todos e semana que vem já teremos a primeira aula!

O que teremos nesta aula?
Tópico abordado:
Introdução ao .Net Framework e CLR

Esperamos todos vocês aqui e enviem sugestões por email.

Abraços.