Mensagens de blog de todos - DevBrasil

Um mergulho no Velocity 2018 em New York

2018-12-17T15:00:00.000Z

O Velocity 2018 em New York é a maior conferência sobre Sistemas distribuídos, alta performance e Arquitetura de aplicações. O Velocity é promovido pela Oreilly com o apoio de grandes empresas e profissionais do mercado de tecnologia.

Durante o Velocity eu tive a oportunidade de interagir e entender como os profissionais estão tratando projetos complexos envolvendo Microservices, Cloud e DevOps / SRE.

Eu tive uma grande dificuldade em escolher as palestras devido ao grande número de opções incríveis. Uma das palestras que me chamou a atenção foi o tratamento de trace distribuído em cenário de Microservices apresentada pelo Naoman Abbas (Pintrest).

A Bridget Kromhout (Microsoft) conduziu a iniciativa “Kubernetes 101” com uma rápida imersão na adoção de Kuberentes e demonstrando como operacionalizar os cenários “Cloud Native”.

A Tuli Nivas (Sales Force) abordou o tema “Performance anomaly detection at scale” demonstrando os desafios da Sales Force para gerenciar a sua plataforma de SaaS.

A Idit Levine (solo.io) abordou o tema “Debuggin microservices apps via a service mesh, Open Tracing, and Squash” demonstrando um grande desafio atual para quem desenvolve microservices e precisa rastrear todo o ciclo da aplicação.

Essas palestras foram apenas uma pequena amostragem do Velocity 2018. Esse tipo de evento é uma grande oportunidade para se conectar com a comunidade de sistemas distribuídos e os engenheiros que estão enfrentando problemas reais e compartilhando.

Para ver todos os detalhes:
https://conferences.oreilly.com/velocity/vl-ny

Um breve resumo do Velocity 2018 em New York

Até a próxima !!!

Ramon Durães

Erro Visual Studio (Programando em C )

2016-03-09T08:14:50.000Z

Olá pessoal, sou novo aqui, e também novo na área. Faço ciência da computação e comecei a usar o Visual para programar. E estou apanhando bastante. Me foi pedido para fazer um programa onde onde caracteres aleatórios seriam gerados, ordenados e depois gravados em um arquivo .TXT. No entanto, quando eu chamo a função GRAVAR, ele da um erro, quando eu tiro a função GRAVAR, o programa compila e executa sem erros. Estou anexando uma imagem onde mostra a função e o erro.

Desde já,

Obrigado.

Desenvolvendo para Apple Watch com Xamarin iOS e C#

2015-10-16T00:57:16.000Z

Estamos vivendo hoje uma novo conceito sobre as coisas que usamos para vestir, iniciamos de fato a era dos Wearables : os Dispositivos vestíveis.

O Xamarin por sua vez tem sua proposta o desenvolvimento crossplatform utilizando todo o poder da linguagem C# e os melhores recursos que a plataforma .Net proporciona usando como base os projetos OpenSource MonoTouch e MonoAndroid.

Mas vamos falar da proposta deste post, que é o desenvolvimento para Wearables, falando um pouco sobre como iniciar o desenvolvimento para Apple Watch com o Watchkit que o Xamarin iOS já tem suporte desde a sua primeira versão Beta.

O Xamarin tem suporte nativo para o dispositivo de cada plataforma, pois assim como o desenvolvimento para smartphones e tablets, ele utiliza também 100% do SDK do Android e do iOS. Cada plataforma possui um dispositivo, arquitetura, recursos diferentes, formas de acessar e sensores diferentes. Toda a sua comunicação é feita pareado a um smartphone utilizando a tecnologia Bluetooth LE.

O Device e a SDK WatchKit

Mais recentemente lançado o Apple Watch não é totalmente independente do smartphone.Utilizamos o WatchKit instalado junto com o Xcode para fornecer a API necessária para esse desenvolvimento. O Código não é executado direto no device, isto é, somente uma UI fica disponível para interação e o código ou Parent App será executado no iPhone que serve toda para a comunicação e configuração do aplicativo, o qual abordaremos logo mais. Os sensores por sua vez não são acessíveis, sendo assim você não terá um nível de customização como no Android Wear. E por sua vez, não é feito nenhum deploy de App no device, esse Parent App é executado e instalado apenas no iPhone, ficando no Apple Watch somente a UI exibindo informações precisas e notificações.

Em ambos não temos teclado para digitação, temos a função de assistente de voz, ditado, mais refinada para ser utilizada no smartwatch, justamente por ter uma tela pequena, não seria tão agradável para o usuário ter um teclado em uma tela tão reduzida.

Criando nosso projeto com Xamarin iOS

Seguindo os primeiros passos para criar uma aplicação para Apple Watch iremos em : File > New > Solution > iOS >Single View App

É necessário primeiramente criar uma single view app, pois é ela que será a Full App iOS, ou Parent App, que será base do projeto WatchKit. Após isso precisamos adicionar o tipo de projeto iOS > Extension > WatchKit App, dentro da solution

Após selecionar o tipo do projeto e avançar, teremos uma tela igual abaixo onde podemos selecionar a parent App, que será o projeto Single View App que criamos anteriormente, incluir o tipo de tela Glance, que são aquelas telas que no device em espera exibem informações rápidas como horário ou ícones de alertas, e Notifications que é a estrutura para a App Watchkit receber e exibir notificações recebidas.

A estrutura do projeto

Conforme a imagem abaixo nós teremos essa estrutura de Solution, após adicionar o projeto WatchKit. O Primeiro projeto da solution é a Parent App, uma app feita em Xamarin iOS que será a base de comunicação do device, pois é no próprio iPhone que ele fica instalado, com o App do Apple Watch, neste primeiro momento não iremos trabalhar com ele, mas nele pode conter configurações de preferência, tutoriais, entre outros recursos para o App WatchKit.

Logo Abaixo dele temos o projeto de tests padrão criado pelas solutions do Xamarin iOS e em seguida o WachKitApp. O Projeto WatchKitApp é o projeto irá ser instalado no Apple Watch, porém como podem observar temos uma estrutura muito reduzida, pois o device não possui tantos recursos quanto um smartphone. Na pasta resources serão adicionados todas as imagens com baixa resolução e tamanho que serão utilizadas no projeto, é algo que devemos tomar cuidado na hora de criar as imagens que serão usadas. O mais importante desse projeto é o arquivo interface.StoryBoard , onde iremos criar as Views ( Telas ) do nosso App WatchKit. O Quarto e ultimo projeto da nossa solution é Extension, nele vai contar toda a nossa regra de negocio, todo o nosso "codebehind" do das views que criamos no AppWatchKit. Para toda view criada lá, iremos manipular com uma Controller no WathKitExtension.

Desenvolvendo e Integrando as aplicações

Dando um duplo click no arquivo interface.storyboard, que está dentro do projeto WatchKitApp, iremos abrir e perceber que temos uma view chamada Interface Controller já criada. Nela iremos arrastar dois controles que estão na nossa toolbox do lado esquerdo, chamados Button e Label. De forma muito simples, drag & drop, arrastamos e posicionamos os controles na nossa view conforma o exemplo abaixo.

Após adicionar teremos a nossa view sendo apresentada desse jeito. Podemos então selecionar um controle de cada vez, o Button e a Label, e acessando as Properties na guia do lado esquerdo do Xamarin onde podemos editar o conteúdo dos controles entre outras propriedades. Neste primeiro momento usaremos a propriedade Name, a primeira da aba Widget, localizada na guia properties para dar um ID para o controle, dessa forma conseguiremos manipular ele na classe InterfaceController.cs , localizada no projeto Extension.

Neste exemplo apenas modifiquei o texto exibido dentro do Button para "Press" e o texto que está dentro da Label para " 0 Clicks ", esse texto pois irei criar um código simples para exibir os numero de vezes que o button receber um click, então será exibido na label. Após personalizar nosso componentes, vamos selecionar o Button e ir na aba Events da guia Properties do Button, onde teremos um campo chamado " Action " para adicionar o evento que iremos manipular o evento Click quando o Button for pressionado. Neste campo iremos digitar " OnButtonPress " e apertar enter, para que grave no Button o evento que iremos utilizar.

Após adicionar o evento OnButtonPress no Button, iremos no projeto Extension, abriremos a classe InterfaceController.cs, pois a mesma esta referenciada a View que acabamos de configurar, e adicionaremos o seguinte bloco de código após o método DidDeactivate.

O que o método faz é bastante simples: Criamos um contador com uma variável click do tipo inteira sendo inicializada com o valor 0, dentro do método OnButtonPress que é utilizado para manipular o evento Click do Button, criamos uma variável msg e dentro dela informamos que o valor que receberá será uma string que irá incrementando o valor inteiro da variável click e complementar a string. Então vamos utilizar o valor da variável msg e utilizar a propriedade da label, chamando ela, através do Name ou ID que criamos na guia properties, SetText() incluindo nela a própria variável, sendo assim estamos indicando que o texto da nossa label irá ser alterado conforme o valor da string também for.

Feito os passos acima, vamos realizar o debug da APP. Quando o emulador do iOS estiver aberto, selecionamos ele, iremos até a opção HardWare > External Displays e selecionamos uma das duas opções do Apple Watch, para que seja aberto um display externo simulando o device AppleWatch.

Com a aplicação rodando teremos esse resultado. A cada click que foi feito no botão, ele irá incrementar o numero do texto que aparece na label, conforme a imagem abaixo.

Esse exemplo simples foi para mostrar como podemos iniciar facilmente o desenvolvimento para aplicações usando o sdk do WatchKit e o Xamarin iOS. Nos próximos posts irei mostrar como consumir dados utilizando o SDK do WatchKit e do Android Wear exibindo no device.

Ordenando a execução de TRIGGER com Oracle 11g

2015-06-16T02:17:58.000Z

Até o Oracle 11g, nas versões anteriores não era possivel ordenar a execução de trigger irei demonstrar que com o Oracle 11g podemos determinar a ordem de execução das triggers de uma tabela que são de um mesmo tipo. Na criação de uma trigger no Oracle 11g, existe uma nova cláusula chamada "follows" que nos permitirá definir a ordem de execução das mesmas.

No primeiro exemplo abaixo, irei criar 3 triggers do tipo BEFORE INSERT sem definir uma ordem de execução.

C:\>sqlplus scott/tiger

SQL*Plus: Release 11.2.0.1.0 Production on Qua Ago 3 21:34:36 2011
Copyright (c) 1982, 2010, Oracle.  All rights reserved.

Conectado a:
Oracle Database 11g Enterprise Edition Release 11.2.0.1.0 - Production
With the Partitioning, OLAP, Data Mining and Real Application Testing options

SQL> create table t1 (id number);

Tabela criada.

SQL> create or replace trigger trg_teste_01
  before insert on t1
  for each row
  begin
      dbms_output.put_line('trigger trg_teste_01');
  end;
  

Gatilho criado.

SQL> create or replace trigger trg_teste_02
  before insert on t1
  for each row
  begin
      dbms_output.put_line('trigger trg_teste_02');
  end;
  

Gatilho criado.

SQL> create or replace trigger trg_teste_03
  before insert on t1
  for each row
  begin
      dbms_output.put_line('trigger trg_teste_03');
  end;
  

Gatilho criado.

Após a criação da tabela e das triggers, irei inserir um registro na tabela T1.

SQL> set serveroutput on
SQL> insert into t1 values (1);
trigger trg_teste_03
trigger trg_teste_02
trigger trg_teste_01

1 linha criada.

Perceberam que a trigger trg_teste_03 foi acionada primeiro? Quem garante que a mesma será executada primeiro na próxima vez? Bom, no segundo exemplo abaixo irei criar novamente as triggers só que, agora, definindo a ordem de execução:trg_teste_01, depois trg_teste_02 e depois trg_teste_03.

SQL> create or replace trigger trg_teste_01
  before insert on t1
  for each row
  begin
     dbms_output.put_line('trigger trg_teste_01');
  end;
  

Gatilho criado.

SQL> create or replace trigger trg_teste_02
  before insert on t1
  for each row
  follows trg_teste_01
  begin
      dbms_output.put_line('trigger trg_teste_02');
 end;
 
Gatilho criado.

SQL> create or replace trigger trg_teste_03
 before insert on t1
 for each row
 follows trg_teste_02
 begin
    dbms_output.put_line('trigger trg_teste_03');
 end;
 

Gatilho criado.

SQL> insert into t1 values (2);
trigger trg_teste_01
trigger trg_teste_02
trigger trg_teste_03

1 linha criada.

Pronto. Podemos ver que as mesmas foram acionadas de acordo com a ordem que eu havia definido anteriormente. Poderíamos inclusive desabilitar uma das triggers que não haveria problema nenhum:

SQL> alter trigger trg_teste_02 disable;

Gatilho alterado.

SQL> insert into t1 values (3);
trigger trg_teste_01
trigger trg_teste_03

1 linha criada.

Agora, caso alguma trigger que é dependente de outra for dropada, aí sim teremos problemas pois não conseguiremos realizar algumas operações até que o problema seja sanado.

SQL> drop trigger trg_teste_02;

Gatilho eliminado.

SQL> select object_name,status from user_objects where object_type='TRIGGER';

OBJECT_NAME                    STATUS
------------------------------ -------
TRG_TESTE_01                   VALID
TRG_TESTE_03                   INVALID


SQL> insert into t1 values (3);
insert into t1 values (3)
            *
ERRO na linha 1:
ORA-04045: erros durante a recompilação/revalidação de SCOTT.TRG_TESTE_03
ORA-04098: gatilho 'SCOTT.TRG_TESTE_03' é inválido e a revalidação falhou

SQL> drop table t1;
drop table t1
           *
ERRO na linha 1:
ORA-00604: ocorreu um erro no nível 1 SQL recursivo
ORA-04045: erros durante a recompilação/revalidação de SCOTT.TRG_TESTE_03
ORA-04098: gatilho 'SCOTT.TRG_TESTE_03' é inválido e a revalidação falhou

SQL> alter trigger trg_teste_03 disable;

Gatilho alterado.

SQL> insert into t1 values (4);
trigger trg_teste_01

1 linha criada.

SQL> drop table t1;

Tabela eliminada.

Caso alguém saiba uma forma mais otimizada me mande é sempre bom compartilhar o que aprendemos :).

C# 5.0 – Gerando Log utilizando Caller Info Attributes

2015-01-04T14:00:09.000Z

Desenvolver software saudável é uma arte, atualmente temos visto muito software de qualidade no mercado, porém quando existe qualquer implementação evolutiva o software começa a desencadear uma série de bugs, por essa razão conceitualmente existe uma diferença entre software saudável e software de qualidade, software saudável em curtas palavras é o software que é evoluído com facilidade e não gera bugs.

Existem várias classes de bugs, alteração de infraestrutura, sintaxe, lógica de implementação entre outros, porém o pior de todos é aquele bug silencioso, pois ele acontece apenas no ambiente de produção e você não consegue entender a causa do erro e onde o erro acontece, por esse motivo a implementação de Log é muito importante porque fornece aos desenvolvedores a rastreabilidade necessária para descobrir o que esta gerando erro, e a novo recurso Caller Infor Attributes disponibilizado no C# 5.0 nos ajuda com essa questão.

