Utilizando o Visual Studio 2010, vamos hospedar um serviço WCF já existente. O foco desde artigo é a hospedagem do serviço, então o leitor pode usar um projeto do ipo Class Library já criado. Como sugestão, pode-se também aproveitar o exemplo criado no artigo Criando um serviço WFC básico e trabalhar na solução HelloWorld disponível no código fonte.

Realizaremos os seguintes passos:

• Hospedar o serviço WCF no Servidor de Desenvolvimento ASP.NET
• Criar uma aplicação cliente para consumir o serviço WCF

Hospedando o serviço WCF Utilizando ASP.NET Development Server

O projeto com o qual trabalharemos (HelloWorldService, caso o leitor utilize o projeto do artigo sugerido) é uma ClassLibrary, portanto, tem de ser hospedado em um ambiente de rede para que os aplicativos clientes possam acessá-lo. Nesta seção, vamos explicar como proceder para criar um site para hospedar um serviço WCF.

Existem vários tipos de host para serviços WCF dentro do Visual Studio 2010. No entanto, nesta seção, vamos criar manualmente o host por motivos didáticos.

Para hospedar a nossa ClassLibrary usando o Servidor de Desenvolvimento ASP.NET, precisamos adicionar um novo site para a solução. Siga estes passos para criar este site:

A)Na Solution Explorer, clique com botão direito sobre o arquivo de solução, e selecione Add | New Web Site ... no menu de contexto.

B)Selecione Visual C # | Asp.Net Empty Web Site como template. Mudar o nome do site de WebSite1 para C:\Artigos\2013\WCF\HelloWorld\HostDevServer:

Figura 1: Criando o HostServer

Agora, no Solution Explorer, você tem mais um item (HostDevServer) dentro da solução.

Em seguida, precisamos definir o site como o projeto de inicialização (Startup Project):

Figura 2: Definindo o Site Como Startup Project

Adicione o Projeto HelloWorldService como referência ao nosso Web Site.

Agora podemos executar o site dentro do Servidor de Desenvolvimento do ASP.NET. Se você iniciar o HostDevServer site, pressionando Ctrl + F5 ou selecione no menu Debug | Start Without Debugging, você vai ver um site vazio no seu browser. Porque temos que definir este site como o projeto de inicialização, mas não definimos qualquer página inicial, ele lista todos os arquivos e diretórios dentro do diretório HostDevServer (Pesquisa no Diretório é sempre habilitado para um site dentro do Servidor de Desenvolvimento do ASP.NET).

Figura 3: Rodando o Web Site

Este site realmente está sendo executado dentro do servidor de desenvolvimento integrado do ASP.NET, que é um recurso que foi introduzido no Visual Studio 2005. Este servidor web é destinado a ser usado por desenvolvedores somente, e tem uma funcionalidade semelhante à dos Serviços de Informações da Internet (IIS). Ele também tem algumas limitações, por exemplo, você pode executar aplicações ASP.NET apenas localmente. Você não pode usá-lo como um servidor IIS real para publicar um site na web.

Adicionando um arquivo svc para o aplicativo host

Embora possamos iniciar o site agora, atualmente, ele não hospeda nosso HelloWorldService. Isto é porque nós não especificamos qual o serviço que este site deve hospedar, ou um ponto de entrada para este site. Assim como um asmx é o ponto de entrada para um WebService padrão, um arquivo .Svc é o ponto de entrada para um serviço WCF, se ele está hospedado em um servidor web. Agora iremos adicionar esse arquivo para o nosso site.

A partir do Solution Explorer, clique com botão direito no site da C: \ ... HostDevServer \ e selecione Add New Item ... no menu de contexto. A janela de diálogo. Selecion

Neste artigo, vamos fugir um pouco da parte teórica e começar já na parte prática do artigo, pois os exemplos que serão criados irão demonstrar com clareza os pontos teóricos sobre a tecnologia WCF (Windows Comunication Foundation).

Utilizando o Visual Studio 2010, vamos construir um aplicativo HelloWorld em WCF. Realizaremos os seguintes passos:

• Criar o projeto e solução;
• Criar a interface do contrato de serviço WCF;
• Implementar o serviço WCF.

Vamos criar o serviço WCF manualmente a partir do zero, o que significa que não vamos utilizar qualquer template do Visual Studio para criar o serviço. Também vamos criar o aplicativo host e o aplicativo cliente manualmente, o que inclui gerar os arquivos de configuração de proxy manualmente utilizando a ferramenta svcutils.exe.

No mundo real, é recomendável utilizar os templates do Visual Studio para ajudar com essas tarefas, mas para efeito didático vamos realizar esse trabalho de forma manual, o que nos dá uma ótima oportunidade de entender o que realmente é o WCF.

Criando a solução e o projeto HelloWorld

Antes de podermos construir o serviço WCF, precisamos criar uma solução para os nossos projetos. O leitor fique à vontade para criar as pastas nos diretórios de sua preferência. Para este artigo utilizaremos o seguinte diretório: “C:\Artigos\2013\WCF\HelloWorld”.

Teremos uma subpasta para a solução e abaixo desta pasta de solução, teremos uma subpasta para cada projeto.

OBS: Você não precisa criar manualmente esses diretórios através do Windows Explorer, o Visual Studio irá criá-los automaticamente quando você cria as soluções e os projetos.

Agora, siga estes passos para criar o nosso primeiro projeto HelloWorld:

