C# – Use Tuples com bom senso

Aplicar o uso da classe Tuple requer bom senso por parte do desenvolvedor, contudo, antes de entrarmos com detalhes sobre isso, vamos antes alinhar o entendimento do que seja e para quais fins utilizamos a classe Tuple.

Se você ainda não está familiarizado com a classe Tuple (System.Tuple) disponível no .Net 4 ou superior , segue segundo a documentação no site da Microsoft seu conceito e de como pode ser utilizada:

Uma tupla é uma estrutura de dados que tem um número específico e a sequência de elementos.

As tuplas são comumente usadas de quatro maneiras:

  1. Para representar um único conjunto de dados. Por exemplo, uma tupla pode representar um registro de banco de dados.
  2. Para fornecer acesso fácil a, e a manipulação de um conjunto de dados.
  3. Para retornar vários valores de um método sem usar out os parâmetros (c#) ou ByRef parâmetros (Visual Basic).
  4. Para passar vários valores para um método por meio de um parâmetro único. Por exemplo, o Thread.Start(Object) método tem um único parâmetro que permite que você forneça um valor para o método que o thread é executado no momento da inicialização. Se você fornecer um Tuple do objeto como o argumento de método, você pode fornecer uma rotina de inicialização do thread com três itens de dados.

Abaixo segue um exemplo de uso da classe Tuple em C#:

Exemplo de uso do Tuple

Apesar do conceito NÃO ser novo na área da desenvolvimento de softwares, é show do bola não acha?

Depois da coisa boa , vem as considerações que me fizeram escrever este post.

Use Tuple para substituir uma matriz de objeto.

Quando você declara um objeto tipo Tuple (ver imagem acima), você precisa certificar que o código esteja preparado para usar corretamente a sequencia que estará disponível no objeto tipo Tuple, note que um objeto tipo Tuple irá expor somente as propriedades com o nome Item1, Item2, Item3, Item4 … Entendeu?

Usar um objeto tipo Tuple em um contexto onde necessita comparar dois ou mais objetos é dar um tiro no pé, neste cenário, o ideial é que crie as suas classes customizadas, Exemplo Carro (Marca , Modelo..), Pessoa (Nome, Idade…)…

A classe System.Tuple não implementa uma classe IEnumarable, neste caso, você não poderá utilizar um foreach.

Programar é bom demais mais não esqueça de ganhar dinheiro.

Ivaldo de Oliveira Batista Júnior

A minha experiência com C# yield

Este artigo foi criado com base na documentação oficial da linguagem C#.

Você pode até considerar o assunto passado, porém , eu utilizo muito a palavra reservada yield do C#.

Quando o foco é produtividade, não tem como não amar o yield. =)

Com base na documentação oficial da linguagem C# , o yield trata-se de uma palavra-chave contextual que quando usada em uma instrução você consegue criar um objeto tipo IEnumerable de forma muito mais simples e dinâmica.

Sendo mais prático, imagine que você possua um método que necessite retornar um objeto tipo lista (IEnumerable ), veja como ficou super simples no exemplo abaixo o método GerarNomes().

Show de bola demais não acha? Note que se eu não utiliza-se o yield eu deveria no mínimo criar mais um objeto, e em seguida, usaria o mesmo para fazer a concatenação na mão … Veja abaixo como ficaria sem o yield:

São muitas as aplicações no dia a dia, sempre que desejar criar uma coleção dinamicamente tipo IEnumerable ou IEnumerable<T> lembre-se do yield. =)

Fica a dica de um recurso massa demais.

Ivaldo de Oliveira Batista Júnior

.NET – Saiba como gerar um boleto bancário com apenas duas linhas de código

Vamos criar um boleto bancário com duas linhas de código? Não acredita? Então olhe o exemplo abaixo:

Cobranca c = new Cobranca("token_conta", "cedente_token");
var boleto = c.Gerar("Joaquim Lima", "445454555", "email@email", 3m);