Vamos implementar um exemplo bem simples para entendermos o conceito, vale lembrar que estamos sendo puristas tratando log de erro apenas com C#, não estamos utilizando nenhum componente orientado a aspecto que existe no mercado.

Na versão do C# 4.0 foi disponibilizada uma feature bem legal que já existia em outras linguagens o Named e Optional Arguments, usando dessa feature os arquitetos da Microsoft tiveram a idéia de adicionar atributos para parâmetros opcionais que representassem o método, arquivo e linha que o erro ocorreu.

Como podemos observar a Solução do Projeto é bem simples

Interface nos fornece um comportamento chamado Error que será implementado pela classe Logger

Classe Logger implementa o comportamento da interface ILog, fornece uma instancia para classes externas acessarem o método Error.

Agora iremos chamar esse comportamento de uma classe cliente, no nosso caso do Main.

Resultado :

Como podemos notar é retornado a descrição do erro, método, arquivo e linha que o erro ocorreu, com essas informações em mãos bastaria persistir esses dados em uma base de dados e implementar uma rotina para enviar notificações via email sobre os erros que estão acontecendo no ambiente de produção.

Vantagem

A sintaxe é clara e objetiva, oferece uma maneira de trabalhar com Log de erro de uma forma customizada não excedendo. Os componentes de terceiros existentes no mercado orientado a aspecto oferecem muito mais do que é realmente necessário, muita das vezes gerando arquivos xml enormes, além da lógica interna desses componentes ser altamente complexas uma vez que é realizado um scan do assembly depois que o C# compiler converteu esse assembly para IL e posteriormente é reescrito o IL.
Então Caller Info Attributes fica como uma alternativa mais limpa e customizada.

Para saber mais

Aprofunde seu conhecimento sobre C#

Artigo sobre Named e Optional Arguments MSDN

Caso de Uso de Named e Optional Arguments

C# 4.0 - Named e Optional Arguments

C# 5.0 - Caller Info Attributes

C# 5.0 – Programação Assíncrona Async e Await

2014-12-24T00:30:00.000Z

Programação Assíncrona é atualmente um dos elementos mais importantes no desenvolvimento de software, um cliente ao navegar por uma aplicação deseja ter uma experiência rica e responsiva, para entregar essa experiência foi introduzido no C# 5.0 uma nova sintaxe simplificada e direta, anteriormente trabalhar com multithread era uma tarefa complexa que exigia muitas linhas de código, agora neste novo modelo tornou-se simples.

Antes de aprender a utilizar a sintaxe do novo modelo de programação assíncrona é muito importante conhecermos quando utilizar programação assíncrona, programação assíncrona é comum ser utilizada ao trabalhar com imagens, arquivos, wcf ou um processo que envolve muita regra de negócio complexa que consequentemente torna-se lento.

Abaixo segue uma imagem de um modelo assíncrono evidenciando um ganho de performance de 5 segundos:

Na figura acima, T1 foi executado em paralelo a T2 e T3, como T2 e T3 representam 5 segundos então a execução de T1, T2 e T3 demorou 5 segundos, logo em um processo não assíncrono demoraria 10 segundos porque T2 teria que esperar o retorno de T1.

Entendendo na prática, abaixo foi feita uma implementação simples para que possamos entender o conceito, importante notar as palavras reservadas async e await, onde async é utilizada na declaração do método e sua função é apenas habilitar a utilização do poderoso await dentro do corpo do método, await recebe como argumento uma Task que é uma tarefa que pode executar uma ação e diz que essa ação será executada em uma thread isolada independente das demais.

No método Main temos a chamada dos métodos de forma estruturada na ordem a seguir:

FazAlgumaCoisa
Soma
Multiplica

Devido o método FazAlgumaCoisa ser assíncrono o método Soma e Multiplicação não precisam esperar o método FazAlgumaCoisa ter um retorno, podendo rodar paralelo, o resultado da execução dessa implementação é:

O resultado da soma é : 20
O resultado da multiplicação é : 100
FazAlgumacoisa

Interessante notar que o método FazAlgumaCoisa embora tenha sido chamada primeiro foi executado por último seu processo demorou mais.

using System;
using System.Threading.Tasks;

namespace DevBrasil
{
public class DevBrasil
{
public static void Main()
{
var result = FazAlgumaCoisa();
Soma(10, 10);
Multiplica(10, 10);
Console.Read();
}

private static async Task FazAlgumaCoisa()
{
await Task.Delay(1000);
Console.WriteLine("FazAlgumaCoisa");
}

private static void Soma(int num1, int num2)
{
Console.WriteLine("O resultado da soma é : {0} ", num1 + num2);
}

private static void Multiplica(int num1, int num2)
{
Console.WriteLine("O resultado da multiplicacao é : {0} ", num1 * num2);
}
}
}

Vantagem

A sintaxe é clara, basicamente constitui de apenas duas palavras reservadas, A palavra reservada await se encarrega de todo o gerenciamento da thread o que facilita o desenvolvimento, antigamente todo o gerenciamento era realizado programaticamente.

Neste artigo foi apresentado de forma simples o novo paradigma de desenvolvimento de processos assíncronos existente na linguagem C#.

Para saber mais
Aprofunde seu conhecimento sobre C#

Alavanque as suas vendas com Windows Azure Search (Preview) - introdução

2014-09-14T20:00:00.000Z

O sistema de busca em nossos site e aplicativos não pode ser menosprezados ou um mero detalhe, sabendo utilizá-lo podemos capturar o comportamento do usuário e gerar números bem expressivos, segundo a pesquisa da SLI Systems, 34% das pessoas que acessam a loja online usam a busca e dessas 43% que não encontram o produto não o procuram mais.

Porem sabemos o quanto e trabalhoso para des

envolvermos sistemas de busca complexos e eficientes e fora a infraestrutura que temos que montar principalmente quando oferecemos preços e descontos especiais em nossos sites.

Para não sofremos podemos utilizar a poderosa ferramenta Windows Azure Search.

A proposta na utilização do Windows Azure Search e adicionar rapidamente recursos de busca em seu aplicativo ou site, sem ter que se preocupar com a complexidade de implementar e manter ou gerenciar qualquer infraestrutura.

Assim como outros serviços do Azure, o serviço de busca utiliza o padrão de chamadas REST , alem desse grande benefício podemos contar com toda a infraestrutura de data center do Azure isso significa redução de latência de pesquisa.

Para o serviço de busca funcionar,precisamos mover os nossos dados para nuvem para que eles sejam indexados.

Alguns bons motivos para utilização do Windows Azure Search !

Simples: Serviço totalmente gerenciado na nuvem, simples de configurar,manter e utilizar. Podemos ajustar de forma rápida e fácil os resultados da pesquisa e as metas de negocio.
Escalável: Windows Azure Search e totalmente escalável, com opção para aumentar replicas de armazenamento ou serviço para lidar com cargas maiores de consulta.
Time Is Money: Com um sistema de busca eficiente e inteligente podemos facilmente elevar a taxa de conversão e satisfação dos clientes .

Configurando o Windows Azure Search:

1 – Entre no portal https://portal.azure.com, clicar no botão New depois na opção Search como na figura abaixo.

2 – Agora precisamos informar algumas informações para criarmos o novo serviço de busca.

2.1 - URL precisamos informar a URL do serviço, evitando utilizarmos espaços e tracos e ficar dentro

do limite de 15 caracteres.

2.2 - Pricing Tier agora precisamos acessar o Nível de Preço, temos duas opções standard e a opção free , nesse exemplo podemos utilizar a opção free para prova de conceito porem não e indicado para aplicação de produção.

2.3 - Resource Group são contêineres e recursos usados para um proposito comum, podemos utilizar essa estrategia para deixar os serviços juntos.

2.4 - Subscription temos a opção de escolhermos outras assinaturas para o serviço de busca.

2.5 - Location como nos outros serviços do Windows Azure temos a opção de escolhermos a localidade do nosso serviço.

2.6 - Create o botão de criar sera liberado quando todos os campos forem preenchidos corretamente, em poucos minutos, sera criado o serviço.

Uma vez criado o nosso serviço podemos visualizar como na figura abaixo.

Conclusão: Nesse artigo aprendemos a Importância de sistema de busca, uma breve Introdução ao Windows Azure Search e como configurá-lo.

Guia de referência :
http://azure.microsoft.com/en-us/services/search/

Dicas de algoritmos e estruturas de dados parte – 1

2014-07-20T20:03:56.000Z

Vamos falar sobre algoritmos e estrutura de dados básicos, para iniciarmos vamos para o seguinte cenário, temos uma lista de nomes não repetidos e temos que implementar um algoritmo que pesquise um determinado nome caso encontre retorne-o:

Valor

Angelica

Pedro

Paulo

Almeida

Bruna

Poderíamos implementar o seguinte passos de um algorítimo para resolver o problema:

Recebemos o nome para realizar a pesquisa.
Percorremos cada elemento da lista e comparamos se é igual ao nome da pesquisa informada.
Se o nome for idênticos, paramos de percorrer a lista e retornamos o nome.

Esses passos funcionaria eficientemente com uma lista de poucos elementos, agora imagine que essa mesma lista chegue a ter 1 milhão de registros, creio que não seria prudente utilizar os mesmos passos informados, pois imagine a quantidade de tempo que esse algoritmo levaria para achar um nome no meio dessa lista, então podemos dizer que a nossa solução é ineficiente para esse problema.

Além do problema com o os passos informados podemos observar um outro problema, o problema com a nossa estrutura de dados pois ela armazena apenas o valor.

A solução para esse problema seria utilizarmos outra estrutura de dados contendo chave e valor.

Chave	Valor
1	Angelica
2	Pedro
3	Paulo
4	Almeida
5	Bruna

Para essa nova estrutura de dados vamos fazer algumas modificações nos passos que utilizamos em nossa primeira solução:

Recebemos o valor para realizar a pesquisa
Convertemos o valor da pesquisa em um numero
Pegamos esse numero gerado e pesquisamos pela chave da estrutura
Caso a chave exista retornaríamos o valor encontrado

Com essas modificações, não precisaríamos percorrer a nossa estrutura para localizarmos o valor pois teríamos a chave do valor informado, nos exemplos que abordei falamos apenas de pesquisa, porém no próximo post iremos desenvolver toda as operações para pesquisar,adicionar e excluir os elementos na lista.

Conclusão: Muitas vezes o problema não está na nossa implementação e sim na estrutura que estamos utilizando. Uma frase do Linus Torvalds que cabe perfeitamente nesse post “Maus programadores se preocupam com o código. Bons programadores se preocupam com a estrutura dos dados e seus relacionamentos.”

Guia de referência: Livro - Algoritmos O Guia Essência

Mensageria usando MSMQ

2014-07-16T01:30:00.000Z

Vamos falar sobre o poder da mensageria usando MSMQ, antes de iniciarmos o desenvolvimento caso você não conheça o MSMQ é indispensável acessar o link.

Nota: Quando criarmos a fila e necessário marcar a opção transacional

Agora Vamos imaginar que temos uma aplicação que recebe milhares de cadastro por dia, e a cada cadastro nossa aplicação deve enviar um e-mail desejando as boas-vindas para esse novo usuário.

O cadastro será feita de forma automática, quando o usuário enviar os dados eles serão persistido na base de dados, porém o envio do e-mail será feita de uma forma off-line, assim que o usuário realizar o cadastro a nossa aplicação enviara para o MSMQ.

E uma determinada rotina pegara a mensagem da fila e enviara o e-mail.

Definindo uma arquitetura básica de gerenciamento de Fila

Vamos a implementação da nossa classe Gerenciador de fila Base

public abstract class GerenciadorFilaBase
{
       protected abstract string CaminhoFilaBase { get; }
       protected MessageQueueTransaction MessageQueueTransaction { get; set; }
       private MessageQueue MsmQBase()
       {
           var msmq = new MessageQueue(CaminhoFilaBase);
 
           if (MessageQueue.Exists(CaminhoFilaBase))
           {
               msmq.Formatter = new BinaryMessageFormatter();
               return msmq;
           }
 
           msmq = MessageQueue.Create(CaminhoFilaBase,true);
           return msmq;
       }
       protected void AdicionarProximoElemento(object objeto)
       {
           MsmQBase().Send(objeto, MessageQueueTransaction);
       }
       protected T RemoverProximoElemento<T>()
       {
           var proximoElemento = MsmQBase().Receive(MessageQueueTransaction).Body;
 
           return (T)proximoElemento;
 
       }
 
       public abstract void Processar();
}

Implementação da nossa classe Usuario

 [SerializableAttribute]
 public class Usuario
 {
    public string Nome { get; set; }
    public string Email { get; set; }
 }

Vamos a implementação da nossa classe Email Fila

public class EmailFila : GerenciadorFilaBase
{
        protected override string CaminhoFilaBase
        {
            get { return @".\private$\email"; }
        }
 
        public void AdicionarEmailFila(Usuario usuario)
        {
            using (MessageQueueTransaction = new MessageQueueTransaction())
            {
                try
                {
 
                    MessageQueueTransaction.Begin();
                    AdicionarProximoElemento(usuario);
                    MessageQueueTransaction.Commit();
                }
                catch (Exception)
                {
 
                    MessageQueueTransaction.Abort();
                }
            }
 
        }
 
        public override void Processar()
        {
            using (MessageQueueTransaction = new MessageQueueTransaction())
            {
                try
                {
                    MessageQueueTransaction.Begin();
                    var proximoElemento = RemoverProximoElemento<Usuario>();
                    Console.WriteLine("Nome:{0}\nEmail:{1}", proximoElemento.Nome, proximoElemento.Email);
                    MessageQueueTransaction.Commit();
                }
                catch (Exception)
                {
 
                    MessageQueueTransaction.Abort();
                }
            }
        }
 }

Vamos examinar o código da classe acima, temos que implementar alguns atributos e métodos, uns deles é o CaminhoFilaBase nesse atributo precisamos informar o caminho da fila.

O método AdicionarEmailFila recebe por parâmetro um classe Usuario, com essa classe o método chama o AdicionarProximoElemento da classe base e adiciona o elemento na fila com o formato do corpo em binário, e para garantir a integridade estamos realizando a operação de forma transacional.

O método Processar é responsável por remover o nosso objeto da fila e enviar o e-mail, nesse exemplo não implementamos o código responsável que envia o e-mail.

Implementação da classe E-mail fila Test responsável por realizar o teste

[TestClass]
  public class EmailFilaTest
  {
      private readonly EmailFila _emailFila = new EmailFila();
 
      [TestMethod]
      public void Deve_adicionar_um_elemento_na_fila()
      {
          _emailFila.AdicionarEmailFila(new Usuario() { Nome = "Juliano Sales", Email = "juliano.salesg@gmail.com" });
      }
      [TestMethod]
      public void Deve_processar_o_proximo_elemento_da_fila()
      {
          _emailFila.Processar();
      }
  }

Conclusão: Com essa abordagem podemos diminuir drasticamente o processamento da nossa aplicação, sempre que tivermos um problema como o apresentado nesse post, podemos utilizar a mesma abordagem, até a próxima pessoal.