• Inicie o Visual Studio 2010.
• Vá ao menu File | New | Project. A janela de diálogo New Project será exibida.
• Selecione Other Project Types | Visual Studio Solutions e escolha o template Blank Solution.
• Nomeie como HelloWorld.

Figura 1: Criando a Solução

Ao clicar em OK o Visual Studio irá criar uma solução vazia como demonstra a figura a seguir:

Figura 2: Solução criada

No Solution Explorer, clique com botão direito sobre a solução e selecione Add | New Project, no menu de contexto.

A tela de criação de projetos será apresentada. Procure o template de projeto “Class Library”, que fica no menu “Visual C#” | “Windows”. Nomeie o projeto como “HelloWorldService” e clique no botão OK:

Figura 3: Criando a Class Library HelloWorldService

Você deve ter notado que já há um template para o WCF Service Application no Visual Studio 2010. Neste artigo não vamos usar este templa

Neste artigo abordaremos o Windows Workflow Foundation (WWF) da versão 4.0, encontrada no Visual Studio 2010. Portanto vale ressaltar que o WWF 4.0 não é compatível com as versão anteriores do Framework, sendo assim, as Activities e Services do WWF 4.0 não são compatíveis ​​com as versões anteriores

Um workflow é uma série de etapas de programação. Cada etapa é modelada em workflow como uma atividade.

Hoje em dia, há um número crescente de programas que utilizam Windows Workflow Foundation como solução técnica chave para a execução informatizada dos processos de negócios das empresas e clientes em geral.

Um componente fundamental de um projeto de Workflow é o uso de extensões para configurar o ambiente em que as atividades de Workflow irão operar. O .Net Framework oferece uma biblioteca de atividades e permite aos analistas criarem atividades personalizadas como funcionalidades adicionais.

O Workflow Designer é construído usando o Windows Presentation Foundation (WPF) o que melhora a experiência de designer das Activities e melhora o desempenho para Workflows grandes e complexos.

Alguns dos principais critérios para utilização de Workflow são listados abaixo:

• Representação visual do processo;
• Pode ser modificada dinamicamente em tempo de execução;
• Pode ser de longa duração.

As Activities podem ser criadas visualmente em Workflows usando o Workflow Designer, uma interface de design que funciona dentro do Visual Studio. O designer também pode ser hospedado em outras aplicações.

Encapsular as funcionalidades de um programa em Activities permite ao desenvolvedor criar aplicações mais gerenciáveis, pois cada componente da execução pode ser desenvolvido como um objeto da Common Language Runtime cuja execução será gerida pelo Runtime do Workflow.

Veja abaixo uma figura Ilustrativa que demonstra visualmente como a tecnologia WWF 4.0 está posicionada no .Net Framework 4.0:

Figura 1: WWF no .Net

Veja o leitor que o WWF se encontra na caixa “Services”, juntamente com outras tecnologias.

O WWF possui um poderoso “engine”, que provê as seguintes funcionalidades:

