| Últimas 20 atualizações de Fernando Rodrigues da Silva |
|
|
Code coverage
Quando efetuamos um teste unitário estamos preocupados em testar o resultado que esta sendo esperado, mas se o nosso código a ser testado houver varias possibilidades com vários fluxos dentro dele, como garantir que o nosso teste passou por vários caminhos. É o Code Coverage que podemos testar todo o caminho do código e não somente seu resultado.
O code coverage é um teste unitário com uma propriedade habilitada, esse teste também podemos dizer que é um teste de caixa branca.
Vamos iniciar criando o método que queremos testar.
public static class Calcular
{
public static decimal Somar(decimal valorA, decimal ValorB)
{
if (valorA == 5)
throw new Exception("Valor inválido");
else if (valorA == 6)
throw new Exception("teste");
return valorA + ValorB;
}
}
Agora vamos preparar os testes unitários
[TestMethod]
public void TestCodeCoverage()
{
Decimal valorA = 3; // TODO: Initialize to an appropriate value
Decimal ValorB = 6; // TODO: Initialize to an appropriate value
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|
Atributos
Quando criamos um teste unitário pelo assistente ou manual alguns atributos são inseridos veremos os principais a seguir.
[TestClass()] Esse atributo identifica que a classe será uma classe de teste.
[ClassInitialize()] O método que possui esse atributo é inicializado antes do primeiro método, como se fosse um construtor da classe, nesse atributo iniciamos propriedades e classe para utilização dos testes.
[TestInitialize()] Esse atributo decorado nos métodos é inicializado antes de cada teste
[ClassCleanup()] O método decorado como esse atributo funciona como um destrutor, nesses métodos é utilizado para limpar e destruir objetos ou fechar conexões, ele é executado após a execução de todos os métodos. Só poderá ter um método decorado com esse atributo.
[TestCleanup()] Esse atributo decorado no método funciona semelhante ao ClassCleanup, mas é executado ao termino de cada teste.
[TestMethod] Esse atributo identifica o método como o teste realmente em si, é nesse método que executaremos e validamos os testes unitários.
Recomenda-se o uso dos atributos TestCleanup e ClassCleanup, para finalizar objetos
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|
Testes no Visual Studio
Testar o software é um processo é uma das fases mais importante no ciclo de desenvolvimento de software, ao entregar o software o cliente espera o bom funcionamento do mesmo, e para isso são aplicados vários testes, como funcionais e não funcionais. No mercado existe varias ferramentas que nos auxilia a testar o software, dentre eles o Visual Studio 2010, que será a ferramenta que abordaremos alguns tipos de testes, como:
- Testes unitários;
- Testes de carga;
- Teste Web;
- Testes Ordenados
Testes unitários
Testes unitários também conhecidos como Unit test, esse tipo de testes são os primeiros teste que o desenvolvedor deve fazer, ele é criado durante a fase de desenvolvimento ou em seu inicio. O objetivo dos testes unitário é testar a menor funcionalidade existente do software, ou seja, isolar parte dos códigos e métodos, e analisar se essas funcionalidades tenham o retorno esperado mediando a um valor informado.
Os testes unitários também podem ser considerados como teste da caixa preta.
O código dos testes unitários terá classe e métodos com atributos identificando que o mesmo será usado para os testes.
Veja na listagem 1 abaixo um simples exemplo de teste unitário
Listagem 1: Pri
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|
Técnicas
Existem varias maneiras de se testar um software sendo ele orientado ao objeto ou não, mas o objetivo da Técnica de software mesmo com paradigmas de desenvolvimento de softwares diferentes, são as mesmas.
Técnica é o processo que vai assegurar perfeito funcionamento de alguns aspectos de software ou de sua unidade.
Segundo a norma IEEE 610.12-1990, as técnicas são procedimentos técnicos e gerenciais que ajudam a avaliação e a melhoria do processo
A seguir conheceremos as principais técnicas.
Temos como técnicas, estrutural e funcional.
Estrutural
O Teste estrutural também conhecido como teste da caixa branca. Esse teste tem por objetivo testar o código fonte, testar cada linha de código possível, testar os fluxos básicos e os alternativos.
No teste funcional ainda podemos classificá-los em alguns itens como:
Stress: Verifica como o sistema é executado com determinados volumes de dados.
Execução: Se o sistema atinge o nível desejado de eficiência
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|
Níveis de testes
Os testes devem ser realizados em vários níveis no desenvolvimento de software. Os principais níveis de testes de software são:
Teste de unidade ou testes unitários.
Esse nível de teste tem por objetivo testar a menor unidade do software, tentando provocar falhas de regra de negocio. Esse teste é feito por pequenos trechos de código isoladamente.
Teste de integração
Verifica se há falhas na entre os módulos ou interfaces, quando esses são integrados ao tentar fazer o funcionamento de um todo.
Teste de sistema
Avalia o sistema como um todo, como se fosse um usuário final, inserindo dados reais e analisando se suas respostas atendem aos requisitos.
Teste de aceitação
No inicio do desenvolvimento são declarados quais serão as funcionalidades que serão testadas para que o software seja declarado como entregue, esse nível de testes são efetuados geralmente por um grupo de usuários que verificam algumas funcionalidades para que o software seja considerado como aceito.
Como os níveis de testes deverão ser aplicados em todo ciclo de desenvolvimento do software logo, o planejamento dos testes devera se feito de cima para baixo, veja na figura 1 o Modelo V
Figura 1 – Modelo V
O Modelo V foi definido por Paul Rook em 19
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|
Veremos abaixo algumas definições de teste por alguns especialistas
É um processo sistemático que tem por objetivo encontrar defeitos (Myers, 1979)
É verificar se o software está fazendo o que deveria fazer, de acordo com seus requisitos, e se não está fazendo o que não deveria fazer (Rios e Moreira, 2003);
É o processo de executar um programa com o objetivo único de encontrar defeitos - Glenn J Meyers “The Art of Software Testing”
Teste é o processo de operar um sistema ou componente do sistema sob condições específicas, observando e registrando o resultado e fazendo uma avaliação de alguns aspectos do sistema ou componente - IEEE Standard Glossary
Mas ao pensar em testes temos sempre algumas dúvidas como:
Porque testar?
Porque precisamos provar que ele não vai funcionar ou mostrar que desenvolvedores não são capazes de fazer software sem defeitos. Primeiro devemos ter em mente que quanto mais cedo achar um defeito mais barato ele vai custar, e outra, o desenvolvimento de software é feito por pessoas sendo, desenvolvedores, analistas, gerentes, arquitetos. E essas pess
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|
Teste de software é a processo de verificar se o produto esta de acordo com as especificações determinadas e que funciona corretamente no qual foi projetado. O objetivo dos testes é de achar erros ou falhas para que a equipe de desenvolvimento possa corrigi-lo o mais rápido possível, pois quanto mais rápido descobrir um erro, mais barato ele fica. Por essas características a disciplina de teste é considerável "destrutiva" e não "construtiva".
Para que possamos dar prosseguimento na disciplina de testes temos que conhecer alguns conceitos como Defeito, Erro e falhas.
Defeito É qualquer imperfeição ou inconsistência no produto do software ou em seu processo, um defeito é também uma não conformidade. O Defeito faz parte do produto, é algo que esta implementada no código de maneira errada.
Erro
O Erro pode ser um resultado de um defeito ou uma falha, como um retorno esperado, que por causa de uma falha teve um valor diferente do que esperado.
Falha
Esta mais ligada ao hardware, como uma rede inacessível, queda de energia. Uma falha pode ocorrer por causa de um erro, por exemplo, houve um retorno de um valor não esperado, como null, isso é um erro, e por causa desse null ocasionou uma falha no sistema.
Os defeitos são ocasionados por vários motivos como:
- Usuários especificam os requisitos errados;
- Analistas interpretam erradamente os requisitos
- Especificações Funcionais e Técnicas elaboradas erroneamente;
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|
Neste curso será mostrado um dos novos pilares de desenvolvimento a partir do framework 3.0, o Windows Communication Fundations. Iremos mostrar uma visão geral de WCF, o que é WCF, e porque de usar, mostrando o ABC do EndPoint. O WCF funciona com a comunicação entre serviço e esses serviços fazem a troca de mensagens, entre o client e o services. O EndPoint é composto de três partes, Address, Binding e o Contract. O Address é o caminho do serviço, o Binding de como será feita a comunicação do serviço e o Contract, quais métodos e ou operações terá o meu serviço.-->">
|
|
|
|
Nesse artigo iremos continuar vendo como ler os contatos de celular utilizando o Sistema Operacional Android, . Agora vamos ver como preencher o telefone de um determinado contato. Vamos criar a classe Telefone. Se aquele contato possuir telefone o mesmo devera ser preenchido, a classe telefone terá esse objetivo.
package br.com.LerContatos;
import java.util.ArrayList;
import java.util.List;
import android.content.Context;
import android.database.Cursor;
import android.provider.ContactsContract;
public class Telefone {
private String _IDContato;
private Context _ctx;
public Telefone(String IDContato, Context Contexto)
{
this._IDContato = IDContato;
this._ctx = Contexto;
}
public List<EntidadeTelefone> getTelefones()
{
Cursor C_Telefones =this._ctx.getContentResolver().query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, null, ContactsContract.CommonDataKinds.Phone.CONTACT_ID + " = " + _IDContato, null, null);
int IndexTelefone;
List<EntidadeTelefone> Telefones = new ArrayList<EntidadeTelefone>();
while(C_Telefones.moveToNext())
{
EntidadeTelefone Telefone = new EntidadeTelefone();
IndexTelefone = C_Telefones.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER);
Telefone.setTelefone(C_Telefones.getString(IndexTelefone));
Telefones.add(Telefone);
}
C_Telefones.close();
return Telefones;
}
}
O Metodo getContentResolver().query() é um prove
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|
Nesse artigo aprenderemos como ler os contatos do celular utilizando o Sistema Operacional Android. Para poder ler os contatos precisamos de permissão do Sistema Operacional e para isso no arquivo AndroidManifest.xml devemos colocar a permissão android.permission.READ_CONTACTS, veja sua implementação completa abaixo.
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="br.com.LerContatos" android:versionCode="1"
android:versionName="1.0">
<application android:icon="@drawable/icon" android:label="@string/app_name">
<activity android:name=".LerContatos"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<uses-sdk android:minSdkVersion="7" />
<uses-permission android:name="android.permission.READ_CONTACTS">
</uses-permission>
</manifest>
Vamos começar criando duas entidades, contatos e telefones, conforme listagens abaixo. Entidade Contato
package br.com.LerContatos;
import java.util.List;
public class EntidadeContatos {
private String ID;
private String Nome;
private String Email;
private List<EntidadeTelefone> Telefones;
public String getID() {
return ID;
}
public void setID(String string) {
ID = string;
}
public String getNome() {
return Nome;
}
public void setNome(String nome) {
Nome = nome;
}
public List<EntidadeTelefone> getTelefones() {
return Telefones;
}
public void setTelefones(List<EntidadeTelefo
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|
Nesse artigo aprenderemos como identificar uma mensagem sms recebida por um celular que possui um sistema operacional Android.
Antes de começarmos a aplicação vamos falar sobre BroadcastReceiver.
Um BroadcastReceiver representada pela classe content.BroadcastReceiver, é uma classe que recebe eventos gerados por um Intent, sem a necessidade da utilização de uma interface gráfica. Esses eventos são mensagens enviadas pelo sistema operacional que pode ser desde um aviso que a bateria está baixa ou uma comunicação que uma mensagem sms foi recebida.
Para demonstrar o recebimento de mensagens sms, utilizaremos a aplicação do artigo enviando uma mensagem sms.
Para autorizar o recebimento de mensagems sms precisamos de autorização, que será informada dentro do arquivo AndroidManifest.xml e configurar um recebimento de um BroadcastReceiver, veja sua configuração abaixo.
<?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="br.com.EnviarSMS" android:versionCode="1" android:versionName="1.0"> <application android:icon="@drawable/icon" android:label="@string/app_name"> <activity android:name=".EnviarSMS" android:label="@string/app_name"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> <receiver android:name=".ReceberSMS" android:enabled="true"> <intent-filter> <action android:name="android.provider.Telephony.SMS_RECEIVED" ></action> </intent-filter> </receiver>
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|
Nesse artigo aprenderemos como fazer uma ligação telefônica, e ainda como preencher o controle ListView por uma entidade.
Para fazer uma ligação precisamos de permissão do Sistema Operacional e para isso no arquivo AndroidManifest.xml devemos colocar a permissão android.permission.CALL_PHONE, veja sua implementação completa abaixo.
<?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="br.com.LigacaoPessoa" android:versionCode="1" android:versionName="1.0"> <application android:icon="@drawable/icon" android:label="@string/app_name"> <activity android:name=".LigacaoPessoa" android:label="@string/app_name"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> </application> <uses-permission android:name="android.permission.CALL_PHONE"></uses-permission> <uses-sdk android:minSdkVersion="7" /> </manifest>
Vamos começar criando uma entidade pessoa, conforme listagem abaixo.
public class EntidadePessoa { private int cdPessoa; private String Nome; private String Telefone; public String getTelefone() { return Telefone; } public void setTelefone(String telefone) { Telefone = telefone; } public int getCdPessoa() { return cdPessoa; } public void setCdPessoa(int cdPessoa) { this.cdPessoa = cdPessoa; } public String getNome() { return Nome; } public void setNome(String nome) { Nome = nome; } public EntidadePessoa(int cdPessoa, String Nome, String Telefone) { this.cdPessoa=cdPessoa; this.Nome = Nome; this.Telefone = Telefone; } @Override public String toString() { // TODO Auto-generated method stub return cdPessoa + "-" + Nome + "-" + Telefone; } } Logo em seguida criaremos a classe pessoa que fará o preenchimento das mesmas.
import java.util.ArrayList; import java.util.List; public class Pessoa { public List<EntidadePessoa> getPessoa() { EntidadePessoa pessoa1 = new EntidadePessoa(1, "Fernando", "123"); EntidadePessoa pessoa2 = new EntidadePessoa(1, "Maria"
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|
Continuando o artigo sobre os controles do android... ProgressDialog –android.app.ProgressDialog.Controle muito parecido com aquelas “aguarde...” que sempre vimos em paginas HTML utilizando o recurso de Ajax. Ao contrario do controle (widget) ProgressBar que sabemos o tempo que o mesmo terá, o ProgressDialog não sabemos o tempo de seu processamento, logo esse tipo de controle é muito útil quando for feito uma requisição ao um WebService, download de um arquivo, onde o tempo de resposta não é informado. public class AndroidConrole extends Activity { private ProgressDialog p_dialog ; private Handler h = new Handler(); @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); //Progress Dialog p_dialog =ProgressDialog.show(this, "Titulo", "Aguarde...", false, true); InicioProgressDialogo(); } private void InicioProgressDialogo() { new Thread(){ @Override public void run() { // TODO Auto-generated method stub //aqui faz todo o processamento e após o seu termino, chamar o método para fechar a janela try { Thread.sleep(2000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } FimProgressDialogo(); } }.start(); } private void FimProgressDialogo() { h.post(new Runnable() {
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|
Continuando o artigo sobre os controles do android... CheckBox – android.widget.CheckBoxEsse controle é utilizado para selecionar uma ou mais opção, veja um exemplo abaixo <CheckBox android:text="Borracha" android:id="@+id/borracha" android:layout_width="wrap_content" android:layout_height="wrap_content"> </CheckBox> <CheckBox android:text="Caneta" android:id="@+id/caneta" android:layout_width="wrap_content" android:layout_height="wrap_content"> </CheckBox> <TextView android:id="@+id/ver_checkbox" android:layout_width="wrap_content" android:layout_height="wrap_content"></TextView> <Button android:text="Ver Seleção checkbox" android:id="@+id/bt_check" android:layout_width="wrap_content" android:layout_height="wrap_content"></Button> public class AndroidConrole extends Activity { /** Called when the activity is first created. */ private int statusProgress=0; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); //CheckBox final CheckBox ck_borracha =(CheckBox)findViewById(R.id.borracha); final CheckBox ck_caneta =(CheckBox)findViewById(R.id.caneta); final TextView ver_check = (TextView)findViewById(R.id.ver_checkbox); Button bt_check = (Button)findViewById(R.id.bt_check); bt_check.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View arg0) { // TODO Auto-generated method stub ver_check.setText(""); if(ck_borracha.isChecked()) ver_check.setText("borracha"); if(ck_caneta.isChecked()) ver_check.setText(ver_check.getText() +",caneta"); } }); } } Nesse exemplo é somente para entendermos a utilização desse controle, pois se houvesse uma quantidade de ckeck muito grande, que é bem comum no dia a dia, poderíamos utilizar a combinação de GridView com checkBox.

ToggleButon – android.widget.ToggleButtonMuito semelhante ao checkbox, ele é usado para representar se o botão está selecionado ou não, mas com o layout diferente. Veja um exemplo. <ToggleButton
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|
Controles no AndroidToda e qualquer aplicação, precisamos trabalhar com controles, como botões, campos de seleção como option, checkbox, dropbox entre outros. Nesse artigo mostrarei os principais controles do android e como trabalhar como eles. ViewA classe View é responsável pela criação de qualquer componente gráfico, ela é a base para os componentes visuais, então todos os controles que falaremos a adiante herdam dessa classe. WidgetEssa classe é a classe filha de view, que representa os componentes. TextView – android.widget.TextView Esse controle é o mais simples de todos, ele represente um texto como se fosse um label na tela. <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="@string/hello"/> EditText – android.widget.EditTex Esse controle representa um campo editavel, onde poderemos inserir informações, tanto textos comuns como senhas. <EditText android:text="Login" android:id="@+id/login" android:layout_width="wrap_content" android:layout_height="wrap_content"> </EditText> <EditText android:text="Senha" android:id="@+id/Senha" android:layout_width="wrap_content" android:layout_height="wrap_content" android:password="true"> </EditText> 
Spinner – android.widget.Spinner
Essa classe é utilizada como um dropbox(combo), muito parecido com a tag <select> do html.
Veja o exemplo se seu uso. <Spinner android:id="@+id/Spinner01" android:layout_width="fill_parent" android:drawSelectorOnTop="true" android:layout_height="60px"> </Spinner> public class AndroidConrole extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); //Spinner final List<String> estados = new ArrayList<String>(); estados.add("SP"); estados.add("RJ"); estados.add("SC"); Spinner cboEstados = (Spinner)findViewById(R.id.Spinner01); ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_spinner_dropdown_item, estados); adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|
O Android é um sistema operacional que roda sobre o núcleo Linux. Inicialmente foi desenvolvido pela Android Inc., em 2005 a Google comprou e posteriormente com parceria com a Open Handset Alliance, a plataforma Android permite que seja desenvolvido com a linguagem Java, utilizando bibliotecas desenvolvido pela Google. Bom como exemplo padrão iremos desenvolver um hello world, e para isso vamos preparar um ambiente para o desenvolvimento do mesmo. Primeiramente devemos baixar o sdk do Android para o seu sistema operacional, você pode encontrar nessa url http://developer.android.com/sdk/index.html
Apos o donwload, é necessário rodar o setup e fazer o update.

Nesse momento você pode instalar varias versões do sistema que será emulado.
Cada SDK representa a versão do sistema operacional do seu celular, por exemplo SO 2.1, SDK Platform Android 2.1 API 7. Na lista você vai encontrar API Google APIs by Google Inc., Android API 7, essa API tem a mesma funcionalidade da SDK, porem com suporte a API do Google maps, ele
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|

Tempo: 14:28
min
Mini resumo: Nesta
vídeo aula, será mostrado, mais um Design Patterns, o Singleton. O Design
Pattern Singleton é um padrão muito utilizado, e que por falta de conhecimentos
acabamos utilizando alternativas que muitas vezes foge da orientação ao objeto.
O Singleton é um padrão para trabalhamos com somente uma instancia, esse tipo
de pattern é muito usado quando vamos trabalhar com aplicações que gerencia
configurações, como atributos que inserimos nos arquivos web.config e ou
app.config, gerenciamento de cachê, de logs, de uploads e donwloads. Esse
pattern se enquadra na categoria de criação.
Metodologia de desenvolvimento do exemplo: Criaremos somente uma classe, e ela é configurada
para ter somente uma instancia.
Tecnologias
utilizadas: Visual
Studio 2010, Design Patterns, Singleton.
Exemplos construídos: Com base no requisito inicial “Criar um
gerenciador de logs”, criaremos
uma aplicação registrado os logs.
Palavras-chave: Visual Studio 2010,
Design Patterns, Singleton, Padrão de Projeto.
-->">
|
|
|
|

Tempo: 19:06
min
Mini resumo: Nesta
vídeo aula, será mostrado, mais um Design Patterns, o Observer. O Design
Pattern Observer é um padrão muito utilizado, ele fica observando o estado de
um objeto e assim que o mesmo alterar seu estado ele avisa todos os seus observadores.
Esse pattern se enquadra na categoria comportamental, pois ele observa o
comportamento de outras classes. Nessa aula criaremos duas interfaces, uma para
ser observada e outra para ficar observando, elas farão a ligação das classes
concretas, pois nenhuma saberá da existência da outra, e para representar a
parte pratica, o requisito de base é “Notificar fornecedores que a nota fiscal
foi paga”
Metodologia de desenvolvimento do
exemplo: Criaremos duas
interfaces que será a ligação entre as classes sem sabê-las de suas
existências.
Tecnologias
utilizadas: Visual
Studio 2010, Design Patterns, Strategy.
Exemplos construídos: Com base no requisito inicial “Notificar
fornecedores que a nota fiscal foi paga”, criaremos uma aplicação fazendo a notificação aos mesmos.
Palavras-chave: Visual Studio 2010,
Design Patterns, Observer, Padrão de Projeto.
-->">
|
|
|
|
Nesse artigo mostraremos um pouco sobre o Design Pattersn Strategy, nesse artigo falamos um pouco sobre o que é Design Patterns e porque usá-lo.
Para demonstrar cada padrão vamos usar alguns itens do seu formato.
Nome: Strategy
Objetivo / Intenção Definir uma família de algoritmos, encapsular cada um, e fazê-los intercambiáveis, ele permite que algoritmos variem independentemente entre clientes que os utilizam.
Também conhecido como: Policy
Motivação: Quando se necessita de um algoritmo que trata de modos diferentes os dados submetidos a ele.Estrutura:

Então vamos a pratica.
Iremos criar uma aplicação que fará o calculo das notas fiscais. Abaixo tem a estrutura da aplicação.

Código da interface do imposto public interface IImposto { decimal CalcularImposto(decimal valor); } Classe Nota fiscal public class NotaFiscal { public IImposto Imposto { get; set; } public decimal CalcularImposto(decimal valor) { return Imposto.CalcularImposto(valor); }
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
|
O que é Design Pattern?
É uma forma padrão de organizar as classes e objetos, onde são compartilhados conhecimentos sobre orientação objeto aplicados a problemas que acontecem em diversos cenários de desenvolvimento de software.
Porque eu devo usar Design Pattern?
Com o Design Pattern você terá vários benefícios dentre eles são, código mais enxuto, limpo, organizado, aumentar a qualidade e diminuir a complexidade do seu código.
Onde encontrar o Design Pattern?
Alguns programadores mais experientes começaram a perceber que os mesmos problemas começaram a aparecer varias e varias vezes e a solução para aqueles problemas eram sempre as mesmas e começaram a catalogar esses padrões. Em 1995 um grupo de pessoas, mas especificamente quatro pessoas escreveram um livro iniciando os Design Patterns mais conhecido de mercado, são eles Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides. Eles foram conhecidos como Gang of four ou GOF.
Mas só existe os Design Patterns do GOF?
O Conceito de padrão de projeto foi criado na década de 70 pelo arquiteto Christopher Alexander em seus livros Notes on the Synthesis of Form, The Timeless Way of Building e A Pattern Language, ele estabelece que um padrão deve ter.
Alem do Design Pattern do GOF, existem vários outros patterns como, por exemplo, Connected Buildings, Car Connection, Positive Outdoor Space e vários outros, esses patters somam certa de 125 padrões.
...
Exibição do post interrompida. Para ler conteúdo completo, clique aqui
|
|
|
| |
|