Links Uteis: Mauro Zamaro - MSMQ: Tem mensagem pra você!

Guia de referência: http://elemarjr.net/2012/01/25/trocando-mensagens-entre-aplicaes-usando-msmq-usando-c/, Message Queuing

Ferramentas para testar consultas LINQ.

2014-04-17T03:13:21.000Z

Enquanto Visual Studio oferece muito em relação ao suporte ao LINQ, há uma série de ferramentas em sua maioria livres que irá nos auxiliar e ajudar a testar as nossas consultas LINQ, as ferramentas abaixo são interessantes para desenvolvedores que estão iniciando e conhecendo LINQ.

Ferramentas:

SQL Server Profiler - Ferramentas de gerenciamento do SQL Server que permite que você monitore todos os comando submetidos ao banco de dados.

LINQPad - livre, uma ótima ferramenta para testar e prototipar consultas LINQ.

LINQ to SQL Visualizer - Permite visualize as consultas que serão emitidas com base no seu LINQ to SQL Query. Você também pode modificar o SQL gerado e visualizar os resultados.

LINQ to Entity Visualizer - Permite visualizar as consultas que serão emitidas com base no seu ObjectQuery <T> (LINQ to Entities) consulta. Você também pode visualizar os resultados.

fonte:http://www.thinqlinq.com/Post.aspx/Title/linq-tools

Espero que você considere útil a lista de ferramentas acima, se alguém conhecer mais ferramentas, por favor, contribua.

BrEntityCrud

2014-04-17T02:00:00.000Z

Usando o BrEntityCrud

O BrEntityCrud iniciou com o nome de EFContextoDB, trata-se de um pequeno frameworkinicialmente desenvolvido para ser utilizado com o MySQL.
O seu uso é bastante simples, estão disponíveis duas classes, conexao e contexto.

O componente tomou formas depois que utilizei em aplicativos pessoais e após alguns testes resolvi compartilha-o com outros desenvolvedores, e assim poder melhorar algumas funcionalidades e claro quem tiver interesse em adota-lo fique à vontade.

Segue o link para download do componente e um exemplo de uso em vb.net:

[Download]

Abaixo um pequeno exemplo de uso em vb.net:

1º) Adicione as suas referências o arquivo: BrEntityCrud.dll
2º) Importar o namespace: imports BrEntityCrud

Exemplo1:

Class clientes
'Os campos contidos nesta entidade devem ser identicos aos do banco de dados caso contrário
'Causará uma excessão.
Property id as integer
Property nome as string
Property foto as image
End class

Obs: Após criar o banco de dados tem um método disponível na classe contexto chamado
CriarTabela, Ele cria uma tabela com o nome da classe ex: clientes e os campos campos
correspondentes nesta classe inclusive o seu tipo de dados ficando de fora apenas o tamanho
do campo. Caso não queira o nome da classe é possível configurar o nome no campo
NomeTabela da classe contexto. desta forma ele ignora o nome da classe.

Sub salvar()
'Abaixo a declaração do objeto que contem as informações necessárias para comunicação com
'o MySQL
Dim con as new conexao("server=localhost;port=3306;database=nomebd;uid=root;password=123;")
Dim ctx as new contexto
ctx.db = con'

Dim cli as new clientes
cli.nome = "fulano da silva"
cli.foto = picturebox1.image 'Não precisa converter a foto para salvar no banco de dados.
ctx.salvar(cli)

if cli.id > 0 then
Msgbox("salvo com secesso!")
Eles
Msgbox("falhou !")
End iF

End Sub

Sub Pesquisar()
Dim con as new conexao("server=localhost;port=3306;database=nomebd;uid=root;password=123;")
Dim ctx as new contexto
Dim cli as new clientes

ctx.db = con
ctx.WhereCampo = "ID"

cli.ID = 1 'Id referente ao registro manipulado.
ctx.Selecionar(cli)

if cli.ID > 0 then
txt_COD.text = cli.id
txt_NOME.text = cli.nome
picturebox1.image = cli.foto 'Não precisa converter a foto para ler do banco de dados.
else
Msgbox("Nenhum registro encontrado !")
End if
End Sub

Exemplo2:
Com herança.

Class clientes
inherits contexto
Property id as integer
Property nome as string
Property foto as image
End class

Sub salvar()
Dim con as new conexao("server=localhost;port=3306;database=nomebd;uid=root;password=123;")
Dim cli as new clientes
cli.db = con

cli.nome = "fulano da silva"
cli.foto = picturebox1.image
cli.salvar

if cli.id > 0 then 'O campo cli.id já retorna com o id do registro salvo.
Msgbox("salvo com secesso!")
Eles
Msgbox("falhou !")
End iF
End Sub

Sub Pesquisar()
Dim con as new conexao("server=localhost;port=3306;database=nomebd;uid=root;password=123;")
Dim cli as new clientes

cli.db = con
cli.WhereCampo = "ID"
cli.ID = 1 'Id referente ao registro manipulado.
cli.Selecionar

if cli.ID > 0 then
txt_COD.text = cli.id
txt_NOME.text = cli.nome
picturebox1.image = cli.foto
else
Msgbox("Nenhum registro encontrado !")
End if
End Sub

Dúvidas, Críticas e/ou sugestões serão bem vindas.

.NET para iOS, Android e Windows Phone: Uma nova Proposta CrossPlatform

2014-04-01T13:24:52.000Z

Quando começamos a nos envolver com desenvolvimento Mobile, fica muito difícil escolher por qual plataforma começar ou defender, digamos assim, dentre tantas opções que temos hoje no mercado.

Cada plataforma vem com uma proposta , comportamento, requisitos , linguagens diferentes e claro , cada pessoa tem a sua linguagem preferida. Porém isso faz de certa forma que os desenvolvedores fiquem restritos à aquela linguagem ou plataforma que vivem aquela história de lealdade e defesa da plataforma, porém quem acaba perdendo com isso, é o próprio desenvolvedor.

Pra quem já sabe e trabalha com .NET está em uma posição muito favorável, pois a Microsoft veio com uma parceria e uma nova proposta para aproveitar o .NET com o C# para iOS, Android e Windows Phone.

Ultimamente temos visto muitas novidades vindo nos Smartphones, os telefones foram transformados de simples dispositivos para fazer ligações a verdadeiros computadores moveis e muito poderosos. Muitos deles vem super completos equipados com telas de alta resolução, GPS, Cameras que gravam vídeos e tiram fotos em excelente resolução , aplicativos cada mais mais integrados com varias redes sociais , quase estão fazendo café e muitos deles quase esquentam uma lasanha de tão quente que fica a bateria =D

Como qualquer área do mercado a coisa é bem dinâmica, principalmente quando se trata de tecnologia. Podemos dizer que a Apple foi o pioneiro nessa revolução dos telefones moveis, vindo em 2007 com o iPhone, trazendo um conceito novo, com tela sensível ao toque, experiência melhor pro usuário, entre outros N recursos. Querendo ou não, ainda é o sistema operacional que mantem como referencia de SO mobile, onde é encontrando tanto no smartphone iPhone como no Tablet iPad e no iPod.

O Android, quando foi comprado pela Google em 2005, resolveu colocar uma nova proposta no mercado atingindo os aparelhos de todos os níveis, desde o mais básico e barato, até o mais TOP como um Galaxy 5. Desde de 2008 ele vem tendo diversas versões lançadas, o que fez com que alcançasse mais de 50% do mercado e menos de 4 anos de vida e ainda continua a crescer. Essa nova proposta trouxe uma flexibilidade maior para os fabricantes de devices, por se tratar de um SO openSource , muitas versões são modificadas para atender a demanda dos devices que são lançados, fazendo com que eles sejam barateados.

A Microsoft demorou um pouco para voltar ao mercado com uma nova proposta, então em 2010 lançou o Windows Phone 7, ansiosamente esperada desde a sua ultima versão, o Windows Mobile. Dessa vez a Microsoft trouxe uma proposta bem diferente do iOS e o Android, trazendo para a tela Live Tiles com informações diretas e dinâmicas para o usuário, tendo uma fluidez e proposta de usabilidade natural. Com isso os fabricantes de dispositivos como a Nokia, que adotou o Windows Phone, tiveram uma certa liberdade para projetar seus devices, mas seguindo rigidamente um conjunto mínimo de requisitos que a Microsoft dita, para que seja mantida a estabilidade e qualidade do sistema, evitando problemas de fragmentação , como acontece hoje no Android.

Mesmo sendo plataformas móveis, o iOS, Android e Windows Phone, possuem maneiras diferentes de executar suas tarefas, sua linguagens próprias e forma de uso dos hardware diferenciadas. Por exemplo as aplicações iOS são escritas em Objective C, o Android em Java e o Windows Phone utiliza o C# e VB.net. Acredito que, como desenvolvedores, não gostaríamos nem um pouco de que para atingir o maior numero de usuários em várias plataformas, ter que aprender novas linguagens para escrever 3 vezes a nossa aplicação, testar 3 vezes, corrigir bugs 3 vezes e gastar 3 vezes mais tempo para tudo!!! Porque não otimizar o nosso tempo e ganhar mais com isso, diminuindo a nossa curva de produção da nossa APP para mais de uma plataforma?

É então essa a proposta, “Escreva uma vez, execute em qualquer lugar” , essa é a proposta, que já não é nova. Essa proposta já havia sido apresentada pela SUN quando foi lançado o Java, com a proposta de ser uma linguagem unificadora para todas as plataformas e dispositivos.

Então uma empresa chamada Xamarin, usando como base o projeto MONO, lançou essa nova e fascinante proposta utilizando o C# e todo o poder da plataforma .net, aliada ao poderoso IDE Visual Studio.

Quam irá ganhar com isso, seremos nós desenvolvedores, reduzindo nosso tempo gasto para escrever e lançar nossos aplicativos.

O que a Xamarin fez foi trazer a proposta, escrever uma vez , execute em qualquer lugar, utilizado todo o poder do C# junto com as Base Class Libraries, que são usados como uma biblioteca e uma linguagem universal, para expor aos desenvolvedores elementos específicos de cada dispositivo e interface de cada plataforma, pois como já sabemos o .NET roda nativamente no Windows Phone, o que não significa que não iremos rodar nativamente esse código dentro do Android e dentro do iOS, que para isso iremos usar o poder do MonoTouch e do Mono For Android, contido no Xamarin.

O que acontece é que o MonoTouch e o Mono for android disponibiliza o .NET para o iOS e para o Android, usando o Mono, que é um compilador open source e multiplataforma da CLI, um padrão que define um ambiente de execução virtual usado pelo C#.

Se já tiver algum conhecimento no .NET vai conseguir usar tranquilamente o Xamarin associado ao Visual Studio , já que os namespaces e Base Class Libraries à disposição.

Nos próximos posts sobre o assunto, já entrarei numa questão mais técnica e prática, para tentar passar a mensagem do quão será fácil desenvolver para as 3 maiores plataformas reaproveitando ao máximo a nossa regra de negócios.

Não vamos precisar nos preocupar com Objective C, Java , vamos poder usar os recursos do C#, generics, LINQ, eventos, recursos de threads, etc.

Hoje para versão Windows não temos versões gratuitas, você pode baixar no site do Xamarin uma versão trial para testar ou caso seja estudante pode solicitar um desconto e adquirir por $99 cada licença.

Saiba Mais em:

Comunidade do Xamarin

Site Xamarin

Visual Studio

Blog Rogério Rodrigues

Validando models com DataAnnotations e Attributes no ASP.NET MVC

2014-02-17T00:00:00.000Z

Nest post vou falar um pouco sobre a utilização de DataAnnotations e Attributes para validação de models em projetos ASP.NET MVC.

Conceitos básicos: Em C# (e também em Visual Basic.NET), um Attribute é uma classe para associação de metadados ou informações declarativas em classes, métodos ou membros. Utilizar um Attribute é normalmente referido como "decorar com o atributo".

O System.ComponentModel.DataAnnotations é um namespace introduzido no .NET 3.5 que nos fornece um conjunto de atributos que podem ser classificados como:

ValidationAttributes: Derivam da classe ValidationAttribute e são usados para garantir regras de validação que podem ser aplicadas a classes ou membros.

DisplayAttributes: Usados para especificar como os dados de uma classe ou membro são exibidos.

Data Modeling Attributes: Usados para especificar a estrutura e o relacionamento entre classes de dados (muito utilizados no Entity Framework Code First).

Neste exemplo, utilizarei atributos do tipo ValidationAttributes e DisplayAttributes

Objetivo: Farei aqui um formulário simples de validação de contatos, decorando o modelo com alguns atributos. Não entrarei em questões sobre arquitetura de projeto, e parto do princípio de que o(a) leitor(a) já esteja familiarizado com a estrutura e funcionamento do ASP.NET MVC.

Ferramentas utilizadas: Utilizei para este exemplo o Visual Studio 2013, o .NET Framework 4.5, e o projeto foi criado no template ASP.NET Web Application / MVC 5, que já traz consigo as referências para o bootstrap.

Let's code!:

Criando o Model

Este simples modelo define a classe Contato com alguns atributos interessantes em seus membros, sendo eles:

[DisplayName] : Quando nos referirmos ao model através da view, o texto que será exibido na Label é o definido neste atributo, ao invés do nome da propriedade. Isso é muito útil quando o nome da propriedade e do desejado diferem, como no caso do Email (nome da propriedade) e E-mail (nome de exibição).

[Required] : Especifica que o campo obrigatório.

[StringLength] : Especifica a largura mínima e máxima da string aceitos no campo.

[EmailAddress] : Atributo já pronto para a validação de e-mails.

[RegularExpression] : Atributo que valida se o valor da propriedade satisfaz a uma expressão regular definida. No caso, utilizei para validar um campo que aceita apenas números.

[Remote] : Não é um DataAnnotation, mas sim um atributo específico do ASP.NET MVC. Basta especificar o nome da Action, seguida pelo controller, e ele fará uma requisição AJAX enquanto você preenche o campo, passando o valor digitado como argumento da action fornecida. Utilizei para validar se o endereço digitado já existe.

Criando o Controller

O controller contém uma action chamada "ConsultaEmailsCadastrados", que graças ao atributo [Remote] citado anteriormente, é acessado sempre que você digitar algum valor no campo Email. No exemplo, se o e-mail digitado já existir na lista, o método retornará uma resposta inválida e a mensagem de erro especificada será exibida.

Ao postar o formulário para a action “CadastrarContato”, devido ao fato da view estar ligada ao model Contato e seus membros, um objeto do tipo “Contato” será passado como parâmetro. Nesta action verifico o valor booleano da propriedade IsValid do dicionário ModelState, que também pode nos fornecer uma lista de erros ocorridos na validação.

Criando a View

Utilizando o Razor View Engine do ASP.NET MVC e suas funções definidas, crio a GUI de forma que os campos da tela se associem ao model através dos Lambda Expressions. As labels geradas pelo @Html.LabelFor irão exibir exatamente o valor definido no atributo [DisplayName], enquanto o @Html.ValidationMessageFor irá exibir as mensagens de erro definidas nos atributos de validação sempre que o input for inválido.

