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

Amazon AWS SES – Como utilizar o serviço de envio de emails da Amazon

Para quem ainda não conhece o serviço da Amazon Simple Emais Send (SES) , uma dica seria uma leitura em: http://aws.amazon.com/pt/ses/ 

Basicamente, você precisará baixar “The Amazon Web Services SDK for .Net” , em seguida adicionar a referência no seu projeto do assembly AWSSDK.dll

Vamos ao exemplo:

using Amazon.SimpleEmail; 
using Amazon.SimpleEmail.Model;

     static void Main(string[] args)
        {
            List listColl = new List();
            listColl.Add("DESTINO@DESTINO");


            AmazonSimpleEmailServiceClient amazonEmail = new AmazonSimpleEmailServiceClient("chave", "secret");

            SendEmailRequest mailObj = new SendEmailRequest();
            Destination destinationObj = new Destination(listColl);
            mailObj.Source = "ivaldo@nnetsistemas.com"; //from
            mailObj.ReturnPath = "ivaldo@nnetsistemas.com"; //to
            mailObj.Destination = destinationObj;

            Amazon.SimpleEmail.Model.Content emailSubjectObj = new Content("assunto");
            Amazon.SimpleEmail.Model.Content emailBodyContentObj = new Content("text...");  
  
            Amazon.SimpleEmail.Model.Body emailBodyObj = new Body();
            //emailBodyObj.Html = emailBodyContentObj;
            emailBodyObj.Text = emailBodyContentObj;
            
            Message emailMessageObj = new Message(emailSubjectObj, emailBodyObj);
            mailObj.Message = emailMessageObj;
            var response = amazonEmail.SendEmail(mailObj);
  
        }

Classe Stopwatch para marcar o tempo decorrido

 Stopwatch é uma classe no. NET Framework que é ideal para cronometrar qualquer operação em seus programas, muito útil para análise do tempo de processamento de uma thread ou tarefa no software.

Abaixo um exemplo de código.

 using System;

using System.Diagnostics;
using System.Threading;

class Program
{
    static void Main()
    {
	//instanciamos e criamos o obj
	Stopwatch stopwatch = new Stopwatch();

	// O método Start diz o objeto do cronômetro para armazenar a hora atual internamente.
	stopwatch.Start();

	// criamos um loop inútil, apenas um exemplo...
	for (int i = 0; i < 1000; i++)
	{
	    Thread.Sleep(100);
	}

	// paramos o cronômetro
	stopwatch.Stop();

	// Imprimimos o tempo decorrido
	Console.WriteLine("Tempo decorrido: {0}", stopwatch.Elapsed);
    }
}

C# – Como criar uma lista dos softwares instalados no micro

C# – Como criar uma lista dos softwares instalados no micro

Veja neste exemplo como criar uma lista simples dos softwares instalados no microcomputador e que são  passíveis de desinstalação.

Este exemplo foi baseado em cima de um código elaborado para saber se um determinado software já estava instalado no micro do usuário.


Pegue o exemplo neste link [download]