A tarefa de criar um software para emitir boleto bancário, e em seguida , integrar a carteira de cobrança com o banco pode exigir um tempo muito considerável de trabalho de desenvolvimento, pensando nisso, procurei na internet um serviço que possibilitasse a criação de boleto bancário via internet (para qualquer banco) , e que me desse a possibilidade de integrar de forma fácil com o meu aplicativo… Achei vários… Mas optei pela plataforma Pagamento Ágil (www.pagamentoagil.com.br)

Após uma lida na documentação do site de cobrança, iniciei um projeto open source de classe no GitHub para ser utilizado em aplicativos .NET , basicamente você deverá fazer o download do componente PagamentoAgil.Net.dll , em seguida, adicioná-lo como referência em seu projeto, e repetir o código acima.

O Download desta biblioteca pode ser realizado através do site: https://github.com/ivaldojunior/PagamentoAgil.Net

Se eu puder ajudar em algo…

Obrigado pela leitura 😉

C# WebClient – Parte I Como fazer um post para uma página web

C# WebClient – Parte I Como fazer um post para uma página web I

O código abaixo faz um post dos dados para uma página web, ao contrário da classe HttpWebRequest, a classe WebClient é mais simples de usar, a mesma poderá ser encontrada no namespace System.Net .

Este código resolveu um problema onde eu tinha que enviar uns dados via HTTP POST a partir de uma aplicação Windows.

No exemplo abaixo, eu invoco o método UploadString, passando duas strings, note que este método está sobrecarregado conforme documentação em: https://msdn.microsoft.com/en-us/library/System.Net.WebClient.UploadValues%28v=vs.110%29.aspx

Através da classe WebClient é possível  por exemplo, baixar a página web no formato string ou array de bytes.

    
string URI = "http://localhost:10108";
string Param = "param1=value1&param2=value2&param3=value3";
using (WebClient wc = new WebClient())
{
    wc.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
    var r = wc.UploadString(URI, Param);
}

Aproveitando o assunto, tem um projeto meu em andamento onde crio uma classe para enviar objetos de forma genérica, o mesmo, poderá ser baixado livremente através do link abaixo.

Download do código: https://github.com/ivaldojunior/PostGenericData.Net

Reflexão em C# (Reflection)

Reflexão em C# (Reflection)

Em ciência da computação, “a reflexão é o processo pelo qual um programa de computador pode observar e modificar sua própria estrutura e comportamento”. Isto é exatamente como a técnica de reflexão (reflection) funciona na linguagem C#. Ser capaz de examinar e alterar informações sobre a sua aplicação durante a sua execução, agregando um enorme potencial.

Um problema comum que enfrento, é a necessidade de comparar atributos e propriedades de objetos em tempo de execução da aplicação.

Reflexão em C#, trabalha muito, muito bem, e ele realmente não é tão difícil de usar.

Logo abaixo, fiz um projeto exemplo cujo o objetivo é comparar dois objetos em tempo de execução.

Você poderá baixar os códigos fontes através do site abaixo:
https://github.com/ivaldojunior/CompareClass.Net

Vamos ir mais em profundidade sobre como ele funciona, mais por enquanto é isso.

Obrigado pela leitura.

C# Paralelismo

Neste artigo, menciono exemplos de códigos feitos em C#, onde tento explorar um pouco mais da computação paralela de tarefas.

Falando a grosso modo, basicamente, o programa cliente quando executado, começa em uma única thread  (“main” thread),  segmento este, criado automaticamente pelo CLR e o Windows.

Quando usamos o paralelismo, este segmento (thread) é dividido em vários outros segmentos (threads), criando segmentos adicionais, desta forma, aproveitamos melhor o poder do processamento da máquina e fazemos o programa fluir mais rapidamente.

Vamos na prática entender melhor o seu funcionamento.