Dica: Você pode usar um @Html.ValidationSummary para exibir todos os erros de validação de uma vez só.

Rodando a aplicação:

Aqui podemos visualizar a validação ocorrendo no lado do cliente, que não permite que o post chegue ao servidor enquanto as regras não forem satisfeitas. Caso você desabilite o Javascript do navegador, a mesma validação ocorrerá somente no server.

Detalhes essenciais: Para que a validação no lado do cliente funcione como na imagem, é necessário adicionar 3 bibliotecas Javascript, sendo elas:

Vale lembrar que mesmo adicionando-as, você precisará ter a chave “UnobtrusiveJavaScriptEnabled” habilitada no web.config da aplicação:

Conclusão: Com a utilização dos DataAnnotations e Attributes, podemos facilmente validar nossas aplicações, poupando retrabalho e garantindo a segurança dos dados de maneira prática e centralizada.

Código Fonte deste exemplo

Visite também:

http://msdn.microsoft.com/en-us/library/system.componentmodel.dataannotations(v=vs.110).aspx

Aprofunde seus conhecimentos sobre o tema visitando a comunidade ASP.NET

Publicando site ASP.NET no Windows Azure via Visual Studio Online

2014-01-13T21:56:34.000Z

Integração e agilidade são as palavres da vez no meio de desenvolvedores de software. Ainda mais se estivermos falando de serviço, e não mais de software de prateleira. Isso porquê esse conceito de software de escopo ou caixa fechada, nos dias de hoje, não é mais visto como algo viável, rentável, sustentável ou mesmo lucrativo. E hoje desenvolvedores de software vivem uma realidade que lhes são exigidos alta qualidade, entregas ágeis e em períodos curtos, afim de minimizar os riscos.

Considerando isso, o desenvolvedor, mesmo que trabalhe sozinho, de forma autônoma, necessita ter um ambiente de trabalho que sirva como ferramenta para entregar toda essa expectativa que lhe é exigido. Uma plataforma, que não seja apenas uma IDE de desenvolvimento, mas uma completa plataforma de gestão de aplicação. Uma plataforma que sirva, não apenas como repositório de códigos fontes, mas de gestão e governança destes, criando rastreabilidade entre o que foi desenvolvido e o que foi solicitado pelo seu cliente. E um ambiente de altíssima disponibilidade e escalabilidade para hospedagem e distribuição da sua aplicação de forma fácil, ágil e segura.

Visando cobrir todas essas necessidades, e ainda excedendo entregando muito mais recursos de produtividade, governança e indicadores que passam segurança e estabilidade agregando valor ao ~~camarote~~ produto, a Microsoft fornece 3 ferramentas, GRATUITAS:

Visual Studio Express for Web
Visual Studio Online
Windows Azure Websites

Todas as três ferramentas já são de grande conhecimento da maioria dos desenvolvedores .NET. Então, em seguida, vou mostrar como publicar seu projeto desenvolvido em ASP.NET (3.5 ou superior) na nuvem do Windows Azure através de implementação contínua do Visual Studio Online.

Primeiro passo: Visual Studio Express

Primeiramente vou criar um projeto ASP.NET MVC usando o template padrão do Visual Studio 2013. A ideia é apenas ter uma representação do que será o seu projeto web.

Com o Visual Studio 2013 aberto, vou no menu File > New Project. Na janela aberta crio um projeto chamado MeuSiteNaNuvem:

Na tela seguinte, selecionamento apenas o template MVC e clicamos OK.

Com isso já tenho nosso projeto ASP.NET MVC criado. Esse irá representar o seu projeto web que já possui.

Segundo passo: Visual Studio Online

Acesso o serviço do Visual Studio Online em http://www.visualstudio.com/, crie sua conta e, após tudo configurado, começaremos a na dashboard como na imagem abaixo:

Já com sua conta rodando e configurada, vamos criar um novo projeto dentro do VSOnline para então defini-lo como o controlador de versão de fontes para o VS2013 e, a partir daí tornar possível fazer toda uma gestão de projeto de desenvolvimento de software, usando metodologia Scrum ou mesmo Agile Software Development ou CMMI.

Clique em “Create Project” e aguarde. Ao concluir, o Visual Studio Online irá retornar uma mensagem que eu acho muito legal!

Clique em “Navigate to Project” e pronto! Seu ambiente VSOnline já está pronto para receber seu projeto ASP.NET. Sendo assim, voltemos ao Visual Studio Express, no menu Team > “Connect to Team Foundation Server…”, adicione como servidor a URL da sua conta no VSOnline (ex: seunome@visualstudio.com) e selecione o nome do projeto que iremos vincular ao nosso site ASP.NET

Assim que finalizado, e ainda no Visual Studio Express, vá na aba Solution Explorer, abra o menu contexto no arquivo da solução aberta, e então clique em “Add Solution to Source Control…“.

O Visual Studio suporta conectar tanto em controlador de versão Team Foundation Version Control (atual Visual Studio Online) quanto Git (via GitHub). Selecione TFS e dê OK.

Na janela seguinte você deve selecionar em qual workspace seus fontes irão se hospedar. Selecione a raiz do projeto que foi criado no VSOnline e dê OK. Para mais detalhes sobre workspace, pesquise sobre Administração do TFS.

Perceba que agora todos os arquivos dos projetos da sua solução terão um sinal de mais ( + ). Isso indica que são arquivos novos e que serão carregados ao controlador de versão no próximo Check-In. Não faça o check-in neste momento ainda.

Terceiro passo: Windows Azure

Acesse o painel de controle da sua conta no Windows Azure em http://manage.windowsazure.com/. Caso ainda não possua uma conta configurada, crie uma e faça uma assinatura “Pay-As-You-Go“. Fique tranquilo, pois não iremos consumir nenhum recurso que seja cobrado um centavo sequer.

Já no painel de controle, clique na aba “WebSites“, em seguida, no rodapé, vá em Novo > Computação > Site > Criação Rápida e dê um nome para a URL do seu site dentro do Windows Azure. Selecione também a região que ficar mais próxima de onde você estará acessando, afim de deixar o tempo de resposta ainda mais curto (na época que escrevi o artigo, a Microsoft ainda estava preparando o datacenter em São Paulo).

Assim que finalizar a criação do seu site, você será direcionado para essa página. Clique então no último link que diz “Configurar a implantação a partir do controle de origem” para vincularmos esse website ao controlador de versão do VSOnline.

O Windows Azure aceita que os arquivos de seu site seja fornecido por vários repositórios. Selecione a opção Visual Studio Online e continue para o próximo passo clicando na setinha para direita.

No passo seguinte, informa o nome da sua conta Visual Studio Online (ex: seunome.visualstudio.com) e então clique em “Autorizar Agora”.

Nisso o Windows Azure irá até o VSOnline, irá confirmar suas credenciais e retornará com a lista de projetos que possui em sua conta. Selecione o projeto que deseja publicar neste website e conclua os passos.

Ao fim do processamento, o Windows Azure irá te confirmar que tudo está devidamente configurado e vinculado. As configurações do Windows Azure terminam aqui, agora vamos para o deploy!

Passo final: Implementação contínua

Já temos os três ambiente devidamente vinculados e configurados. Agora basta sinalizarmos para o VSOnline que terminamos de alterar o fonte e que podemos enviar os arquivos para nuvem e deixar toda a infra estrutura fazer o trabalho pesado. Volte no Visual Studio Express e, no meu contexto da solução, selecione “Check In” para iniciarmos o processo de envio dos arquivos para o repositório de código fonte.

Essa opção irá nos levar para a aba do Team Explorer, já na tela de Pending Changes (modificações pendentes) detalhando todos os arquivos que estão aguardando subirem para o repositório. No campo de comentário (comment), insira informações sobre essa subida afim de ter um mínimo de rastreabilidade do que foi modificado a cada Check In. Caso esteja usando alguma metodologia de gestão de desenvolvimento de software no VSOnline (Backlog, Sprint, Tasks, Impeachment, etc), vc pode vincular esse check in a algum desses itens através do campo Related Work Items.

Clique no botão “Check In” ao topo. Ao concluir o processo de subida, clique no botão “Home” e depois vá em “Builds” para listar a fila de publicações que o ambiente que criamos está gerindo, testando, compilando e validando antes de enviar para o ambiente de publicação.

Acompanhe todo o processo de build e deploy do fonte que foi enviado para o VSOnline e então submetido (caso passe nos testes e builds) para o ambiente vinculado do Windows Azure.

Agora é só acessar a URL do site que foi definido na criação do mesmo no Windows Azure para validar que está publicado com sucesso! No exemplo está publicado em http://meusitenanuvem.azurewebsites.net/

Também é possível fazer o acompanhamento dos builds via Visual Studio Online, na guia Implantações do site do projeto.

Finalizando

Esse são os passos mínimos necessários para se ter um ambiente com controle de códigos fontes, implementação contínua, disponibilidade, entre outros. A partir daí, pode-se aumentar a produtividade consumindo mais recursos do Visual Studio Express como projetos de testes unitário, do Visual Studio Online como gestão de desenvolvimento como Srum, e do Windows Azure como vincular recursos adicionar como banco de dados. E tudo isso sem nenhum custo, totalmente gratuito.

Para saber mais

Aprofunde seus conhecimentos na comunidade ASP.NET

Aprofunde seus conhecimentos na comunidade Windows Azure

Entity Framework: Convenções (Conventions)

2014-01-09T14:02:26.000Z

Comecei trabalhar com Entity Framework a pouco tempo. Como disse algumas vezes em minhas redes sociais, eu tenho uma relação de amor e ódio com esse framework. Isso porquê tem horas que me sinto amarrado, e outra que parece ser 10 vezes mais veloz desenvolver com ele do que usando ADO.NET.

Enfim, nos meus primeiros contatos fui apresentado a um super facilitador do EF, as Convenções. Convenções são conjuntos de regras que são usadas para configurar automaticamente um modelo conceitual com base em definições de classe. As convenções são definidas no namespace System.Data.Entity.ModelConfiguration.Conventions.

Essas convenção se comportam da mesma maneira que no ASP.NET MVC. Através da formatação da nomenclatura de sua classe, propriedade ou variável, o Entity Framework já irá entender de qual entidade do banco de dados está se referindo. E para deixar tudo ainda mais claro, no Entity Framework existem alguns tipos de convenções.

Chave Primária (Primary Key)

Essa convenção rege que uma propriedade é uma chave primária se, em uma classe, é chamada “ID” (não é caso sensitivo), ou se é chamada pelo nome da classe seguido por “ID”. Se o tipo da propriedade chave primária for numérico ou GUID será configurado como uma coluna de identidade.

public class Usuario
{
    public int UsuarioID { get; set; }
    //... outras propriedades
}

Relacionamento (Relationship)

Podemos também instruir ao EF onde existem e quais tipos de relacionamentos estão sendo aplicados nas entidades do banco de dados. Apenas usando as regras de convenções, podemos informar se o relacionamento aplicado é <um-para-um>,<um-para-muitos>, ou <muitos-para-muitos>. Até mesmo se a existência de um registro pai é ou não obrigatória dependendo do tipo da propriedade da chave estrangeira em questão.

public class Estado
{
    // Primary key
    public int EstadoID { get; set; }
    public string Sigla { get; set; }
    // Navigation property
    public virtual ICollection Cidades { get; set; }
}
public class Cidade
{
    // Primary Key
    public int CidadeID { get; set; }
    public string Nome { get; set; }
    // Foreign Key
    public int EstadoID { get; set; }
    // Navigation property
    public virtual Estado Estado { get; set; }
}

Conexão (Connection)

Após ter todas as classes de domínio já declaradas de forma a representar as entidades do seu banco de dados, definimos a classe de contexto do tipo DbContext afim de conectarmos esse domínio ao banco de dados e, então, iniciarmos a manipulação de informações persistentes. Para isso também existe uma regra de convenção que podemos usar. Basta criar sua classe de contexto com o mesmo nome da sua Connection String declarada no web.config da aplicação web.

Considerando a seguinte declaração de uma Connection String no web.config:

<configuration>
  <connectionStrings>
    <add name="BancoPrincipal"
         providerName="System.Data.SqlServer"
         connectionString="Server=.\SQLExpress;AttachDbFilename=MyDataFile.mdf;Database=dbname;"/>
  </connectionStrings>
</configuration>

Nossa declaração da classe de contexto, usando as devidas regras de convenção, fica:

public class BancoPrincipal : DbContext
{
    public DbSet<Usuario> Usuarios { get; set; }
}

Neste exemplo, o EF saberá que o contexto BancoPrincipal deverá se conectar ao banco de dados usando a ConnectionString de mesmo nome declarada no web.config.

Mais Convenções

Existem, claro, muito mais regras de convenções dentro do Entity Framework. Essas que eu citei são as que tive o primeiro contato quando comecei a trabalhar com EF.

Abaixo compartilho uma lista de demais convenções do EF para seu estudo.

Aprendam bem todas as regras que irão se aplicar ao código de vocês e ganhem velocidade no desenvolvimento.

Para saber mais

Aprofunde seus conhecimentos na comunidade ASP.NET

DICA: Erro Get/Refresh TFS OAuth token failed with invalid_grant

2013-12-11T19:57:36.000Z

Alguns usuários tem reportado nos fóruns um erro que vem acontecendo durante o processo de chekin de arquivos para o TFS Online (Visual Studio Online).

Recentemente esse mesmo erro aconteceu comigo durante o processo de implantação de código. E com isso as alterações feitas no código ou mesmo novos arquivos adicionados, não são implantados. A solução para esse erro é o seguinte:

No Menu esquerdo do painel de controle do Windows Azure clique em Desconectar do Visual Studio Online.

A partir daí vamos criar uma nova conexão.

Ainda no painel de controle, clique em "Configurar a implantação a partir do seu ponto de origem".

Será aberto uma tela onde você poderá escolher a sua fonte de dados:

Escolha onde está a sua fonte de dados. Siga os próximos passos autorizando novamente o acesso a sua conta do Visual Studio Online.

Em seguida escolha qual aplicação deseja vincular novamente.

Após a conclusão desse processo. O seu histórico de implantação voltará a ser exibido no seu painel do Windows Azure, e também suas implantações voltarão a ser aplicadas.

Para saber mais:
Aprofunde seus conhecimentos sobre este tema na comunidade ALM

Projeto Katana e o desenvolvimento web com .NET - Prática

2013-12-04T10:00:00.000Z

Na parte anterior do post abordamos uma introdução ao projeto Katana e suas motivações, bem como o OWIN (Open Web Interface for .NET). Neste post introduziremos alguns conceitos na prática bem como as bibliotecas necessárias para a construção de aplicações compatíveis com o OWIN através do projeto Katana. Observação: Link para download do código disponível ao final do post.

Criando o projeto

Para reproduzir os mesmos exemplos é necessário o Visual Studio 2013 ou a versão Express 2013 para Web, que pode ser obtida gratuitamente.

Nesta prática criaremos uma pequena aplicação e hospedaremos através do IIS e em seguida reutilizaremos o mesmo projeto em um host customizado através de uma aplicação console.

Para dar inicio criaremos pelo o Visual Studio uma aplicação ASP.NET vazia conforme Figura 1.

