Aula_31 10 18 (1)

Prévia do material em texto

Treinamento em C# WebDeveloper
	
Aula
03
	
	Quarta-feira, 31 de Outubro de 2018
	
	
	
Desenvolvimento Orientado a Objetos em C#
	
Criando uma nova solution em branco:
Criando um projeto Console Application
Modelagem de entidades
Diagrama de Classes
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Projeto01.Entities
{
 public class Estoque
 {
 //prop + 2x[tab]
 public int IdEstoque { get; set; }
 public string Nome { get; set; }
 public List<Produto> Produtos { get; set; } //TER-MUITOS
 //construtor default
 //[ctor] + 2x[tab]
 public Estoque()
 {
 //vazio
 }
 //sobrecarga de construtores (overloading)
 public Estoque(int idEstoque, string nome)
 {
 IdEstoque = idEstoque;
 Nome = nome;
 }
 public Estoque(int idEstoque, string nome, List<Produto> produtos)
 : this(idEstoque, nome)
 { 
 Produtos = produtos;
 }
 //sobrescrita (override) do método ToString()
 public override string ToString()
 {
 return $"Id: {IdEstoque}, Nome: {Nome}";
 }
 }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Projeto01.Entities
{
 public class Produto
 {
 public int IdProduto { get; set; }
 public string Nome { get; set; }
 public decimal Preco { get; set; }
 public int Quantidade { get; set; }
 public Estoque Estoque { get; set; } //TER-1
 public Produto()
 {
 }
 public Produto(int idProduto, string nome, decimal preco, int quantidade)
 {
 IdProduto = idProduto;
 Nome = nome;
 Preco = preco;
 Quantidade = quantidade;
 }
 public Produto(int idProduto, string nome, decimal preco, 
			 int quantidade, Estoque estoque)
 : this(idProduto, nome, preco, quantidade)
 { 
 Estoque = estoque;
 }
 public override string ToString()
 {
 return $"Id: {IdProduto}, Nome: {Nome}, 
			Preço: {Preco}, Quantidade: {Quantidade}";
 }
 }
}
Interfaces
Interface é uma ferramenta de programação orientada a objetos utilizado para definir padrões (contratos) que as classes deverão implementar.
Uma interface funciona como um contrato entre si e qualquer classe ou estrutura que a implementa. 
Isso significa que uma classe que implementa uma interface é obrigada 
a implementar todos os seus membros. Uma Interface tem apenas a declaração de membro ou assinatura e, implicitamente, todos os membros de uma interface são públicos e abstratos.
Criando uma interface para geração de 
arquivos voltados para a entidade Estoque:
Regra: Nomes de interfaces 
sempre começam com a letra I
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Projeto01.Contracts
{
 public interface IEstoqueControle
 {
 }
}
Método Abstrato
Um método abstrato consiste de um método que não possui corpo (conteudo) mas somente assinatura (cabeçalho). Caberá à classe que herdar a interface que implemente os seus métodos abstratos.
Todos os métodos abstratos de uma 
interface já são implicitamente publicos.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Projeto01.Entities; //importando..
namespace Projeto01.Contracts
{
 public interface IEstoqueControle
 {
 //método abstrato
 void ExportarParaTxt(Estoque estoque); 
 }
}
Criando uma classe que implemente a interface:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Projeto01.Contracts; //importando
using Projeto01.Entities; //importando
namespace Projeto01.Controllers
{
 public class EstoqueControle : IEstoqueControle
 {
 }
}
Regra: Quando uma classe HERDA uma interface, a classe é obrigada a implementar todos os métodos abstratos declarados na interface:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Projeto01.Contracts; //importando
using Projeto01.Entities; //importando
namespace Projeto01.Controllers
{
 public class EstoqueControle : IEstoqueControle
 {
 public void ExportarParaTxt(Estoque estoque)
 {
 throw new NotImplementedException();
 }
 }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Projeto01.Contracts; //importando
using Projeto01.Entities; //importando
using System.IO; //arquivos
namespace Projeto01.Controllers
{
 //implementando a interface
 public class EstoqueControle : IEstoqueControle
 {
 //implementando o método abstrato da interface
 public void ExportarParaTxt(Estoque estoque)
 {
 StreamWriter streamWriter = new StreamWriter
						("c:\\temp\\estoques.txt", true);
 streamWriter.WriteLine("Id do Estoque...: " + estoque.IdEstoque);
 streamWriter.WriteLine("Nome............: " + estoque.Nome);
 //verificar se o objeto contem produtos..
 if(estoque.Produtos.Count > 0)
 {
 //varrer a lista de produtos
 foreach(Produto produto in estoque.Produtos)
 {
 streamWriter.WriteLine("\tId do Produto..: " 
				+ produto.IdProduto);
 streamWriter.WriteLine("\tNome...........: " 
				+ produto.Nome);
 streamWriter.WriteLine("\tPreço..........: " 
				+ produto.Preco);
 streamWriter.WriteLine("\tQuantidade.....: " 
				+ produto.Quantidade);
 }
 }
 streamWriter.Close();
 }
 }
}
Criando uma nova interface:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Projeto01.Entities; //importando
namespace Projeto01.Contracts
{
 public interface IProdutoControle
 {
 //método abstrato
 void ExportarParaXml(Produto produto);
 }
}
Exemplo:
<?xml version="1.0" encoding="ISO-8859-1"?>
<produto>
 <idproduto>1</idproduto>
 <nome>Notebook</nome>
 <preco>2000</preco>
 <quantidade>2</quantidade>
 <estoque>
 	<idestoque>1</idestoque>
	<nome>Informática</nome>
 </estoque>
</produto>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Projeto01.Contracts; //contratos
using Projeto01.Entities; //entidades
using System.Xml; //importando
namespace Projeto01.Controllers
{
 public class ProdutoControle : IProdutoControle
 {
 public void ExportarParaXml(Produto produto)
 {
 //criando um arquivo XML..
 XmlWriter xmlWriter = XmlWriter.Create("c:\\temp\\produto.xml");
 
 //escrevendo o cabeçalho do arquivo XML..
 xmlWriter.WriteStartDocument();
 //abrindo a TAG <produto>
 xmlWriter.WriteStartElement("produto");
 //escrevendo os dados do produto
 xmlWriter.WriteElementString("idProduto", 
			produto.IdProduto.ToString());
 xmlWriter.WriteElementString("nome", produto.Nome);
 xmlWriter.WriteElementString("preco", produto.Preco.ToString());
 xmlWriter.WriteElementString("quantidade", 
			produto.Quantidade.ToString());
 //abrindo a TAG <estoque>
 xmlWriter.WriteStartElement("estoque");
 xmlWriter.WriteElementString("idestoque", 
			produto.Estoque.IdEstoque.ToString());
 xmlWriter.WriteElementString("nome", produto.Estoque.Nome);//fechando a TAG </estoque>
 xmlWriter.WriteEndElement();
 //fechando a TAG </produto>
 xmlWriter.WriteEndElement();
 //fechando o arquivo..
 xmlWriter.Close();
 }
 }
}
Regras sobre interfaces:
· Interfaces não podem ter atributos
· Interfaces não podem ter construtores
· Métodos de interface devem ser abstratos, ou seja, não podem ter corpo, apenas assinatura.
· Métodos de interface já são implicitamente públicos.
Regra principal: 
Quando uma classe HERDA uma interface, a classe é obrigada a implementar (fornecer corpo) para todos os métodos abstratos da interface.
---------------------------------
Testando:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Projeto01.Entities; //importando
using Projeto01.Controllers; //importando
namespace Projeto01
{
 class Program
 {
 static void Main(string[] args)
 {
 //criando objetos..
 Estoque estoque = new Estoque(1, "Informática");
 estoque.Produtos = new List<Produto>();
 Produto produto1 = new Produto(1, "Monitor", 400, 2, estoque);
 Produto produto2 = new Produto(2, "Teclado", 100, 4, estoque);
 //adicionar os produtos na lista..
 estoque.Produtos.Add(produto1);
 estoque.Produtos.Add(produto2);
 //gerando os arquivos..
 EstoqueControle estoqueControle = new EstoqueControle();
 ProdutoControle produtoControle = new ProdutoControle();
 //pausar..
 Console.ReadKey();
 }
 }
}
Exceções
Consistem de erros que ocorrem em tempo de execução nos projetos. Não são erros de compilação mas sim erros que se apresentam durante a execução do sistema.
Tratamento de exceções
Bloco de comando: try / catch
Exception
Classe do .NET utilizada para capturar qualquer 
tipo de erro ocorrido em tempo de execução.
Hierarquia de Classes de tratamento de exceção:
Executando:
Utilizando try e catch:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Projeto01.Entities; //importando
using Projeto01.Controllers; //importando
namespace Projeto01
{
 class Program
 {
 static void Main(string[] args)
 {
 //criando objetos..
 Estoque estoque = new Estoque(1, "Informática");
 estoque.Produtos = new List<Produto>();
 Produto produto1 = new Produto(1, "Monitor", 400, 2, estoque);
 Produto produto2 = new Produto(2, "Teclado", 100, 4, estoque);
 //adicionar os produtos na lista..
 estoque.Produtos.Add(produto1);
 estoque.Produtos.Add(produto2);
 //gerando os arquivos..
 EstoqueControle estoqueControle = new EstoqueControle();
 ProdutoControle produtoControle = new ProdutoControle();
 try //tentativa
 {
 estoqueControle.ExportarParaTxt(estoque);
 Console.WriteLine("\nEstoque gravado com sucesso.");
 }
 catch(Exception ex) //captura da exceção
 {
 Console.WriteLine("Erro: " + ex.Message);
 }
 try //tentativa
 {
 produtoControle.ExportarParaXml(produto1);
 Console.WriteLine("\nProduto gravado com sucesso.");
 }
 catch (Exception ex) //captura da exceção
 {
 Console.WriteLine("Erro: " + ex.Message);
 }
 //pausar..
 Console.ReadKey();
 }
 }
}
Saida do programa:
Arquivos gerados:
Erros em tempo de execução:
Novo projeto:
Classe de entidade: Cliente
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Projeto02.Entities
{
 public class Cliente
 {
 public int IdCliente { get; set; }
 public string Nome { get; set; }
 public string Email { get; set; }
 public Cliente()
 {
 }
 public Cliente(int idCliente, string nome, string email)
 {
 IdCliente = idCliente;
 Nome = nome;
 Email = email;
 }
 public override string ToString()
 {
 return $"Id: {IdCliente}, Nome: {Nome}, Email: {Email}";
 }
 }
}
Criando uma interface :
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Projeto02.Entities; //importando
namespace Projeto02.Contracts
{
 public interface IClienteControle
 {
 //método abstrato..
 void ExportarJson(Cliente cliente);
 //método abstrato..
 Cliente ImportarJson();
 }
}
Implementando a interface:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Projeto02.Entities; //importando..
using Projeto02.Contracts; //importando..
namespace Projeto02.Controllers
{
 public class ClienteControle : IClienteControle
 {
 public void ExportarJson(Cliente cliente)
 {
 throw new NotImplementedException();
 }
 public Cliente ImportarJson()
 {
 throw new NotImplementedException();
 }
 }
}
JSON (JavaScript Object Notation)
Formato para troca / representação de dados em 
aplicações web baseado na linguagem JavaScript.
Exemplo:
{
	IdCliente : 1,
	Nome : "Sergio Mendes",
	Email : "sergio.coti@gmail.com"
}
{
	IdProduto : 1,
	Nome : "Notebook",
	Preco : 2000,
	Estoque : {
		IdEstoque : 1,
		Nome : "Informática"
	}
}
NuGet (Gerenciador de 
dependencias do VisualStudio)
Utilizado para instalar frameworks, bibliotecas 
ou recursos externos nos projetos.
Newtonsoft.Json
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Projeto02.Entities; //importando..
using Projeto02.Contracts; //importando..
using Newtonsoft.Json; //importando..
using System.IO; //importando..
namespace Projeto02.Controllers
{
 public class ClienteControle : IClienteControle
 {
 public void ExportarJson(Cliente cliente)
 {
 //abrindo o arquivo..
 StreamWriter streamWriter = new StreamWriter
						("c:\\temp\\cliente.json");
 //escrevendo os dados do cliente no arquivo em formato JSON
 streamWriter.WriteLine(JsonConvert.SerializeObject(cliente));
 //fechando o arquivo..
 streamWriter.Close();
 }
 public Cliente ImportarJson()
 {
 //abrindo o arquivo..
 StreamReader streamReader = new StreamReader
						("c:\\temp\\cliente.json");
 //ler todo o texto contido no arquivo..
 string conteudo = streamReader.ReadToEnd();
 //fechando o arquivo..
 streamReader.Close();
 //retornando um cliente..
 return JsonConvert.DeserializeObject<Cliente>(conteudo);
 }
 }
}
Executando:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Projeto02.Entities;
using Projeto02.Controllers;
namespace Projeto02
{
 class Program
 {
 static void Main(string[] args)
 {
 Cliente cliente = new Cliente(1, "Ana Paula", "anapaula@gmail.com");
 try
 {
 ClienteControle clienteControle = new ClienteControle();
 clienteControle.ExportarJson(cliente);
 Console.WriteLine("\nJSON gerado com sucesso.");
 }
 catch(Exception e)
 {
 Console.WriteLine("Erro: " + e.Message);
 }
 Console.ReadKey();
 }
 }
}
Saida do programa:
using System;
using System.Collections.Generic;using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Projeto02.Entities;
using Projeto02.Controllers;
namespace Projeto02
{
 class Program
 {
 static void Main(string[] args)
 {
 Cliente cliente = new Cliente(1, "Ana Paula", "anapaula@gmail.com");
 try
 {
 ClienteControle clienteControle = new ClienteControle();
 clienteControle.ExportarJson(cliente);
 Console.WriteLine("\nJSON gerado com sucesso.");
 Cliente clienteObtido = clienteControle.ImportarJson();
 Console.WriteLine("Dados gravados: " + clienteObtido.ToString());
 }
 catch(Exception e)
 {
 Console.WriteLine("Erro: " + e.Message);
 }
 Console.ReadKey();
 }
 }
}
Leia mais sobre JSON em:
https://www.json.org/json-pt.html
23