class TarefaTeste
{
 static void Main()
 {
     Thread t = new Thread (EscreveLetra); // INICIAMOS UM NOVO SEGMENTO
     t.Start(); // EXECUTANDO...

// Ao mesmo tempo, vamos fazer alguma coisa no segmento principal.
for (int i = 0; i < 1000; i++) Console.Write ("1");

}

static void EscreveLetra()
{
for (int i = 0; i < 1000; i++) Console.Write ("a");

}
}

O thread principal cria uma nova thread t em que é executado um método que imprime repetidamente o caráter “a”. Simultaneamente, o segmento principal imprime repetidamente o número 1.

No próximo código, vejamos um exemplo onde notamos que o CLR atribui para cada Thread uma pilha de memória individual mantendo desta forma uma cópia da variável “z” para cada thread em execução.

static void Main() 
{
  new Thread(Imp).Start();      // Chamada do método Imp() em um novo segmento
  Imp();                         // Chamada Imp()na thread principal
}
 
static void Imp()
{
  // declarar e usar uma variável local - "z"
  for (int z = 0; z < 5; z++) Console.Write('Z');
}

No exemplo acima, definimos um método com uma variável local, em seguida, chamamos o método simultaneamente no segmento principal.

Abaixo exemplifico uma lógica viável para lidar com uma situação similar.

class TarefaTest
{
  bool feito;
 
  static void Main()
  {
    TarefaTest t = new TarefaTest();   // cria uma instancia comum
    new Thread (t.Imp).Start();
    t.Imp();
  }
 
  // Note que Imp é agora um método de instância
  void Imp() 
  {
     if (!feito) { feito = true; Console.WriteLine("pronto"); }
  }
}

Como os dois segmentos chamam o método Imp() na mesma TarefaTest, note que eles compartilham a variável “feito”. Isso resulta em “pronto”  impresso uma vez… ao invés de duas vezes.

Falando de variáveis estáticas, as  mesmas oferecem uma outra maneira de compartilhar dados entre as threads. Veja um exemplo similar de código logo abaixo:

class TarefaTest
{
  static bool feito;
 
  static void Main()
  {
    new Thread (Imp).Start();
    Imp();
  }
  
  static void Imp() 
  {
     if (!feito) { feito = true; Console.WriteLine("pronto"); }
  }
}

Ambos os exemplos ilustram um outro conceito fundamental: o de thread safety (ou melhor, a falta dela!).

Note que a saída é na verdade indeterminada, é possível que a variável “feito” poderia ser impressa duas vezes, e este risco aumenta se você trocar a ordem das declarações do método Imp, veja abaixo um exemplo:

 
  static void Imp() 
  {
     if (!feito) { Console.WriteLine("pronto"); feito = true;  }
  }

O problema é que uma thread enquanto avalia a condição if, a outra poderia já estar executando o WriteLine, isso antes que tivesse a chance de definir o feito para true.

A solução seria obter um bloqueio exclusivo ao ler e escrever para a variável comum.

Veja o exemplo abaixo:

class TarefaTest
{
  static bool feito;
  static readonly object protege = new object() 
  static void Main()
  {
    new Thread (Imp).Start();
    Imp();
  }
  
  static void Imp() 
  {
     lock (protege)
     {
       if (!feito) { Console.WriteLine("pronto"); feito = true;}
     }
  }
}

No exemplo acima, quando duas threads simultaneamente enfrentar um bloqueio (neste caso, protege) , uma thread espera, até que o bloqueio se torna disponível. Neste caso, ele garante apenas que uma thread execute a seção do código protegida.

A seção do código protegida é denominada thread-safe.

Hoje em dia a maior complexidade em programação multithreading é a questão do compartilhamento de campos (variáveis).

No exemplo abaixo, mostro como fazer uma thread aguardar a finalização de outra.

class TarefaTest
{
 
  static void Main()
  {
    Thread t = new Thread(Imp);
    t.Start();
    t.Join();
    Console.WriteLine("A thread t acabou...!!");
  }
   