• Planejamento e execução de Workflows e Activities, que podem ser executados usando um de três métodos:
  - Usando WorkflowInvoker, que executa Workflows em Threads (isto é, uma nova Thread não é criada para o Workfolow). Isto significa que o processo de chamada irá aguardar o fluxo de trabalho para completar.
  - Usando WorkflowApplication, que executa Workflows em uma nova thread (de modo que o aplicativo de chamada n ...

Olá a todos.

É provável que Serialização Binária não esteja na moda nos tempos atuais, visto que o padrão XML está amplamente divulgado, e com razão, pois oferece muitos benefícios. Porém Serialização Binária é extremamente útil e oferece muitos benefícios.

Para começar, vamos explicar bem resumidamente o que é serialização.

Em linhas gerais serialização é uma técnica utilizada para persistir objetos. É a técnica a ser utilizada quando precisamos gravar objetos oriundos de nossas aplicações em Bancos de Dados, arquivos, ou XML ou então quando precisamos transmitir esses objetos remotamente via rede. Para maiores detalhes, o leitor pode ler este artigo: Overview a respeito de Serialização , onde existe uma explicação um pouco mais detalhada sobre o assunto.

A definição técnica de Serialização Binária segundo a documentação da MSDN é a seguinte:

“...utiliza codificação binária para produzir uma serialização compacta a ser utilizada tanto em armazenamento físico como em streams de rede. Não é adequada para transmitir dados através de Firewall, mas oferece melhor desempenho ao armazenar dados... ”.

Preste atenção na frase final da oração acima, realmente, é a mais pura verdade.

Cheguei a essa conclusão quando estava trabalhando em um projeto onde era necessário serializar um objeto que possuía muitas propriedades do tipo List

Podemos então resumir a vantagem da Serialização Binária com apenas duas palavras: desempenho superior.

Porém, penso que haveria problemas para integrar um sistema feito em .Net com outro feito em Java utilizando esse tipo de serialização, visto que a maneira de implementar Serialização Binária é diferente nesses dois frameworks.

Terminando a parte teórica do artigo, vamos agora construir uma classe que implementará a técnica de Serialização Binária.

No Visual Studio 2010 Express, crie um projeto do tipo Console Application utilizando C#. Nomeie-o como “AppBinSerializer”.

Figura 1: Criando novo projeto

Agora, com o projeto criado, adicione uma nova classe clicando com o botão direito sobre o projeto.

Figura 2: Adicionando nova classe

Nomeie a classe como CustomBinarySerializer. Essa classe conterá os métodos que receberão um objeto qualquer e o transformará em código binário.

Para começar a codificação adicione os seguintes usings:

Listagem 1: Referência a namespaces necessários

using System;
using System.Collections.Generic;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;

Antes de tudo, vamos deixar nossa classe totalmente genérica colocando um Type Parameter (comando ) na declaração da classe. Isso fará com que possamos serializar qualquer tipo de objeto, mas na instanciação da classe, teremos que indicar os tipos de objetos que iremos serializar.

Listagem 2: Definição da classe genérica

public class CustomBinarySerializer<T>
{

}

Agora criaremos o primeiro método. Ele fará a serialização propriamente dita. Adicione os seguintes comandos à classe:

Listagem 3: Método para serialização

public byte[] SerializeToBytes(T data)
{
    byte[] ret = null;
    if (data != null)
    {
       MemoryStream streamMemory = new MemoryStream();
       BinaryFormatter formatter = new BinaryFormatter();
       formatter.Serialize(streamMemory, data);
       ret = streamMemory.GetBuffer();
    }

    return ret;
}

Simples não? Em linhas gerais criamos um MemoryStream que recebe o retorno do método Serialize do objeto BynaryFormatter. Um detalhe interessante é a declaração do tipo do parâmetro esperado pelo método SerializeToBytes. Repare que utilizamos o Type Parameter declarado na classe, ou seja. Isso significa que, por exemplo, se instanciarmos essa classe passando o tipo String no Type Parameter, esse método automaticamente esperará uma string como parâmetro.

Passaremos agora a codificar o método que realizará a Deserialização, ou seja, transformar um array de byte para um objeto específico. Adicione o seguinte bloco de comando:

Listagem 4: Método para deserializar

public T DeserializeFromBytes(byte[] binData)
{
      T retorno = default(T);
      if (binData != null || binData.Length != 0)
      {
          BinaryFormatter formatter = new BinaryFormatter();
          MemoryStream ms = new MemoryStream(binData);
          retorno = (T)formatter.Deserialize(ms);
      }
      return retorno;
}

Começamos parametrizando o retorno do método de acordo com o Type Parameter da classe. Depois instanciamos um objeto do tipo T utilizando o comando defalt(T). Posteriormente verificamos a array de byte passada como parâmetro para nos certificarmos que ela está preenchida com algum valor e a partir daí utilizamos o método Deserialize do objeto BynaryFormatter, passando um MemoryStream que receberá o array de byte a ser deserializado. Note que fazemos um Parse explícito do retorno do método Deserialize para garantirmos a integridade do tipo retornado pelo método.

É isso. Esses dois métodos implementam a serialização binária. Segue o código completo da classe até aqui.

Listagem 5: Código completo da classe

public class CustomBinarySerializer<T>
    {
        public byte[] Serialize2Bytes(T data)
        {
            byte[] ret = null;

            if (data != null)
            {
                MemoryStream streamMemory = new MemoryStream();
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(streamMemory, data);
                ret = streamMemory.GetBuffer();
            }

            return ret;
        }

        public T DeserializeFromBytes(byte[] binData)
        {
            T retorno = default(T);
            if (binData != null || binData.Length != 0)
            {
                BinaryFormatter formatter = new BinaryFormatter();
                MemoryStream ms = new MemoryStream(binData);
                retorno = (T)formatter.Deserialize(ms);

            }
            return retorno;
        }
    }

Vamos testar nossa aplicação. Primeiramente vamos criar dentro da classes Program uma classe simples com três propriedades e dois construtores somente para testarmos a serialização com tipos complexos (poderíamos testar utilizando tipos nativos do .Net). Repare que precisamos utilizar o atrubuto [Serializable], pois dessa maneira indicamos ao runtime que essa classe pode ser serializada. Sem esse atributo nada irá funcionar.

Dentro da classe Program.cs do Console Application adicione as seguintes linhas de código.

Listagem 6: Alterações no Program.cs

[Serializable]
class TestSerialize
{
   private int _cod;
   private string _desc;
   private DateTime _dataManut;
   public int Cod
   {
        get { return _cod; }
        set { _cod = value; }
   }
   public string Desc
   {
        get { return _desc; }
        set { _desc = value; }
   }
   public DateTime DataManut
   {
       get { return _dataManut; }
       set { _dataManut = value; }
   }
}

public TestSerialize()
{

}

public TestSerialize(int cod, string desc, DateTime data)
{
    this._cod = cod;
    this._desc = desc;
    this._dataManut = data;
}

Agora dentro do método Main vamos instanciar um objeto da classe TestSerialize e instanciar um objeto da classe CustomBinarySerializer. Depois chamamos o método SerializeToByte para serializarmos o objeto TestSerialize e verificaremos o retorno deste método escrevendo o conteúdo do array de byte na tela do console:

Listagem 7: Alterações no método Main

static void Main(string[] args)

static void Main(string[] args)

{

   bool diaMesImpar;

   if ((DateTime.Now.Day % 2) != 0)

   diaMesImpar = true;

}

static void Main(string[] args)

{

      bool diaMesImpar = ((DateTime.Now.Day % 2) != 0) ? true : false;

}

 

O que é Dependency Injection?

Meios de Implementação de Dependency Injection

 
        public class Empresa
        {
            private int _cod;
 
            public int Cod
            {
                get { return _cod; }
                set { _cod = value; }
            }
            private string _razaoSocial;
 
            public string RazaoSocial
            {
                get { return razaoSocial; }
                set { razaoSocial = value; }
            }
 
            private Endereco _endereco;
 
            public Endereco Endereco
            {
                get { return _endereco; }
                set { _endereco = value; }
            }
 
        }

Sintaxe de um Destrutor

 public class ExemploDestrutor

        {

            //Destrutor

            // ~ + o nome da Classe

            ~ExemploDestrutor()

            {

                //Codigo de destruição de objetos

            }

        }

Algumas características de um Destrutor

  public class AluguelItem

        {

            string _titulo;

 

            public string Titulo

            {

                get { return _titulo; }

                set { _titulo = value; }

            }

            public Boolean VerificaEstoque(string titulo)

            {

                //codigo para verificar um item no estoque

                //returna true para demonstração

                return true;

            }

        }

        public class DVD : AluguelItem

        {

        }

        public class Liv

1. Preencher uma string com caracteres repetidos

string s = new string('*', 20);

2. Procurar Strings vazias

bool IsEmpty = String.IsNullOrEmpty(str);

3. Reverter uma String

    public string Reverse()

    {

        string s = "LEANDRO";

        char[] charArray = s.ToCharArray();

        Array.Reverse(charArray);

        return new string(charArray);

    }

 

4. Comparação de Strings

if (String.Compare( s1, s2, true ) == 0)

Olá a todos.

Todos os meus artigos que publiquei na DevMedia até hoje foram artigos técnicos voltados para a linguagem C#. Porém neste artigo, vamos sair um pouco dessa tônica e tentar explicar os fundamentos de uma linguagem muito importante não só para desenvolvedores, mas para todos os profissionais que se envolvem em projetos de desenvolvimento de sistemas e clientes.

Nesta série de artigos veremos o que é UML, para que serve e alguns exemplos práticos dos seus diagramas mais comumente utilizados.

O que é UML?

UML é um acrônimo para a expressão Unified Modeling Language. Pela definição de seu nome, vemos que UML é uma linguagem que define uma série de artefatos que nos ajuda na tarefa de modelar e documentar os sistemas orientados a objetos que desenvolvemos.

Ela possui nove tipos de diagramas que são usados para documentar e modelar diversos aspectos  dos sistemas.

A maioria dos problemas encontrados em sistemas orientados a objetos tem sua origem na construção do modelo, no desenho do sistema. Muitas vezes as empresas e profissionais não dão muita ênfase à essa fase do projeto, e acabam cometendo diversos erros de análise e modelagem. Isso quando há modelagem, pois nós profissionais da área sabemos que muitas vezes o projeto começa já na fase de codificação.

Diagrama de Casos de Uso

Esse diagrama documenta o que o sistema faz do ponto de vista do usuário. Em outras palavras, ele descreve as principais funcionalidades do sistema e a interação dessas funcionalidades com os usuários do mesmo sistema. Nesse diagrama não nos aprofundamos em detalhes técnicos que dizem como o sistema faz.

Este artefato é comumente derivado da especificação de requisitos, que por sua vez não faz parte da UML. Pode ser utilizado também para criar o documento de requisitos.

Diagramas de Casos de Uso são compostos basicamente por quatro partes:

• Cenário: Sequência de eventos que acontecem quando um usuário interage com o sistema.
• Ator: Usuário do sistema, ou melhor, um tipo de usuário.
• Use Case: É uma tarefa ou uma funcionalidade realizada pelo ator (usuário)
• Comunicação: è o que liga um ator com um caso de uso

Vamos criar um cenário de exemplo para vermos a notação de um diagrama de caso de uso:

“A clínica médica Saúde Perfeita precisa de um sistema de agendamento de consultas e exames. Um paciente entra em contato com a clínica para marcar consultas visando realizar um check-up anual com seu médico de preferência. A recepcionista procura data e hora disponível mais próxima na agenda do médico e marca as consultas. Posteriormente o paciente realiza a consulta, e nela o médico pode prescrever medicações e exames, caso necessário”.

Com esse cenário simples podemos começar a criar nosso diagrama. Inicialmente vamos definir nossos atores:

a)     Paciente