Figura 1 - Criação do projeto

Em seguida crie um novo item na solução. Escolha a opção OWIN Startup Class conforme figura Figura 2. Serão instalados dois pacotes ao projeto ao incluir esta classe, sendo eles o pacote Microsoft.Owin contendo a base para os outros componentes do projeto Katana e o pacote Owin.

Figura 2 - Classe startup e referências adicionadas automaticamente.

A classe criada possui uma convenção, incluindo um método void nomeado Configuration e recebe uma instancia de um objeto que implemente a interface IAppBuilder, permitindo a compatibilidade de servers e hosts não somente utilizando o projeto Katana, mas futuras implementações de servers e hosts de terceiros.

O código da classe startup pode ser conferido a seguir:

using Owin;

[assembly: OwinStartup(typeof(KatanaDemo.Startup))]

namespace KatanaDemo
{
using AppFunc = Func<IDictionary<string, object>, Task>;

public class Startup
  {
      public void Configuration(IAppBuilder app)
      {
          // app.UseFoo
          // app.UseBar
      }
  }
}

O método Configuration será responsável por registrar todos os componentes middleware para serem executados a cada requisição.

Middleware

Os middlewares são componentes capazes de manusear o objeto Environment Dictionary, definido pela especificação OWIN. O middleware pode ser desde um simples componente de autenticação até um framework completo como o ASP.NET WebApi ou SignalR. A porta de entrada para a comunicação entre o server e o middleware é a assinatura do Application Delegate demonstrado no post anterior.

Servers e Hosts

Dentro do contexto do OWIN, os Hosts podem ser desde um server IIS, até aplicações Windows Forms e Serviços do Windows, sendo ele responsável pelo carregamento e finalização de componentes internos OWIN. Os Servers são responsáveis pela ligação TCP, construir o Environment Dictionary e processar cada um dos componentes registrados no IAppBuilder através da pipeline criada para a execução.

Conforme conferimos na Figura 3, temos o diagrama demonstrando os participantes deste processo e como se associam.

Figura 3 - Fluxo (Host/Server/Pipeline)

Para darmos continuidade, utilizaremos o server demonstrado na Figura 3 denominado SystemWeb, ele permitirá executarmos nossa aplicação dentro da pipeline do ASP.NET onde a mesma atuara como um Host e Server ao mesmo tempo. Para isso instalamos mais um componente do projeto Katana através de PMC. Execute o comando abaixo:

> Install-Package Microsoft.Owin.Host.SystemWeb

Após concluir a instalação criaremos dois middlewares de exemplo em nosso projeto, um será responsável por devolver uma mensagem “hello katana” e o outro responderá qual o path solicitado através da URL digitada.

public class HelloMiddleware
{
readonly AppFunc _next;

public HelloMiddleware(AppFunc next) { _next = next; }

public async Task Invoke(IDictionary<string, object> env)
  {
      var responseBody = env["owin.ResponseBody"] as Stream;
      var hello = System.Text.Encoding.UTF8.GetBytes("Hello Katana!");
      await responseBody.WriteAsync(hello, 0, hello.Length);

await _next.Invoke(env);
}
}

public class PathMiddleware : OwinMiddleware
{
public PathMiddleware(OwinMiddleware next) : base(next) { }

public override async Task Invoke(IOwinContext context)
  {
      await context.Response.WriteAsync(String.Format(" at {0}", context.Request.Path.Value));
      //await Next.Invoke(new OwinContext(env));
  }
}

Entenderemos adiante cada middleware, e por hora para utilizar ambos, registraremos na seguinte ordem de nosso método Configuration na classe Startup.

public void Configuration(IAppBuilder app)

{

app.Use<HelloMiddleware>();

app.Use<PathMiddleware>();

}

Ao executarmos, nossa aplicação com o velho F5, ao acessarmos uma URL especifica como http://localhost:xxx/path/to/pipeline em nosso navegador, teremos o resultado conforme Figura 4.

Figura 4 - Katana através da pipeline do ASP.NET

Nosso primeiro middleware segue uma convenção padrão respeitando a assinatura do Application Delegate, ou seja nosso método Invoke é assíncrono, e recebe o objeto Environment Dictionary, no exemplo obtivemos o objeto que corresponde ao corpo de resposta HTTP com a chave conforme a especificação OWIN descreve e escrevemos uma mensagem no objeto Stream. O segundo middleware é mais interessante pois herdamos de uma classe de auxilio do projeto Katana que visa facilitar a criação de middlewares, facilitando a manipulação de dados do Environment Dictionary de maneira tipada provendo um objeto do tipo OwinContext. Veja que internamente existem alguns recursos para facilitar a execução dos middlewares seguintes de forma encadeada, recebermos o próximo middleware a ser executado e decidirmos se o mesmo poderá ser executado ou não, este tipo de recurso é útil em cenários de autenticação.

Usando uma Framework real

Desta vez utilizaremos um framework real em nossa aplicação, o ASP.NET WebApi. Comecemos instalando o pacote que habilita o WebApi para o uso com o OWIN. Pelo PMC execute o seguinte comando:

> Install-Package Microsoft.AspNet.WebApi.Owin

Após instalação, criamos um controller conforme abaixo em nosso projeto:

public class ValuesController : ApiController
  {
      public string[] Get()
      {
          return new[] { "SignalR", "ASP.NET MVC", "WebApi", "WebPages", "WebForms" };
      }
  }

E registramos o WebApi em nosso objeto IAppBuilder através de um extension method chamada UseWebApi conforme abaixo, incluída com o pacote que acabamos de instalar.

//..outras diretivas using

using System.Web.Http;

public void Configuration(IAppBuilder app)
{
var httpConfig = new HttpConfiguration();
httpConfig.Routes.MapHttpRoute("default", "api/{controller}");

app.UseWebApi(httpConfig);

//… outros middlewares
}

Ao executarmos nossa aplicação e entrarmos com a URL http://localhost:xxx/api/values teremos o seguinte resultado conforme Figura 5.

Figura 5 - WebApi em ação

Com isso podemos utilizar o conhecimento que já temos para criar nossas aplicações utilizando outros frameworks disponíveis e compatíveis com o OWIN como ASP.NET SignalR ou NancyFx.

Portando a aplicação

Antes de concluirmos os exemplos vamos portar esta aplicação para execução em outro ambiente. Para tal, crie uma novo projeto neste mesmo solution utilizado, do tipo Console Application e inclua uma referência de nosso projeto anterior. Observação: Caso esteja no Visual Studio Express, crie o projeto como uma Class Library (Biblioteca de Classes *.dll) e através das propriedades (Alt+Enter) troque o output para Console Application conforme Figura 6.

Figura 6

Para prosseguir, inclua os mesmos pacotes que foram incluídos no projeto anterior desta mesma solution, com exceção do server SystemWeb, que desta vez será substituído por dois outros componentes do projeto Katana. O primeiro, Microsoft.Owin.Hosting responsável por prover as classes necessárias para realizarmos o Host em um processo customizado, e segundo, o server Microsoft.Owin.Host.HttpListener. Observação: Necessário trocar o projeto Default no PMC para que sejam incluindo os novos pacotes no projeto correto. Execute o comando abaixo.

> Install-Package Microsoft.Owin.Hosting

> Install-Package Microsoft.Owin.Host.HttpListener

Em nossa classe Program do novo projeto incluímos o código abaixo. Inclua as referencias através da diretiva using para enxergar a classe Startup criada no projeto web anteriormente.

public static void Main(string[] args)
{
var app = WebApp.Start<Startup>("http://localhost:1234");

Console.WriteLine("Pressione Enter para fechar...");
Console.ReadKey();

app.Dispose();
}

Ao rodar a aplicação com o F5, teremos o mesmo resultado do outro projeto porem fora do ambiente do IIS conforme Figura 7.

Figura 7 - Self-Hosting em ação

Conclusão

Conforme conferimos, foi introduzido os conceitos práticos iniciais para a utilização do projeto Katana e o porte de uma aplicação OWIN para outro Host e Server sem necessidade de alteração no código fonte. Seria possível portar para outras plataformas como o runtime Mono ao invés do .NET Framework. Esta independência abre caminhos para muitos recursos, incluindo ferramentas para automação de testes de integração sem a necessidade de levantar o IIS, e isto é só a ponta do que é possível fazer. Vamos ficar atentos aos próximos passos do projeto Katana através do seu Roadmap e as contribuições ao OWIN criados pela comunidade. Para maiores detalhes consulte as referências deste post. Até a próxima e bons estudos!!!

Código utilizado neste post:

http://sdrv.ms/1amhhoQ.

Referências:

http://owin.org

http://katanaproject.codeplex.com

http://www.asp.net/aspnet/overview/owin-and-katana/an-overview-of-project-katana

http://msdn.microsoft.com/en-us/magazine/dn451439.aspx

Projeto Katana e o desenvolvimento web com .NET - Introdução

2013-12-01T18:30:00.000Z

Este post é dividido em duas partes, a primeira tem o papel de introduzir o projeto Katana criado pela Microsoft e a especificação OWIN e o que isso contribui ao desenvolvimento web utilizando o .NET Framework, a segunda parte terá como papel, introduzir a parte prática. Porém antes de descrever o Katana é necessário entender as motivações do projeto.

Desafios

Analisando rapidamente a linha do tempo do ASP.NET, sua primeira versão trouxe organização de código e introduziu o paradigma orientado a objetos em contraste as aplicações construídas com o asp clássico, e introduziu também um ambiente visual com controles de servidor (Server Controls) que trazia um ambiente similar ao que desenvolvedores VB6 tinham, visando diminuir a curva de aprendizagem e adoção do desenvolvimento web para desenvolvedores desktop.

No entanto a natureza do ASP.NET era monolítica, contendo todas as funcionalidades como os objetos relacionados ao core do HTTP e ao framework WebForms em uma unica dll (System.Web) com um acoplamento a infraestrutura especifica de host do IIS, outro detalhe é que o mesmo fazia parte das releases do Framework .NET. Com este cenário o time do ASP.NET encontrou dificuldades em entregar novos recursos e melhorias conforme a evolução do desenvolvimento para web em geral acontecia.

Evolução

Devido a evolução constante e novos padrões introduzidos ao desenvolvimento web como o MVC (Model View Controller), foi criado o ASP.NET MVC habilitando alem do desenvolvimento sobre um novo paradigma, também a entrega de releases sem vinculo com as releases do Framework .NET, introduzindo flexibilidade ao time do ASP.NET para introduzir novos recursos. Outros produtos como ASP.NET Web Api e SignalR foram introduzidos mais tarde, desta vez independentes da infraestrutura monolítica do core do ASP.NET e o host especifico do IIS.

Futuro já presente

Com a adoção de tecnologias como Nodejs e projetos como o Rack que define uma interface entre servidores e frameworks Ruby, a comunidade de desenvolvedores .NET começou a fomentar ideias e discussões no grupo NET HTTP Abstractions, concebendo uma especificação que tinha como proposito definir uma interface de abstração entre servidores e aplicações permitindo um ecossistema rico baseado em componentes para aplicações e servidores web baseados em .NET, dando vida ao OWIN (Open Web Interface for .NET). Segundo a especificação do OWIN, poderíamos rodar aplicações web agnósticas de servidor promovendo uma maior autonomia e a possibilidade de incluir recursos/componentes a sua aplicação conforme necessidade.

OWIN

Os objetivos do OWIN garantem que novos componentes possam ser facilmente desenvolvidos e consumidos e que aplicações possam ser portadas para diferentes Hosts permitindo inclusive porte para outros sistemas operacionais, como ambiente Unix (Linux/Mac) sem necessidade de recompilação.

A abstração criada é consistida em dois elementos chave da especificação:

Environment Dictionary - Refere-se a estrutura de dados responsável por armazenar as informações de requisição/resposta da aplicação.

IDictionary<string, object> env;

Application Delegate - A assinatura de um delegate que define uma interface entre os servidores e os componentes em uma aplicação compatível com o OWIN. Este delegate recebe um dicionário com todas informações de requisição/resposta e retorna objeto Task referente a execução assíncrona de seu componente.

using AppFunc = Func<

IDictionary<string, object>, // environment dictionary

Task>; // tarefa assíncrona

Não há nenhuma dependência de tipos externos alem da biblioteca padrão do Framework .NET criando uma dependência minima.

Projeto Katana

Dentro deste contexto, o projeto Katana é a contribuição da Microsoft a especificação OWIN. O projeto não traz um novo framework Microsoft para desenvolvimento web, mas sim um conjunto de ferramentas para construir e compor aplicações baseadas na especificação OWIN criando um ecossistema sustentável para o desenvolvimento web. Produtos como o ASP.NET Web.Api e ASP.NET SignalR já possuem suporte ao OWIN, assim como outros projetos open-source para .NET como FubuMVC, ServiceStack e NancyFx. O projeto Katana disponibiliza vários componentes, entre eles componentes que permitem realizar o host de aplicações web em processos customizados como um serviço do windows ou executáveis e componentes para realizar o host ou servir aplicações compatíveis com o OWIN entre outros componentes.

Este post introduziu de forma simples o conceito e motivos por trás do projeto Katana e o que vem a ser o OWIN, na segunda parte, abordaremos uma visão mais especifica aplicada a pratica. Para maiores detalhes do projeto Katana e OWIN os links de referências podem ser consultados. Até a próxima parte deste post e bons estudos!

Referências:

http://owin.org

http://katanaproject.codeplex.com

http://www.asp.net/aspnet/overview/owin-and-katana/an-overview-of-project-katana

http://msdn.microsoft.com/en-us/magazine/dn451439.aspx

Qualidade de software não importa, o que vale é entregar

2013-10-17T13:11:38.000Z

Durante anos acompanhando o mercado de software no Brasil venho me dedicando a conversar com os profissionais de tecnologia em todos os segmentos de empresas e o tema qualidade de software é sempre algo deixado em segundo plano na agenda dos gestores, sendo visto erroneamente como custo e mais trabalho para criar uma solução. Indo contra essa abordagem o Forrester fez um excelente estudo EM 2009 onde comprova que corrigir um bug em produção chega a custar 30 vezes mais, coisa que você já deve saber, porém poucos se dedicam a estudar mais a fundo a origem e como resolver.

Essa visão aplicada em fazer os projetos de qualquer jeito criando sistemas de produção “pseudo” produtivos tem prejudicado toda a indústria de software ao longo dos anos, contribuindo justamente para o contrário, resultando em software mal projetado, inseguro e nada produtivo, permeado por falhas frequentes e um retrabalho absurdo, consumindo os desenvolvedores, usuários e demais participantes do ciclo do projeto.

É comum receber o contato de clientes relatando que desenvolvedores querem testes, mas sempre chegam com aquele tom de deboche e uma dúvida no ar: “para quê?”, como uma grande interrogação na cabeça do gestor, uma vez que para ele está indo tudo bem, maravilhoso e que fazer software é assim mesmo, árduo, complexo, repetitivo, falho e, principalmente, essas dificuldades só existem devido à características do negócio dele e por isso eles sofrem e estão condenados a viver assim sempre planejando e vendendo sonhos que nunca são entregues conforme o previsto.