  static void Imp() 
  {
      for (int z = 0; z < 5; z++) Console.Write('Z');
  }
}

Existe também uma forma de criar um tempo limite, seja em milisegundos ou como um TimeSpan. Em seguida, retorna true se a thread terminou, ou false se esgotou..

No próximo artigo mostro como faremos isso..

 

 

Silverlight – Como desativar o evento disparado no click do botão direito do mouse

Silverlight – Como desativar o evento disparado no click do botão direito do mouse

Uma solução interessante para desativar o menu de contexto apresentado como padrão em uma aplicação silverlight, seria criar um novo manipulador de evento conforme código mostrado abaixo.

private void Application_Startup(object sender, StartupEventArgs e)
        {
            this.RootVisual = new MainPage();
            Application.Current.RootVisual.MouseRightButtonDown += 
                new System.Windows.Input.MouseButtonEventHandler(RootVisual_MouseRightButtonDown);  

        }

        void RootVisual_MouseRightButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
        {
            e.Handled = true;
        }

Existem outras alternativas, como por exemplo, utilizar código javascript para manipular o evento no nível do plugin.

Para baixar o projeto exemplo, clique aqui!

https://docs.google.com/open?id=0B8NN4AoTW8vOa0FsSXduSS1Sd3M

JavaScript – Como obter dados de uma janela do tipo POPUP

JavaScript – Como obter dados de uma janela do tipo POPUP

Abaixo um exemplo de como abrir e obter dados de uma janela popup , neste caso, utilizei o potencial da linguagem orientada a objeto JavaScript.

Criei um projeto simples de exemplo, que pode ser baixado através do link:

https://skydrive.live.com/redir?resid=55163E95BEEDE6FC!5363&authkey=!ANqp-ajUBz-8oVU

Basicamente criei duas páginas, sendo que na página default.aspx , coloquei os seguintes scripts:

    function getValueModal() {

        //seta a página popup
        var url = './popup.aspx';

        //crio um novo objeto
        var obj = new Object();

        //crio e seto a propriedade nome
        obj.nome = '';

        //chamo a função (abaixo) que irá abrir a nova janela
        //note que set o objeto obj para receber o retorno
        //importante também é popular o  window.returnValue na função localizada no página popup. 
       obj = WindowOpenModal(url, obj, 600, 400);
        
        if (obj != null) {
            document.getElementById('txtexemplo').value = obj.nome
          }
    }


    //função para formatar e abrir a nova janela tipo modal / popup
    function WindowOpenModal(page, name, w, h) {
        var vLargura
        var vAltura
        if (w == null && h == null) {
            vLargura = ScreenWidth() - 200;
            vAltura = ScreenHeight() - 100;
        }
        else {
            vLargura = w;
            vAltura = h;
        }
        return window.showModalDialog(page, name, 'dialogwidth: ' + vLargura + 'px; dialogheight: ' + vAltura + 'px;resizable:no;center:yes;scroll:yes;');
    }

Na página popup.aspx , os seguintes scripts foram colocados

function Seleciona(nome) {

    var mObj = new Object();
    mObj.nome = unescape(nome);
    //define a propriedade do valor de retorno da janela aberta 
    window.returnValue = mObj;
    window.close();
}

Baixe o projeto exemplo e experimente…

Silverlight – Executando uma app no micro cliente

Através de uma aplicação Silverlight acessamos o micro do cliente e executamos aplicações.

No exemplo abaixo, é mostrado um código utilizando a classe AutomationFactory visando a execução de um objeto que permite o acesso ao Shell do Windows… Neste caso, apenas executamos um arquivo.bat .

private void ExecutarArquivo()

{
if (AutomationFactory.IsAvailable)
{
using (dynamic wScript = AutomationFactory.CreateObject("WScript.Shell"))
{
wScript.Run("c:\teste.bat", 0, true);
}
}
}