b)     Secretária

c)      Médico

Agora vamos definir algumas ações de cada usuário:

1. Overview sobre Multithreads

1.1 O que são Threads?

Thread é uma forma de um processo dividir a si mesmo em duas ou mais tarefas, podendo executar elas concorrentemente. O suporte a threads é oferecido pelos Sistemas Operacionais, ou por bibliotecas de algumas linguagens de programação

1.2 O que são Aplicações Multithreads?

Um programa single - thread (thread única) inicia na etapa 1 e continua seqüencialmente (etapa 2, etapa 3, o passo 4) até atingir a etapa final. Aplicações multithread permitem que você execute várias threads ao mesmo tempo, cada uma executando um passo por exemplo.

Cada thread é executada em seu próprio processo, então, teoricamente, você pode executar o passo 1 em uma thread e, ao mesmo tempo executar o passo 2 em outra thread e assim por diante. Isso significa que a etapa 1, etapa 2, etapa 3 e etapa 4 podem ser executadas simultaneamente.

Na teoria, se todos os quatro passos durassem o mesmo tempo para executar, você poderia terminar o seu programa em um quarto do tempo que levaria para executar os quatro passos sequencialmente.

Então, por que todos os programas não são multithread? Uma das razões nos diz que junto com a velocidade vem a complexidade. Controlar um grande número de threads requer bastante trabalho e conhecimento. Imagine se um passo de alguma forma dependesse das informações no passo 2. O programa pode não funcionar corretamente se o passo 1 termina cálculo antes do passo 2 ou vice-versa.