Eu imagino que você certamente se identificou com algo dito até este momento, afinal esses fatos refletem a mais pura essência de como se “conduz” e se pensa um projeto de software nas condições do vai fazendo e coloca em produção que eu assumo (“Go Horse”), pode confiar. Estamos no momento importante para você se permitir uma pausa (“Eu sei que você já escutou isso”) para refletir se esse processo de trabalho na raça, força bruta e retrabalho é realmente a única forma de se construir software e repensar onde foi parar toda a modernização tecnológica que foi criada nos últimos 15 anos e continua sendo ignorada.

Em todas as minhas pesquisas no mercado de software tenho percebido que ninguém se preocupa em contabilizar o prejuízo, retrabalho, insatisfação de todos que participam, inclusive você e os usuários do sistema, mas, principalmente, o custo para manter um software na UMB (Unidade multiplica bug, equivalente a UTI para seres humanos) durante toda a vida do mesmo, temendo qualquer mudança, atualização que se torna cada vez mais nociva a estabilização do projeto.

Se você tem um software hoje hospedado na UMB ((Unidade multiplica bug) sabe responder rapidamente o tamanho do backlog de mudanças que não consegue implementar por falta de tempo (“$”); sabe responder os seus sonhos não realizados que impedem de atender o cliente de forma mais moderna com um software simples e fácil de atualizar, pois está preso em um ciclo vicioso de manutenção recorrente que consome todo o seu tempo de repensar, inovar e progredir no produto.

Não existe produtividade ou evolução com segurança em software feito de qualquer jeito sem sustentação. É o mesmo que ter um edifício sem a devida fundação que sustente a carga de pessoas. Eu sei que as palavras carga e escalar são proibidas de falar em projetos de software, mas chega um momento que não aguentamos e temos que colocar o dedo na ferida e começar a dizer não. Quando eu digo não, é não mesmo. Chegou o momento de tomar uma atitude de mudança e parar de esperar resultados sem você fazer nada de diferente.

Para pensar em um ciclo moderno de software é importante entender e discutir os requisitos desde o início, tornando as pessoas parte do processo. É preciso pensar mais no problema a ser resolvido antes mesmo de iniciar a codificação. Com as tecnologias modernas é possível pensar e separar corretamente a inteligência da aplicação criando código simples e de fácil manutenção que quando integrado a testes unitários automatizados passam a compartilhar a qualidade para todos do projeto. Hoje podemos criar ciclos de qualidade indo desde funcionalidades até carga usando serviços de nuvem, o que aumenta a sua produtividade com a redução do retrabalho eliminando problemas recorrentes que nunca se resolvem numa abordagem tradicional.

Adotar práticas de qualidade é mais atitude do que qualquer outra ação e precisa estar na mente de todos que participam do ciclo de desenvolvimento de software. Você precisa conquistar o coração do seu cliente com um produto orientado aos seus desejos e que funcione corretamente. Qualquer pessoa que contribuir no projeto precisa ter em mente o quanto é importante aquela qualidade que ele está somando ao projeto.

Hoje não existe mais desculpa para viver no mundo de “Alice do software”, achando que jogar a sujeira debaixo do tapete e deixar o cliente pagar a conta da falta de qualidade é a solução. Um cliente insatisfeito custa muito caro para o negócio. Ele vai reclamar do produto e esse ciclo repetitivo de ir e voltar desestimula todo a equipe que perde a percepção de entrega do projeto. Por isso, hoje, pensar em qualidade é fundamental para ter produtividade e satisfação entre todos. Reduza os custos do seu projeto eliminando defeitos recorrentes e repetitivos ainda no início.

Para saber mais:
Aprofunde seus conhecimentos sobre este tema na comunidade ALM

NoSQL: uma nova necessidade !

2013-10-14T20:30:37.000Z

NoSQL: uma nova necessidade !

Desde 1987, quando a linguagem SQL virou um padrão ISO, os bancos de dados relacionais (definidos em 1970 por Edgar Codd) tornaram-se um padrão para o desenvolvimento de aplicações com bases de dados. SQL, relacional e RDBMS (Relational DataBase Management System) tornaram-se quase sinônimos e instalaram-se na mente de todos os desenvolvedores por décadas. Ninguém imaginava outra forma de trabalhar com grandes massas de dados.

Mas o cenário mudou ! O custo dos dispositivos de armazenamento de dados caiu vertiginosamente, o poder de processamento disparou, a Internet passou a exigir bancos de dados de tamanhos que antes não eram imaginados e os órgãos de segurança e controle passaram a vislumbrar a possibilidade de criar bases de dados gigantescas que pudessem satisfazer seu apetite de controlar os cidadãos.

Como resposta, várias organizações passaram a desenvolver e utilizar bancos de dados não relacionais, que suportassem suas demandas. As formas normais foram esquecidas e a regra passou a ser a velocidade de acesso e resposta às requisições. Não tenho notícia de quando as organizações governamentais iniciaram este movimento, mas 5 empresas privadas foram pioneiras: em 2004 a Amazon iniciou o desenvolvimento do banco de dados hoje comercializado como Dynamo DB e a Google iniciou o desenvolvimento do BigTable, lançado em 2006. Seguindo a inspiração da Amazon, a LinkedIn iniciou o projeto Voldemort criando uma base de dados não relacional e não SQL para gerenciar seus 135 milhões de membros. Yahoo criou o Sherpa em 2009. FaceBook baseou-se nas soluções da Amazon e da Google e desenvolveu a sua, que passou a ser distribuída como código aberto em 2008 com o nome de Apache Cassandra.

O que estes 5 bancos de dados tem em comum ? Deixaram de ser relacionais, abandonaram o padrão SQL e o conceito ACID (Atomicidade, Consistência, Isolamento e Durabilidade). As formas normais foram flexibilizadas e surgiram os termos N1NF (non first normal form) e MRNN (Modelo relacional Não Normalizado). As técnicas de modelagem mudaram e agora falamos em denormalização, agregação, junções laterais, redução dimensional, índices compostos e distribuição de chaves em vários servidores. A prioridade passou a ser alta performance e alta escalabilidade.

A performance alcançada nestes projetos foi surpreendente, superior a 10 vezes a conseguida com bancos relacionais, e em muitas arquiteturas a performance se mantém praticamente constante independente do tamanho da base de dados. A performance passou a ser previsível !

O sucesso desta abordagem levou a criação de vários novos bancos de dados não relacionais, muitos de código aberto, alguns suportando SQL, outros com ACID, cada um com suas características especiais. Muitos armazenam os dados em formato JSON. Todos passaram a ser classificados como NoSQL.

O termo NoSQL foi utilizado pela primeira vez em 1998 quando Carlos Strozzi criou um banco de dados relacional não SQL. Este termo voltou a ser utilizado em 2009 por Johan Oskarsson em um evento sobre banco de dados de código aberto. Na verdade seu significado era de ser não MySQL, não Sql Server, etc ... NoSQL passou a ser utilizado para designar todos os bancos de dados não relacionais (NoRDBMS), e entendido como Not Only SQL por alguns.

Quatro arquiteturas se destacaram e hoje podemos classificar os bancos de dados NoSQL em 5 tipos:

1. Key-Value Databases

É a arquitetura mais simples, utilizada pela primeira vez no Amazon Dynamo DB.

                cor : vermelho
                idade : 30
                nome : Ana

Vários pares chave/valor podem pertencer a um conjunto geralmente chamado de Bucket.

Exemplo de programação:

                Set(chave,valor)                 // cria um par chave-valor
                Get(chave) // lê o conteúdo da chave
                Delete(chave) // exclui a chave

Exemplos de bancos de dados key-value: SimpleDB, Voldemort, Tokyo Cabinet, Oracle NoSQL, MemcaheDB, Redis, Hbase, Riak, FatDB, Hibari, Aerospike, BangDB.

2. Tabular Databases (Column Family)

Acrescenta mais um grau de complexidade à arquitetura anterior, antes tínhamos bucket, key e value. Agora temos Column family, Key, Column name e value.

Key 4564564 ; nome : Ana ; idade : 30 ; cidade : São Paulo

Uma Column Family de assemelha a uma tabela de um banco de dados relacional, e geralmente precisa ter suas colunas predefinidas.

Exemplo de programação:

                Set pessoas[‘4564564’] [‘nome’]=’Ana’                         /
                Set pessoas[‘4564564’] [‘idade’]=30 / inclui uma coluna
                Set pessoas[‘4564564’] [‘cidade’]=’São Paulo’ /
                Get pessoas[‘4564564’] // lê uma coluna
                Drop column pessoas[‘4564564’] /// exclui uma coluna

Exemplos de bancos de dados tabulares: Cassandra, Hypertable, Apache Hbase, Apache Accumulo, BigTable, Mnesia, OpenLink Virtuoso, Clouddata, Cloudera, HPCC, Stratosphere.

3. Document Databases

Inspirados no banco de dados Lotus Notes, agora comercializado como Lotus Domino, basicamente permite o armazenamento de registros aleatórios, geralmente sem necessidade de pré-definição.

idpessoa : 4564564 ; nome : Ana ; idade : 30 ; cidade : São Paulo
idpessoa : 6865476 ; nome : Bia ; estado : PB ; sexo : F

Cada documento pode ter vários pares de valores e pertencer a uma coleção de documentos.

Exemplo de programação:

                dp.pessoa.insert( { idpessoa : 4564564,
                                                     nome: “Ana”
                                                     idade: 30
                                                     cidade: “São Paulo”      } ) // inclui um documento
                db.pessoas.find( {idpessoa : 4564564} )                        // lê um documento
                db.pessoas.remove( {idpessoa : 4564564} ) // exclui um documento

Exemplos de bancos de dados de documentos: MongoDB, Apache CouchDB, RavenDB, BaseX, eXist, Cloudant, Clusterpoint, Jackrabbit, IBM Lotus Domino, OrientDB, Sedna, TokuMX, ElasticSearch, RethinkDB, ThruDB, Terrastore, RaptorDB.

4. Graph Databases

São bancos de dados que utilizam estruturas gráficas compostas de nodos e barras. Tantos os nodos quanto as barras podem possuir propriedades que conforme o banco podem dispensar uma pré-definição.

“Ana”(idade:30) “reside em”(desde:1997) “Porto Alegre”(estado:RS)

Cada nodo possui seu endereço ID e o endereço das barras a ele ligadas, cada barra de ligação possui a direção, seu ID próprio e os IDs dos nodos interligados.

Para o caso acima, em um banco de dados relacional teríamos 3 tabelas:

     Pessoa        -1 x MUITOS->     Residência                -MUITOS x 1->   Cidade
IdPessoa – Nome       IdResidência - IdPessoa – Ano – IdCidade IdCidade – Nome
IdAna – Ana          Id1997   -   IdAna – 1997 – IdPoa IdPoa – Porto Alegre

Neste caso, sempre que fosse necessário acessar os dados da residência de Ana, precisaríamos utilizar uma pesquisa indexada na tabela “Residência” para encontrar “IdAna” e outra na tabela “Cidade” para encontrar “IdPoa”. Estas pesquisas por chave binária em uma base com bilhões de registros exigiriam centenas ou milhares de acessos e sua performance se degradaria ainda mais, cada vez que a base de dados aumentasse.

                Ana 1997                                     Porto Alegre
                * IdAna * Id1997 * IdPoa
                out: Id1997 in: IdAna in: Id1997
out: IdPoa

No banco de dados não relacional tipo Graph, serão necessários apenas um acesso à tabela “Residência” e outro à tabela “Cidade”, pois estando em “Ana” temos o endereço da barra de ligação “Residência” e nesta temos o endereço de “Porto Alegre”. E serão sempre dois acessos, independente do tamanho da base de dados ! Não existe uma modelagem de dados relacionando as tabelas, o relacionamento é feito caso a caso pelas barras de ligação.

Nestas bases de dados, as operações de leitura transversal são praticamente instantâneas, precisamos apenas de um nodo raiz onde iniciar nossas buscas. É claro que para chegar ao nodo raiz, teremos que nos utilizar de algoritmos semelhantes aos utilizados nas bases relacionais. Mas em uma transação on-line, o nodo raiz é definido no início da operação.

Exemplo de programação:

Create vertex Pessoa set nome = ’Ana’, idade = 30 // inclui o nodo Ana
Create vertex Cidade set nome = ’Porto Alegre’, estado = ‘RS’ // inclui o nodo Porto Alegre
Create edge Residencia
from (select from Pessoa where nome = ’Ana’)
to (select from Cidade where nome = ’Porto Alegre’) // inclui a ligação

Exemplos de bancos de dados tipo Graph: DEX, Neo4j, OrientDB, InfiniteGraph, AllegroGraph, FlockDB, Sones GraphDB, OWLIM, VelocityGraph, Trinity, Meronymy, Fallen 8.

5. Outros Bancos de Dados não relacionais

Na prática muitos bancos de dados não relacionais usam uma ou várias das 4 arquiteturas acima simultaneamente. É comum encontrar o mesmo banco de dados em várias classificações.

Bancos que adotam outras arquiteturas não relacionais:

Multimodel Databases: ArangoDB, Datomic.
Object Databases: Versant, JADE, db4o, Objectivity, Starcounter, Perst, HSS, ZODB, magma, NEO, Morantex, ODABA, EyeDB, FramerD.
Grid & Cloud Databases: GigaSpaces, GemFire, Infinispan, Queplix, Hazelcast.
XML Databases: EMC Document XDB, Qizx, Berkeley DB XML.
Multidimensional Databases: Globals, Cache, SciDB, MiniM DB, rasdaman.
Multivalue Databases: U2, OpenInsight, Reality, OpenQM, jBase.
Tuple Store Databases: Apache River, Tarantool.
Triple/Quad Store: Meronymy SPARQL, Apache JENA.

Bancos de Dados Híbridos

Novos bancos de dados estão chegando ao mercado, agora suportando arquiteturas híbridas com bases relacionais e não relacionais, dados estruturados e não estruturados. Acredito que este seja o futuro, várias arquiteturas na mesma base de dados, com integração através de uma nova linguagem SQL. Mas levará um tempo até a estabilização da arquitetura não relacional, para que se tenha uma integração eficiente entre elas.

Conclusão

Com certeza dispomos agora de um cardápio mais extenso na busca de soluções. Infelizmente, segundo pesquisa realizada pela Information Week, apenas 56% dos profissionais de TI já ouviram falar de NoSQL e apenas 1% consideram bancos de dados NoSQL como parte de sua direção estratégica. A lista de empresas que hoje utilizam bases NoSQL não pode ser desconsiderada, além das 5 pioneiras temos: Comcast, Netflix, Pitney Bowes, Disney, RSA, Symantec, HP, AT&T, Impetus, ebay, Ericsson, Adobe, Cisco, MTV, ...

É claro que os bancos de dados relacionais sempre terão o seu espaço, mas porque não utilizar várias arquiteturas e ter o melhor de cada mundo ?

Graph Databases são extremamente eficientes em sistemas de relacionamento (CRMs) e inteligência,
Document Databases se adéquam perfeitamente às necessidades de gestão de conteúdo,
Key Value Databases pela sua simplicidade tornam-se extremamente rápidos em bases de dados gigantescas,
Multidimensional Databases superam as expectativas em sistemas de BI (Business Intelligence) e OLAP (On-line Analytical Processing).

Precisamos repensar as técnicas de modelagem em nossos projetos, as formas normais serão boas em alguns casos. Agora existe uma etapa anterior de projeto onde com base na demanda e nos requisitos precisaremos decidir o tipo de modelagem, normalizada ou não, os bancos de dados que serão utilizados e as formas de integração entre eles.

Utilizando o Live SDK com Windows Phone

2013-10-14T11:18:12.000Z

Boa Tarde Pessoal,

O Live SDK permite que desenvolvedores possam utilizar informações da conta Windows Live dos usuários em suas aplicações, permite que seja obtido o Nome , e-mail, contatos, permite que trabalhe com arquivos do SkyDrive do usuário, e o melhor, tudo isso pode ser utilizado também no Windows Phone, para isso, basta baixar o SDK(que pode ser baixado aqui).

Para utilizar o Live SDK, são disponibilizadas uma série de escopos de permissões para definir oque sua aplicação pode fazer (e que pode ser encontrado na integra aqui), vou listar aqui, as que serão utilizadas em nosso exemplo, e oque cada um faz:

wl.basic = Acesso de leitura a informações básicas de perfil do usuário. Também permite acesso de leitura a uma lista de contatos do usuário.

wl.signin = Comportamento de logon único. Com o logon único, os usuários que já estão conectados no Live Connect também entram em seu site.

wl.skydrive_update = Acesso de leitura e gravação aos arquivos do usuário armazenados no SkyDrive.

wl.emails = Acesso de leitura a endereços de email pessoais, preferidos e comerciais do usuário.

Bom, o intuito deste artigo, é mostrar como é simples utilizar o Live SDK em nossas aplicações, e também subir arquivos no skydrive

Após baixar o Live SDK e instalar em sua maquina, é necessário incluir as referencias no Visual Studio conforme print abaixo:

Após incluir essas referencias, é necessário incluir os namespaces no CS:

using Microsoft.Live;

using Microsoft.Live.Controls;

após isso, vamos arrastar para nossa tela, o componente "SignInButton", que pode se encontra em sua ToolBox.

Caso o "SignInButton" não esteja disponivel em sua ToolBox, basta inclui-lo clicando com o botão direito do Mouse, selecionar "Choose Itens", e selecionar a opção "SignInButton"

Após isso, basta arrastar o botão para a tela.

No código do botão criado, é necessário adicionar as seguintes propriedades:

ClientId = Id da sua aplicação criada no dev.live.com

Scopes = os scopos informados no inicio do Post

No Code Behind, adicionei os seguintes códigos para acesso em toda a tela:

LiveConnectClient liveClient;

LiveConnectSession session;

No evento do SignInButton, adicionei o seguinte seguimento de código que é responsavel por realizar o login na Live.

private void signInButton1_SessionChanged(object sender, LiveConnectSessionChangedEventArgs e)

{

if (e.Status == LiveConnectSessionStatus.Connected)

{

liveClient = new LiveConnectClient(e.Session);

session = e.Session;

liveClient.GetCompleted += new EventHandler<LiveOperationCompletedEventArgs>(OnGetCompleted);

liveClient.GetAsync("me", null);

}

else

{

MessageBox.Show("Erro ao Realizar Login");

liveClient = null;

}

void OnGetCompleted(object sender, LiveOperationCompletedEventArgs e)

{

if (e.Error == null)

{

if (e.Result.ContainsKey("name"))

{

Dictionary<string, object> dicionarioEmails = (Dictionary<string, object>)e.Result["emails"];

txtEmail.Text = dicionarioEmails["account"].ToString();

txtNome.Text = e.Result["name"].ToString();

}

else

{

MessageBox.Show(e.Error.ToString());

}

ao Clicar no SignInButton, ele executará estes métodos, e abrirá uma janela do browser para que você possa realizar o login no windows live, e logo em seguida uma tela de autorização das permissões solicitadas pela aplicação

Tendo realizado isso, estaremos conectados a nossa conta do Windows Live.

Agora, vamos criar um pequeno arquivo texto e adiciona-lo ao skydrive.

para fazer isso, vamos criar um evento no Code Behind que irá converter o conteudo do TextBox existente na tela para um MemoryStream e vamos em seguida adiciona-lo a nosso diretorio raiz do SkyDrive.

o seguimento de código deve ficar semelhante a isso:

private void button1_Click(object sender, RoutedEventArgs e)

{

if (session != null)

{

string nomeArquivo = "ExemploSkydrive.txt";

byte[] arrayBytes = Encoding.UTF8.GetBytes(this.textBox1.Text);

MemoryStream stream = new MemoryStream(arrayBytes);

LiveConnectClient cliente = new LiveConnectClient(session);

cliente.UploadCompleted += new EventHandler<LiveOperationCompletedEventArgs>(cliente_UploadCompleted);

cliente.UploadAsync("me/skydrive", nomeArquivo, stream, OverwriteOption.Overwrite);

}

else

{

MessageBox.Show("É necessário estar conectado ao Skydrive");

}

void cliente_UploadCompleted(object sender, LiveOperationCompletedEventArgs e)

{

if (e.Result["id"] != null)

{

MessageBox.Show(string.Format("Arquivo {0} salvo com sucesso!", e.Result["name"].ToString()));

}

else

{

MessageBox.Show("Erro ao Salvar Arquivo no Skydrive");

}

O código que se encontra no evento do Botão, é oque realizará o "salvamento" do arquivo no Skydrive, e o evento cliente_UploadCompleted é oque verificará o retorno da execução, por exemplo se o arquivo foi ou não criado.

Bom pessoal, como vocês podem ver, utilizar o Live SDK para salvar arquivos no SkyDrive é uma tarefa bem simples e muito útil que pode facilitar e muito a vida tanto do desenvolvedor quanto do usuário, e tornará sua aplicação mais rica e útil , oque pode chamar a atenção dos usuários.

Segue abaixo aplicação de exemplo para download:

SkydriveAccess.rar (380,12 kb)

Participe do Grupo Windows Phone no DevBrasil

Task's Windows Phone

2013-10-08T17:00:00.000Z

Neste artigo, vou escrever sobre as Task's para enviar e-mail's, salvar contatos, enviar SMS, Tirar Fotos, e também utilizar o Search do Windows Phone.

Bem, vamos começar.

Para começar, é necessário que você referencie em seu projeto o seguinte Namespace:

using Microsoft.Phone.Tasks;

Não sei se é do conhecimento de todos, que quando a Microsoft desenvolveu o Windows Phone, ela colocou algumas restrições quanto a execução de algumas tarefas sem o consentimento do usuário, como por exemplo efetuar chamadas, enviar e-mail's, enviar SMS, salvar um contato na agenda.

Todas estas coisas, quando vamos fazer em nosso app, dependemos da autorização do usuário, e para realizar tais tarefas, utilizamos as Tasks do Windows Phone

Vamos ver alguns deles neste artigo.

O primeiro que irei abordar é o "EmailComposeTask", que faz parte do Namespace "Microsoft.Phone.Tasks", e é utilizada para compor e-mail's. Com o "EmailComposeTask", você pode montar um e-mail e o usuário escolherá por qual conta ele irá enviar o e-mail, se vai alterar o assunto, o conteúdo do e-mail, ou até mesmo o destinatário. Ou seja, você pode induzir o usuário a lhe enviar um e-mail, mais não quer dizer que necessariamente ele vai lhe enviar este e-mail, ou se o e-mail vai com o conteúdo que você definiu.

A baixo segue uma instancia do "EmailComposeTask":

EmailComposeTask email = new EmailComposeTask();

//a propriedade "To" define o destinatario do e-mail

email.To = "julio.arruda@outlook.com";

//A propriedade "Bcc" define a quem o e-mail será enviado como cópia oculta

email.Bcc = "julio.arruda@outlook.com";

//A propriedade "Cc" define a quem o e-mail será enviado com cópia

email.Cc = "julio.arruda@outlook.com";

//A propriedade "Subject" define o Assunto do e-mail

email.Subject = "Sample SendMail";

//A propriedade "Body" define o corpo do e-mail

email.Body = "E-mail de exemplo";

//O Evento "Show" abre o aplicativo de e-mail para enviar

email.Show();

O Próximo item da lista é a criação de um contato na agenda, e da mesma maneira que enviar um e-mail, é necessária a confirmação do usuário, onde também o usuário pode alterar qualquer uma das informações cadastradas, complementar ou até mesmo não salvar nenhuma delas.

O processo é todo muito simples, utilizamos o "SaveContactTask" para instanciar um novo contato, e seguimos os parâmetros abaixo:

SaveContactTask contact = new SaveContactTask();

//A Propriedade "FirstName" define o primeiro nome

contact.FirstName = "Julio";

//A propriedade "LastName" define o Ultimo nome

contact.LastName = "Arruda";

//A propriedade "JobTitle" define a profissão

contact.JobTitle = "Programador .NET";

//A propriedade "PersonalEmail" define o e-mail pessoal

contact.PersonalEmail = "julio.arruda@outlook.com";

//A propriedade "MobilePhone" define o numero de celular

contact.MobilePhone = "9999999999";

//pO evento "Show" exibe a tela para salvar o contato

contact.Show();

Neste código, abordei apenas algumas das propriedades de um contato, existem mais vários campos a serem preenchidos que devem ser analizados quando a sua necessidade

Segue um print de uma tela para salvar o contato do exemplo.

O próximo item, é como escrever um SMS para ser enviado pelo usuário, mais lembrando que assim como os anteriores, o SMS não é enviado automaticamente, é necessária uma interação com o usuário, onde o mesmo pode alterar tudo, ou até mesmo não enviar.

Faremos uso do: "SmsComposeTask" para instanciar uma nova SMS, e seguir os parâmetros conforme exemplo abaixo:

SmsComposeTask sms = new SmsComposeTask();

//A propriedade "Body" define o conteudo do SMS

sms.Body = "Teste de Envio de SMS ";

//A propriedade "To" define para quem será enviado o SMS

sms.To = "9999999999";

//O método "Show" exibe a tela de envio do SMS

sms.Show();

Segue um print do SMS do exemplo:

O próximo item que irei abordar é como realizar uma ligação, assim como os demais, é uma ação que depende do usuário para ser executada, nós enviamos uma solicitação para realizar a chamada, mas cabe ao usuário aceitar ou não.

Para isso, utilizamos o "PhoneCallTask" para instanciar uma nova ligação, e preenchemos as propriedades como abaixo:

PhoneCallTask call = new PhoneCallTask();

//A pripriedade "DisplayName" define o nome que será exibido no display enquanto a ligação estiver sendo realizada

call.DisplayName = "Julio Arruda";

//A propriedade "PhoneNumber" define o numero a que defe ser realizada a ligação

call.PhoneNumber = "88051287";

//O evento "Show" pergunta ao usuário se ele quer ou não realizar a ligação

call.Show();

Segue print's da ligação

Outra propriedade que temos de interessante, é a utilização da câmera do windows phone, para isso faremos o uso de: "CameraCaptureTask", e devemos realizar o procedimento de acordo com o exemplo abaixo:

private void button4_Click(object sender, RoutedEventArgs e)

{

//Instancia do CameraCaptureTask

CameraCaptureTask cameraCaptureTask = new CameraCaptureTask();

//Definição do Evento quando a foto for tirada

cameraCaptureTask.Completed += new EventHandler<PhotoResult>(cameraCaptureTask_Completed);

//Chama a Câmera

cameraCaptureTask.Show();

}

//Evento que é executado quando a foto é tidada

void cameraCaptureTask_Completed(object sender, PhotoResult e)

{

//Valido se a foto foi tirada

if (e.TaskResult == TaskResult.OK)

{

//caso tenha sido tirada exibo um messagebox com o nome da foto

MessageBox.Show(e.OriginalFileName);

}

Segue um print com a mensagem do caminho da foto:

Outra coisa interessante de utilizar é o Search, onde podemos realizar buscas no aparelho e na internet de acordo com o parâmetro informado.

Para isso utilizamos o: "SearchTask", com os parametros informados abaixo:

SearchTask search = new SearchTask();

//A propriedade "SearchQuery" define o parametro que deve ser buscado

search.SearchQuery = "Julio Arruda";

//O evento "Show" exibe a tela ddo Search

search.Show();

Seguem prints do search

Bom pessoal, é simples mais de momento é isso.

Espero que tenha ajudado.

Abaixo estou postando o aplicativo de exemplo.

Sample1.rar (68,55 kb)

Deixando o seu Java Script em um modelo arquitetural

2013-09-08T18:33:31.000Z

Alguns meses atrás eu estava participando de um grande projeto para o Submarino porém nesse projeto nós estávamos enfrentando um grave problema, nós não estávamos conseguindo ter 100 % de controle dos nossos Java Script.

Por causa dessa falta de controle nós estávamos enfrentando inúmeros bugs e a cada vez que precisávamos adicionar uma nova funcionalidade ou até mesmo dar uma manutenção em uma tela era sempre uma tarefa muito árdua.

Depois de algumas horas cheguei a seguinte arquitetura, segue abaixo o modelo arquitetural.

Conhecendo as camadas da arquitetura:

Service: Camada responsável por consumir e expor algumas funcionalidade que pode ser reutilizada por outras funcionalidade no sistema.

Model: Camada responsável por prover métodos e informações necessárias para a nossa View e comunicar-se com nossa aplicação server-side.

View: Camada responsável por prover métodos e funcionalidades para iterações com o usuário.

Implementando o modelo arquitetural:

Vamos imaginar por um momento que temos um sistema e precisamos realizar um cadastro de participante.

“O código completo do projeto pode ser consultado no final do artigo.”

Dentro do arquivo Participante.js localizado na pasta Scripts temos a seguinte implementação.

var ParticipanteService = {
    validacaoEmail: function (email) {
        return email.length > 3;
    }
};
var ParticipanteModel = function () {
 
    var self = this;
    self.url = "/Participante/InserirParticipante";
    self.Participante = {
        nome: '',
        sobreNome: '',
        email: '',
        senha: ''
    };
 
    self.inserirParticipante = function (done) {
        $.ajax({
            url: self.url,
            type: 'POST',
            data: self.Participante,
            success: function (retorno) {
                return done(retorno);
            }
        });
    };
 
};
var ParticipanteView = function () {
    var self = this;
    self.model = new ParticipanteModel();
    self.salvar = function () {
        self.model.Participante = $("form").serialize();
        self.model.inserirParticipante(function (retorno) {
            alert(retorno);
        });
    };
    self.render = function () {
        $("#btnGravar").click(function () {
            var isEmail = ParticipanteService.validacaoEmail($("#email").val());
            if (isEmail)
                self.salvar();
            else
                alert("O e-mail não é valido!");
 
        });
    }();
}();

Conclusão: Podemos observar que com essa arquitetura proposta conseguimos separar as responsabilidades e cada camada e especialista em uma determinada tarefa, uma simples brecha no nosso código pode ser o início do fracasso do nosso projeto.

Links Uteis:

Código fonte do projeto: https://github.com/julianosaless/ModeloArquiteturalJS

Guia de referência: http://knockoutjs.com/, http://backbonejs.org/ ,http://devbrasil.net/group/jquery,

http://devbrasil.net/group/aspnet

Método Virtual C#

2013-09-07T22:56:42.000Z

Olá tudo bem, vamos a definição da Microsoft sobre Métodos Virtuais

“A virtual function is a member function that you expect to be redefined in derived classes. When you refer to a derived class object using a pointer or a reference to the base class, you can call a virtual function for that object and execute the derived class’s version of the function.”

Para melhorar o nosso entendimento vamos conferir o diagrama de class abaixo.

Segue um exemplo básico mostrando o poder do polimorfismo.

public class Pessoa
    {
        public virtual string Nome()
        {
            return "Nome Padrao";
        }
    }
 
    public class Ricardo : Pessoa
    {
        public override string Nome()
        {
            return "Ricardo";
        }
 
    }
 
    public class Paulo : Pessoa
    {
        public override string Nome()
        {
            return "Paulo";
        }
    }

Agora vamos aos testes

[TestClass]
public class TestMetodoVirtual
{
 
    [TestMethod]
    public void deve_retornar_nome_ricardo()
    {
        Pessoa pessoa = new Ricardo();
        Assert.AreEqual("Ricardo", pessoa.Nome());
    }
 
    [TestMethod]
    public void deve_retornar_nome_paulo()
    {
        Pessoa pessoa = new Paulo();
        Assert.AreEqual("Paulo", pessoa.Nome());
    }
}

Conclusão:

Apesar desse exemplo bem simples existe vários Framework que utilizam essa estrategia, uma dica legal e utilizar e conhecer o Hook Method , até aproxima pessoal.

Class abstratas x Interface

2013-08-08T14:00:00.000Z

Tanto as classes abstratas e quanto as interfaces podem definir métodos abstratos que precisam ser implementados pelas class que estende ou implementa, porém somente as classes abstratas podem possuir métodos concretos.

Apesar dessa diferença vamos notar que teremos a repostas mais conceitual do que relacionada com questões referente a linguagem.

Quando a abstração e um comportamento então creio que a melhor solução e utilizar uma interface, quando a abstração e mais conceitual, algo que precisa ser especializado e refinado creio que a melhor solução e construir uma class abstrata.

Por um momento vamos imaginar que precisamos criar uma árvore.

Vamos as características de uma árvore, toda árvore possui algumas características listada abaixo.

Arvore:

Folha.
Galho.
Tronco.
Fruto.

Note que a característica fruto está em vermelho como não é novidade tem árvore que são frutíferas e arvores que não são.

Então podemos dizer que todas as árvores em um determinado ponto tem uma característica comum, porém existe características incomuns quando falamos de outros pontos, como no exemplo o fruto seria uma característica incomum.

Nesse exemplo poderíamos utilizar uma class abstrata, abaixo irei colocar alguns exemplos dessa implementação.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

public abstract class Arvore

{

       public void Folha()

       {

           throw new NotImplementedException();

       }

       public void Galho()

       {

           throw new NotImplementedException();

       }

       public void Tronco()

       {

           throw new NotImplementedException();

       }

       public abstract string Fruto();

}

1

2

3

4

5

6

7

public class Abacateiro : Arvore

{

        public override string Fruto()

        {

            return "Abacate";

        }

}

1

2

3

4

5

6

7

public class Goiabeira : Arvore

{

       public override string Fruto()

       {

           return "Goiaba";

       }

}

Testando nossa implementação:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

[TestClass]

public class TesteArvoreAbstract

{

    [TestMethod]

    public void deve_retornar_o_fruto_goiaba()

    {

        Arvore arvore = new Goiabeira();

        Assert.AreEqual("Goiaba", arvore.Fruto());

    }

    [TestMethod]

    public void deve_retornar_o_fruto_abacate()

    {

        Arvore arvore = new Abacateiro();

        Assert.AreEqual("Abacate", arvore.Fruto());

    }

}

Outra maneira interessante seria:

1

2

3

4

5

6

public interface IArvore

{

ICaracteristicasComuns CaracteristicasComuns {get; }

CaracteristicasIncomuns CaracteristicasIncomuns { get; }

}

1

2

3

4

5

6

7

8

public interface ICaracteristicasComuns

{

    void Folha();

    void Galho();

    void Tronco();

}

1

2

3

4

public abstract class CaracteristicasIncomuns

{

public abstract string Fruto();

}

1

2

3

4

5

6

7

8

9

10

11

12

13

public class Goiabeira : IArvore

{

    public ICaracteristicasComuns CaracteristicasComuns

    {

           get { return new GoiabeiraPadrao(); }

    }

    public CaracteristicasIncomuns CaracteristicasIncomuns

    {

           get { return new GoiabeiraPersonalizada(); }

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

public class GoiabeiraPadrao : ICaracteristicasComuns

{

    public void Folha()

    {

        throw new NotImplementedException();

    }

    public void Galho()

    {

        throw new NotImplementedException();

    }

    public void Tronco()

    {

        throw new NotImplementedException();

    }

}

1

2

3

4

5

6

7

public class GoiabeiraPersonalizada : CaracteristicasIncomuns

{

    public override string Fruto()

    {

           throw new NotImplementedException();

    }

}

Conclusão:

A melhor maneira de entendermos um conceito e praticar e praticar, espero que todos tenham conseguido entender as diferenças entre class abstrata e interface, mais uma vez obrigado a todos.

Conhecendo o Glimpse - Plataforma de diagnostico extensível para sua aplicação ASP.NET

2013-07-18T20:35:49.000Z

Se você esta precisando de uma ferramenta de diagnostico para sua aplicação ASP.NET que seja extensível, com vários recursos, e ainda não ouviu falar ou testou o Glimpse, esta na hora de avaliar esta ferramenta e suas possibilidades.

Como funciona e como ele pode me ajudar?

O Glimpse quando instalado em sua aplicação, ativa uma toolbar no rodapé das páginas similar a ferramenta para desenvolvedores do Chrome ou o Firebug. O Glimpse pode lhe ajudar de diversas maneiras, oferecendo visualização de dados de requisições, respostas, dados servidor e informações como o tempo do processamento, entre outras que podem ser obtidas através de extensões adicionado ao próprio Glimpse. Ele possui extensões de suporte para aplicações ASP.NET WebForms e MVC entre outros. Confira no próprio site a documentação e extensões disponíveis, http://getglimpse.com.

Demonstração - diagnóstico para a execução da aplicação e consultas ao banco de dados.

Vejamos em alguns passos como configurar o Glimpse em uma aplicação exemplo feita com ASP.NET MVC 4 e o Entity Framework 5. A aplicação pode ser obtida aqui.

Obs: Solution criado com o Visual Studio 2012 e o Sql Server 2012 Express LocalDB.

A aplicação prove uma simples página de registros de visitantes (guestbook), o suficiente para demonstrar um pouco do que o Glimpse tem a oferecer. Execute a aplicação e verá que o Glimpse ainda não esta instalado. Pare a execução da aplicação e abra o console do nuget em seu Visual Studio. Execute os comandos a seguir:

Install-Package Glimpse.Mvc4

Install-Package Glimpse.EF5

Rode novamente sua aplicação, e através da url base, adicione glimpse.axd, ex: http://localhost:[porta]/glimpse.axd, ao acessar verá que existe uma opção para habilitar o Glimpse, "Turn Glimpse On" (obs: estas opções podem ter seus nomes alterados em releases futuras).

Habilite e volte a url raiz da aplicação. Veja no rodapé as informações não somente do servidor e requisições/resposta como também das consultas SQL realizadas pelo Entity Framework.

Clique no logo do Glimpse, e será aberta uma toolbar com várias tabs especificas.

Tab referente a execução do controller/action

Tab referente a execução de SQL

Para desabilitar o Glimpse volte a pagina glimpse.axd e clique "Turn Glimpse Off". É importante ressaltar que foram instaladas duas extensões do Glimpse, 'Mvc4' especifica para realizar o diagnóstico da aplicação MVC e o 'EF5' específico para diagnósticos na execução do Entity Framework 5, o Core do Glimpse foi automaticamente incluído quando executou-se os comandos do nuget por ser uma dependência.

Grandes poderes, grandes responsabilidades.

A configuração praticamente automática, pode parecer mágica aos olhos, porém deve se tomar cuidado e analisar as mudanças realizadas no web.config da aplicação, veremos que o próprio Glimpse realiza algumas configurações e cria uma seção especifica para ele onde defini-se se o Glimpse estará disponível ou não pelo atributo defaultRuntimePolicy e a url de acesso em endpointBaseUri. Há também a opção de habilitar o acesso remoto, ou seja fora de localhost, por padrão somente aceita requisições locais. Deste modo é certo que seja desabilitado este recurso em produção, e habilitar somente por demanda, se necessário realizar a consulta aos diagnósticos de possíveis problemas na aplicação.

Finalizando

Fica a dica de uma excelente ferramenta de auxilio a nós desenvolvedores, espero que se alguém se interessar este seja o passo inicial para o estudo aprofundado da ferramenta.

Abraços, sucesso a todos!

Escrever um Arquivos de Texto em C# utilizando o StreamWriter

2013-07-04T18:28:54.000Z

Boa Tarde Pessoal,

Estou mais uma vez aqui, escrevendo este artigo para vocês, pois por diversas vezes, temos a necessidade de criar arquivos de texto, que podem ser utilizados para criar log's, criar uma integração com outro sistema, enfim, precisamos criar arquivos de texto, mas como fazer isso com o C#.
Neste artigo, irei demonstrar como fazer isso com o C# utilizando o StreamWriter.

Para começar, você deve incluir em seu projeto a referencia:

using System.IO;

Para realizar a escrita de um arquivo, você deve utilizar um método semelhante a esse:

private void EscreveArquivo()
{

//Declaração do método StreamWriter passando o caminho e nome do arquivo que deve ser salvo
StreamWriter writer = new StreamWriter(@"c:\ArquivoPronto.txt");

//Escrevendo o Arquivo e pulando uma linha
writer.WriteLine("Hello World");
//Escrevendo o Arquivo sem pular linha

writer.Write("Exemplo de arquivo escrito com o StreamWriter");

writer.WriteLine();
writer.WriteLine("www.devbrasil.net");

//Fechando o arquivo
writer.Close();

//Limpando a referencia dele da memória
writer.Dispose();
}

Em resumo, basta instanciar a Classe StreamWriter e passar o arquivo que ele deve criar, passar os dados para escrever o arquivo.

Bom pessoal, espero que tenha ajudado.

Qualquer duvida, comente.

Veja mais sobre StreamWriter em:

StreamWriter

Leitura de Arquivo CSV em C#

2013-07-03T16:59:03.000Z

Boa Tarde Pessoal,

Estou aqui mais uma vez, postando um conteúdo simples, mais que muitas vezes, acaba sendo complexo por acabar caindo no esquecimento, pois nem sempre realizamos tal tarefa.

Vou explicar, como realizar a leitura de um arquivo .csv, mais esse mesmo método funciona para qualquer outra estrutura que possua algum tipo de separador como virgula, etc.

Para realizar a leitura de um arquivo texto, necessitamos incluir a referência:

using System.IO;

static void LerCSV()
{

//Declaro o StreamReader para o caminho onde se encontra o arquivo
StreamReader rd = new StreamReader(@"c:\txt\produtos.csv");

//Declaro uma string que será utilizada para receber a linha completa do arquivo
string linha = null;

//Declaro um array do tipo string que será utilizado para adicionar o conteudo da linha separado
string[] linhaseparada = null;

//realizo o while para ler o conteudo da linha

while ((linha = rd.ReadLine()) != null)
{

//com o split adiciono a string 'quebrada' dentro do array
linhaseparada = linha.Split(';');
//aqui incluo o método necessário para continuar o trabalho

}
rd.Close();

}

Em resumo, basta utilizar o StreamReader para ler o arquivo, declaro as variaveis necessárias, e com o auxilio do while realizo as leituras.

Bom pessoal, espero ter ajudado vocês.

Você pode obter mais informações sobre o StreamReader em:

StreamReader MSDN

Como organizar seus Casos de Teste na MTM?

2013-07-03T14:34:20.000Z

Um plano de teste desorganizado pode ser prejudicial no desempenho do Tester durante a execução. É papel do Arquiteto de Testes garantir que os Planos de Testes estejam devidamente organizados e garantam cobertura dos cenários necessários para a release.

Para organizar os casos de teste na MTM, basta criar uma nova Suíte de Testes e vincular os casos de teste a mesma.

Existem 3 tipos de suites:

Suite (simples)

Ao criar uma suite de testes, você pode adicionar a ela novos casos de testes e criar novos casos de testes vinculados a mesma.

Query-based Suite

A querry-based suite, como o próprio nome já diz, é uma suite de testes baseada em uma pesquisa. Ela é preenchida como os casos de testes resultantes da pesquisa na qual a mesma é baseada. Uma vez que forem adicionados novos casos de testes que se aplicarem a resultado da pesquisa, eles serão automaticamente vinculados a suite em questão.

Requirements

É possível também, adicionar uma suite baseada em um requisito do sistema. Esta suite será preenchida com os casos de teste que estiverem vinculados ao requisito em questão. Todos os novos casos de testes criados a partir desta suite serão vinculados automaticamente ao requisito e todos os novos casos de teste vinculados ao requisito estarão disponíveis na suite.

Bom trabalho e até o próximo post.

O artigo original pode ser visualizado em: http://mundodeti.blogspot.com.br/2013/07/como-organizar-seus-casos-de-teste-na.html

Enviar E-mail com C#

2013-07-02T12:30:00.000Z

Bom dia Pessoal,

Venho percebendo que apesar de ser uma coisa simples, ainda existem duvidas sobre como enviar e-mails através do C#, tendo isto em mente, vou postar uma maneira simples de enviar e-mails utilizando o C#.

Para utilizar as classes de e-mail, são necessárias as seguintes referencias:

using System.Net.Mail;
using System.Net;

Para enviar os e-mails basta criar um método de acordo com o seguinte exemplo:

public bool EnviarEmail(string assunto,string destinatario,string file)
{
try
{

string CorpoEmail = file;
MailMessage mailMessage = new MailMessage();

//Endereço que irá aparecer no e-mail do usuário

mailMessage.From = new MailAddress("email@seudominio.com", "Fale Conosco");

//destinatarios do e-mail, para incluir mais de um basta separar por ponto e virgula
mailMessage.To.Add(destinatario);
mailMessage.Subject = assunto ;
mailMessage.IsBodyHtml = true;

//conteudo do corpo do e-mail
mailMessage.Body = CorpoEmail.ToString();
mailMessage.Priority = MailPriority.High;

//smtp do e-mail que irá enviar
SmtpClient smtpClient = new SmtpClient("smtp.seudominio.com");

smtpClient.EnableSsl = false;

//credenciais da conta que utilizará para enviar o e-mail
smtpClient.Credentials = new NetworkCredential("email@seudominio.com", "senhadoemail");

smtpClient.Send(mailMessage);
return true;

}
catch
{
return false;
}
}

Bom pessoal, é isso, espero que tenha ajudado.