Para ajudar entender essa complexidade, vamos fazer uma analogia comparando um programa multithread com o corpo humano. Cada um dos órgãos do corpo (coração, pulmões, fígado, cérebro) são processos e cada processo é executado simultaneamente. Assim, o corpo humano seria como uma grande aplicação multithread. Os órgãos são os processos em execução simultânea, eles dependem uns dos outros, sendo que todos os processos se comunicam através de sinais nervosos e fluxo de sangue, desencadeando uma série de reações químicas. Como em todos os aplicativos multithread, o corpo humano é muito complexo. Se algum processo não obtiver informações de outros processos, ou um processo retardar ou acelerar, vamos acabar com um problema médico. É por isso que, esses processos precisam ser sincronizados corretamente para funcionar normalmente.

1.3 Quando Utilizar Multithread?

Quando precisamos de desempenho e eficiência. Por exemplo, vamos pensar em um jogo de vídeo game. Imagine um jogo possuindo uma única thread, tanto para o processamento de imagens quanto para o processamento de áudio. Seria possível? Sim, seria. Mas esse é o cenário ideal para garantir a performance? Não. O ideal seria criar threads para o processamento das rotinas de imagens e outra para rotinas de áudio.

Outro cenário comum onde você precisaria de Multithread seria um sistema de tratamento de mensagens. Imagine um aplicativo que captura milhares de mensagens simultaneamente. Você não pode capturar eficientemente uma série de mensagens ao mesmo tempo em que você está fazendo algum outro processamento pesado, porque senão você pode perder mensagens. Então cabe aqui dividir o processamento de captura e processamentos paralelos em threads diferentes.

Cada um destes cenários são usos comuns para multithread e se utilizado de maneira correta, essa técnica vai melhorar significativamente o desempenho de aplicações similares.

Em linhas gerais, os benefícios do uso das threads advém do fato do processo poder ser dividido em várias threads; quando uma thread está à espera de determinado dispositivo de entrada/saída ou qualquer outro recurso do sistema, o processo como um todo não fica parado, pois quando uma thread entra no estado de 'bloqueio', uma outra thread aguarda na fila.

1.4 Quando não utilizar Multithread?

Geralmente quando aprendemos os recursos de multithread, ficamos fascinados com todas as possibilidades que essa técnica nos oferece e saímos usando – a em todos os tipos de programas que vemos pela frente.

É preciso tomar muito cuidado com isso, pois ao contrário de um programa single thread, você está lidando com muitos processos ao mesmo tempo, com múltiplas variáveis ??dependentes. Isso pode se tornar muito complicado de se controlar. Pensemos em multithread, um malabarismo. Malabarismos com uma única bola em sua mão (embora meio chato) é bastante simples. No entanto, se você é desafiado a colocar duas dessas bolas no ar, a tarefa é um pouco mais difícil. Imagine três, quatro, cinco bolas então, e as coisas vão se tornar cada vez mais difíceis. Como a contagem de bola aumenta você tem chances cada vez maiores de deixar cair alguma bola.

Trabalhar com multithreads requer muito trabalho e concentração. É preciso ressaltar que o uso dessa técnica em sistemas simples, geralmente não nos leva a um cenário muito proveitoso. Mesmo que o programador seja um cara muito bom e desenhe direitinho o sistema utilizando threads, fatalmente o ganho em performance não irá compensar caso seja necessário dar manutenções futuras no sistema.

2. Como Utilizar Threads

2.1 Criando uma Multithread

Dentro do .Net, para criar uma thread devemos utilizar o Namespace System.Threading. Nesta Namespace se encontra a classe Thread, que é a que usamos para instanciar uma thread.

No exemplo abaixo, veremos como instanciar uma thread e como rodá – la. Antes de tudo, uma thread sempre realiza determinada tarefa codificada em um método. Sendo assim, primeiramente vamos definir um método estático que realizará alguns prints em uma aplicação de Console:

Lembrando que todos os exemplos citados aqui foram feitos em C#, no Visual Studio 2008, utilizando um projeto do tipo Console Application.

public static void run()
{
      for (int i = 0; i < 5; i++)
      {
   Console.WriteLine("Thread Atual - " + Thread.CurrentThread.Name + i);
               
         Thread.Sleep(1000);
      }
}

Este método apenas escreve na tela o nome da thread atual dentro de um loop for.

Repare que no código abaixo este método será utilizado para instanciar uma thread, pois para criar threads, precisamos apontar o método que ela executará, passando como parâmetro ao construtor da thread um objeto ThreadStart, que recebe o nome do método a ser executado pela thread.

Agora no método Main do seu Console Application, digite as seguintes linhas de código:

static void Main(string[] args)
{
   Console.WriteLine("Thread principal iniciada");
   Thread.CurrentThread.Name = "Principal - ";
 
   Thread t1 = new Thread(new ThreadStart(run));
   t1.Name = "Secundária - ";
   t1.Start();
 
   for (int i = 0; i < 5; i++)
   {
     Console.WriteLine("Thread atual  

Olá a todos os leitores da DevMedia.

Neste  artigo veremos um exemplo de uso de Métodos Condicionais em C#. Essa técnica provê um poderoso mecanismo pelo qual as chamadas dos métodos podem ser incluídas ou omitidas. Essa técnica pode ser utilizada no caso de você querer que sua aplicação se comporte de maneiras diferentes em modo debug e release.

Vamos tomar como exemplo um programa que possui um método que captura alguns argumentos de uma linha de comando. Para testar esse método você precisa reiniciar o programa diversas vezes em diferentes cenários em modo Debug. Mas quando a aplicação for implantada você deseja ignorar esses testes.

Para utilizar essa técnica basta utilizar o atributo “Conditional” que se encontra em “System.Diagnostics”.

Nosso teste será bastante simples. Em um Console Application, na classe Program, criaremos um método estático que receberá uma string para escrever algo, somente em modo Debug. No método Main da classe Program, chamaremos esse método. Ainda dentro do método Main escreveremos na tela uma string , tanto em modo Debug e Release.

class Program
    {
        [Conditional("DEBUG")] // this method is only called in debug mode.
        public static void TestaMetodo(string trace)
        {
            Console.WriteLine("[TRACE] - " + trace);
        }       
        static void Main(string[] args)
        {
            Program.TestaMetodo("Essa linha só é escrita em Debug - Iniciando"); 
            Console.WriteLine("Escrevendo algo em modo release e debug."); 
            Program.TestaMetodo("Essa linha só é escrita em Debug - Finalizando");
            Console.ReadKey();
        }

    }

Quando o programa é rodado em modo Debug temos a seguinte tela:

Quando rodamos a aplicação em modo Release temos o seguinte resultado:

O uso do Atributo Condicional torna muito fácil a tarefa de depurar e implantar aplicações sem que seja necessário uma alteração de código para cada ambiente.

Espero que esse artigo tenha sido útil.

Obrigado e até a próxima.

public T GenDeserializer(string pXML)
        {
            UTF8Encoding encoding = null;
            XmlDocument xmlDoc = null;
            MemoryStream ms1 = null;
            XmlSerializer customSerializer = null;
            T Obj = default(T);
            try
            {
                xmlDoc = new XmlDocument();
                xmlDoc.LoadXml(pXML);

                encoding = new UTF8Encoding();
                using (ms1 = new MemoryStream(encoding.GetBytes(xmlDoc.InnerXml)))
                {
                    ms1.Position = 0;
                    customSerializer = new XmlSerializer(typeof(T));
                    Obj = (T)customSerializer.Deserialize(ms1);
                }

            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                encoding = null;
                xmlDoc = null;
                ms1 = null;
                customSerializer = null;
            }
            return Obj;
        }

  static void Main(string[] args)
        {
            Cliente cliente = new Cliente();
            cliente.Id = 10;
            cliente.NomeCompleto = "Cliente Teste";
            cliente.Cpf = 500986026;            
cliente.Email = "emailcliente@cliente.com";
            cliente.Senha = "senha123";

        }

Olá a todos.

No artigo anterior, vimos uma breve descrição sobre o que é e para que serve Serialização. Construímos também nossa classe modelo que será utilizada para testarmos nossa ferramenta.

Agora iniciaremos a codificação de nossa ferramenta. No projeto “Utils” (ver artigo anterior, onde criamos nossa solução no Visual Studio) crie uma nova classe de nome “GenericSerializer.cs”.  A idéia é ter uma ferramenta que possa serializar qualquer tipo de objeto criado por nós, ou seja, objetos que serão instâncias de nossas classes. Seguindo esse pensamento, a classe “GenericSerializer.cs” deverá ser capaz de ler em tempo de execução e até em tempo de design, qualquer tipo de objeto que definirmos. Para isso utilizamos os chamados “Parameters Type”, que são usados em definições de classes genéricas. Abaixo segue a definição de nossa classe:

 
public class GenericSerializer<T>

Quando definimos uma classe genérica, podemos aplicar restrições (Constraint) aos tipos que a classe receberá como argumento. Exemplo:

 
public class GenericSerializer<T> where T : new()

Aqui nós restringimos o uso de nossa classe para instâncias de classes que possuem um construtor público vazio, ou seja, sem parâmetros. Exemplo

 
public Cliente() 
{ 

}

Quando um código cliente tenta usar a classe genérica usando um tipo que não é permitido pela Constraint definida, o resultado é um erro em tempo de compilação.

Abaixo segue uma tabela com todos os tipos de Constraints que podemos utilizar na construção de classes genéricas:

Olá a todos.

Cada vez mais o uso de arquivos XML se mostra necessário no nosso dia a dia. Projetos de integração de sistemas, construção de projetos multiplataformas e até projetos que disponibilizam serviços via Cloud Computing nos obrigam cada vez mais dominarmos as técnicas de construção de Web Services que lidam com arquivos do tipo XML.

Nesse contexto, as técnicas de Serialização se mostram muito úteis no nosso cotidiano.

Serialização é o processo de transformar um objeto (geralmente uma instância de uma classe) em uma sequência de bytes, para persistir na memória, num banco de dados ou em um arquivo. O objetivo é salvar o estado de um objeto para poder recriá-lo quando necessário. Para recriar um objeto utilizamos a desserialização, que é o processo inverso ao de Serialização, ou seja, transformar uma sequência de bytes em um objeto.

Ilustração 1 - Processo de Serialização

O objeto é serializado em um fluxo, que pode transportar não apenas dados, mas informações sobre o tipo do objeto, como seu nome, versão, cultura, e assembly. Esse fluxo pode ser armazenado em um banco de dados, em um arquivo, ou na memória.

A serialização permite que o desenvolvedor salve o estado de um objeto e o recrie conforme necessário, fornecendo o armazenamento dos objetos, bem como intercâmbio de dados. Através da serialização, um desenvolvedor pode executar ações como enviar o objeto para um aplicativo remoto por meio de um serviço da Web, passando um objeto de um domínio para outro, passando um objeto através de um firewall como uma sequência XML

Neste artigo construiremos uma ferramenta que poderá serializar objetos para XML, visando disponibilizar de maneira simples essa funcionalidade tão impor

Na parte anterior do artigo, criamos o método que fará a exportação do GridView, Poderíamos parar por ali mas existe a possibilidade de o GridView conter TemplateFields, contendo WebControls. Para essa situação, deveremos criar um método que substitui esses TemplateFields com WebControls por textos contidos nos próprios WebControls.

private static void PrepareGridViewForExport(Control gv)
    {
        LinkButton lb = new LinkButton();
        Literal l = new Literal();
        string name = String.Empty;
        for (int i = 0; i < gv.Controls.Count; i++)
        {
            if (gv.Controls[i].GetType() == typeof(LinkButton))
            {
                l.Text = (gv.Controls[i] as LinkButton).Text;
                gv.Controls.Remove(gv.Controls[i]);
                gv.Controls.AddAt(i, l);
            }
            else if (gv.Controls[i].GetType() == typeof(DropDownList))
            {
                l.Text = (gv.Controls[i] as DropDownList).SelectedItem.Text;
                gv.Controls.Remove(gv.Controls[i]);
                gv.Controls.AddAt(i, l);
            }
            else if (gv.Controls[i].GetType() == typeof(ImageButton))
            {
                l.Text = (gv.Controls[i] as ImageButton).ToolTip;
                gv.Controls.Remove(gv.Controls[i]);
                gv.Controls.AddAt(i, l);
            }
            else if (gv.Controls[i].GetType() == typeof(Button) ||
                     gv.Controls[i].GetType() == typeof(HiddenField) ||
                     gv.Controls[i].GetType() == typeof(CheckBox))
            {
                gv.Controls.Remove(gv.Controls[i]);
            }
            if (gv.Controls[i].HasControls())
            {
                PrepareGridViewForExport(gv.Controls[i]);
            }
        }
    }

Aqui criamos uma função recursiva que lê  todos os controles de um GridView. Uma vez detectado um controle, é verific

Olá a todos.

Neste artigo veremos como exportar dados contidos em um GridView para documentos do tipo Word e Excel.

Nosso exemplo será bastante simples, pois utilizaremos recursos do próprio .Net para realizarmos a exportação.

Crie um projeto do tipo Web Application com uma página – Default.aspx e uma classe – Exporter.cs.

A página Default.aspx conterá os controles:

• GridView;
• SqlDataSource;
• Button

Este GridView está vinculado à um SqlDataSource que contem um select simples, o que faz com que o GridView seja preenchido com os dados de uma tabela ao executar a aplicação. Aqui o leitor poderá fazer o mesmo procedimento ou utilizar outras maneiras de preencher o GridView.

Nesta última parte do artigo finalizaremos os nossos teste

Muito bem, podemos agora codificar o Program.cs para testarmos o funcionamento do projeto. Na classe Program.cs adicione os seguintes “usings”:

using System;using System.Collections.Generic;using System.IO;using TestProject.Model;

using TestProject.BO;

Depois, dentro da classe Program crie o seguinte método:

static byte[] GetFile()

        {

            byte[] buffer = null;

            string fileName = @"C:\teste.jpg";

            FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);

            BinaryReader br = new BinaryReader(fs);

            long numBytes = new FileInfo(fileName).Length;

            buffer = br.ReadBytes((int)numBytes);

            return buffer;

 

        }

Este método pega os bytes de um arquivo qualquer no disco. Modifique a linha string fileName = @"C:\teste.jpg" para apontar para ajgum arquivo no seu disco rígido. Vai servir para inserirmos uma array de bytes no campo “prod_img_bytes”, do BD. Esse campo é do tipo image.

Agora dentro do método Main adicione os seguintes comandos:

Produto prod = new Produto();

prod.Desc = "Teste Produto Update 12";

prod.Id = 2;

prod.Imagem = "1231232132132";

prod.Nome = "Teste Insert";

prod.Preco = Decimal.Parse("125,77");

prod.Url = "jodijfosi";

prod.ImagemByte = GetFile();

Nesse bloco de comandos apenas instanciamos um objeto do tipo Produto (classe model) e setamos suas propriedades. Note que utilizamos o método “GetFile()”, que retorna um array de bytes, referentes a um arquivo.

Vamos agora testar o método “TestaInsertUpdateTrans” da classe ProdutoBO:

ProdutoBO boProduto = new ProdutoBO();

boProduto.TestaInsertUpdateTrans(prod);

Console.WriteLine("Produto '{0}' Inserido e alterado com sucesso", prod.Id);

Console.WriteLine();

Console.ReadKey();

Antes de testarmos, vou colocar o método Main completo da classe Program:

static void Main(string[] args)

        {

            try

            {

                Produto prod = new Produto();

                prod.Desc = "Teste Produto Update 12";

                prod.Imagem = "1231232132132";

                prod.Nome = "Teste Insert";

                prod.Preco = Decimal.Parse("125,77");

                prod.Url = "jodijfosi";

                prod.ImagemByte = GetFile();

 

                ProdutoBO boProduto = new ProdutoBO();

                boProduto.TestaInsertUpdateTrans(prod);

                Console.WriteLine("Produto '{0}' Inserido e alterado com sucesso", prod.Id);

                Console.WriteLine();

                Console.ReadKey();

 }

            catch (Exception ex)

            {

                if (ex.InnerException == null)

                {

                    Console.WriteLine(ex.Message);

                }

                else

                {

                    Console.WriteLine(ex.InnerException.Message);

                }

            }

            finally

            {

                Console.ReadKey();

            }

           }

Vamos testar nossa aplicação e ver o resultado na tela:

Ilustração SEQ Ilustração \* ARABIC 15 – Resultado do método que insere um produto

No meu caso, como já existem alguns produtos cadastrados na tabela, o sistema retornou o id 97. Vamos olhar no BD o produto com ID 97:

Ilustração SEQ Ilustração \* ARABIC 16 – Registros da tabela Produto

Vemos aqui que tudo foi inserido e alterado corretamente, inclusive o campo prod_img_byte que é um image.

Vamos agora testar o método da classe ProdutoBO que retorna uma lista de produtos. Vamos adicionar os seguintes comando ao método Main da classe Program:

Console.Clear();

 

                List<Produto> listRetorno = boProduto.GetListaSemFiltro();

 

                if (listRetorno.Count > 0)

                {

                    foreach (Produto pro in listRetorno)

                    {

                        Console.WriteLine("ProdutoId = " + pro.Id + " imagem_Byte = " + pro.ImagemByte.Length);

                    }

                }

 

                Console.ReadKey();

Vamos agora desenvolver nosso projeto de teste que será um Console Application.

Como foi dito no início do artigo, iremos utilizar o conceito de três camadas (Model, Business e Data Access). Dessas três camadas, iremos codificar apenas a Model e a Business, pois utilizaremos nossa classe DAL Genérica.

No seu Visual Studio 2008, dentro da nossa solução, crie mais um projeto de nome “TestProject” do tipo Console Application.

Vamos primeiramente montar a estrutura de pastas deste projeto:

Ilustração SEQ Ilustração \* ARABIC 12 – Estrutura de pastas do projeto de teste

Dentro do projeto temos uma pasta BO (anacrônico para Business Objects), onde ficarão as classes da camada Business, e temos uma pasta onde ficarão as classes da camada Model (ou Entities). Temos também um App.Config, que conterá as strings de conexão e algumas chaves na seção appconfig. A classe Program.cs será o Console Application propriamente dito.

Vamos iniciar a codificação pelo App.Config:

xml version="1.0" encoding="utf-8" ?>

<configuration>

  <appSettings>

    <add key ="current.connection" value="sqlServerConn"/>

  appSettings>

  <connectionStrings>

    <add name="sqlServerConn" connectionString="Data Source=CTS06483251\SQLEXPRESS;Initial Catalog=TESTE;Integrated Security=True" providerName="System.Data.SqlClient"/>

    <add name="sqlServerConn2" connectionString="Data Source=CTS06483251\SQLEXPRESS;Initial Catalog=TESTE2;Integrated Security=True" providerName="System.Data.SqlClient"/>

  connectionStrings>

configuration>

Este é o nosso arquivo de configuração. Ele é bem simples. Possui apenas a chave “current.connection” na seção appSettings>, necessária para o funcionamento da nossa classe DAL genérica. Essa chave aponta para a string de conexão que será a mais utilizada pela nossa aplicação.

Na seção connectionStrings> temos duas conection strings, uma que será a principal “sqlServerConn”, que é a que utilizaremos no nosso primeiro exemplo, e outra de nome “sqlServerConn2” que utilizaremos mais tarde.

Agora precisamos adicionar as referências dos outros projetos da solução ao projeto de teste. Clique com o botão direto do mouse no projeto de teste, depois clique em “add reference” na aba “Projects” selecione todos os projetos e clique em “OK”.

Ilustração SEQ Ilustração \* ARABIC 13 – Referências a serem adicionadas ao projeto de teste

Agora que temos todas as referências que precisamos, vamos codificar nossa classe model. No nosso BD temos apenas uma tabela e cinco procedures. Vamos então criar uma classe para representar essa tabela e utilizar os Atributos customizados que construimos, para mapear as propriedades dessa classe com os campos da tabela e com os parâmetros das Stored Procedures.

Clique com o botão direito do mouse na pasta “Model” e adicione uma nova classe de nome “Produto.cs”.

Vale lembrar que, por ser uma classe da camada Model, esta classe não conterá nenhum método, somente propriedades. Primeiramente adicione os seguintes “usings”:

using System;

using System.Collections.Generic;

using System.Text;

using System.Data;

using GenDAL.Library.Attributes;

using GenDAL.Library.BaseClasses;

Logo após declaramos a namespace da classe model. Se não estiver assim, corrija:

namespace TestProject.Model

{

 

}

Vamos agora declarar a classe:

[AttProcNameSelectNoFilter("spSELProd_S")]

[AttDataAccessType(DataAccesType.Both)]

public class Produto : BaseModelClass

{

 

}

Utilizamos dois de nossos atributos customizados - AttProcNameSelectNoFilter que serve para indicar qual é a procedure que realiza um Select sem filtro e AttDataAccessType que serve para indicar qual será o tipo de acesso a dados que a classe DAL realizará. No caso deixamos setado para Both, que quer dizer que a classe DAL poderá acessar o BD via SP ou via execução de SQL. Repare que a classe herda de BaseModelClass. Ess