Passo a passo: Criando um aplicativo Baseado Agente-

Artigo
02/25/2013

Este tópico descreve como criar um aplicativo baseado agente- básico.Neste passo-a-passo, você pode criar um agente que lê dados de um arquivo de texto de forma assíncrona.O aplicativo usa o algoritmo de soma de verificação Adler-32 para calcular a soma de verificação dos conteúdos de aquele arquivo.

Pré-requisitos

Você deve compreender os tópicos a seguir para concluir essa explicação passo a passo:

Seções

Essa explicação passo a passo demonstra como executar as seguintes tarefas:

Criando o aplicativo de console
Criando a classe de file_reader
Usando a classe de file_reader no aplicativo

Criando o aplicativo de console

Esta seção mostra como criar um aplicativo de console do Visual C++ que referencia os arquivos de cabeçalho que o programa usará.

Para criar um aplicativo Visual C++ usando o assistente do aplicativo de console do Win32

No menu de Arquivo , clique em Novo, e clique em Projeto para exibir a caixa de diálogo de Novo Projeto .
Na caixa de diálogo de Novo Projeto , selecione o nó de Visual C++ no painel de Tipos de projeto e selecione Aplicativo do Console Win32 no painel de Modelos .Digite um nome para o projeto, por exemplo, BasicAgent, clique em OK para exibir Assistente do aplicativo de console do Win32.
Na caixa de diálogo Assistente do aplicativo de console do Win32 , clique Concluir.
Em stdafx.h, adicione o seguinte código.
```
#include <agents.h>
#include <string>
#include <iostream>
#include <algorithm>
```
O arquivo de cabeçalho agents.h contém a funcionalidade da classe de concurrency::agent .
Verifique se o aplicativo foi criado com êxito compilar e executar o.Para compilar o aplicativo, no menu de Compilar , clique Compilar solução.Se o aplicativo cria com êxito, execute o aplicativo clicando em Iniciar Depuração no menu de Depurar .

Superior[]

Criando a classe de file_reader

Esta seção mostra como criar a classe de file_reader .O tempo de execução agenda cada agente para realizar o trabalho em seu próprio contexto.Como consequência, você pode criar um agente que executa o trabalho de forma síncrona, mas interage com outros componentes de forma assíncrona.A classe de file_reader lê dados de um arquivo de entrada dada e enviar dados de aquele arquivo a um determinado componente de destino.

Para criar a classe de file_reader

Adicione um novo arquivo de cabeçalho C++ ao seu projeto.Para fazer isso, clique com o botão direito do mouse no nó de Arquivos de Cabeçalho em Gerenciador de Soluções, clique Adicionar, clique em Novo Item.No painel de Modelos , **Arquivo de Cabeçalho (.h)**selecione.Na caixa de diálogo de Adicionar novo item , digite file_reader.h na caixa de Nome e clique em Adicionar.
Em file_reader.h, adicione o seguinte código.
```
#pragma once
```

Em file_reader.h, crie uma classe que é chamada file_reader que deriva de agent.

class file_reader : public concurrency::agent
{
public:
protected:
private:
};

Adicione os seguintes membros de dados à seção de private de sua classe.
```
std::string _file_name;
concurrency::ITarget<std::string>& _target;
concurrency::overwrite_buffer<std::exception> _error;
```
O membro de _file_name é o nome de arquivo que o agente ler.O membro de _target é um objeto de concurrency::ITarget que o agente grava o conteúdo do arquivo para.O membro de _error contém qualquer erro que ocorrer durante a vida do.

Adicione o seguinte código para os construtores de file_reader à seção de public da classe de file_reader .

explicit file_reader(const std::string& file_name, 
   concurrency::ITarget<std::string>& target)
   : _file_name(file_name)
   , _target(target)
{
}

explicit file_reader(const std::string& file_name, 
   concurrency::ITarget<std::string>& target,
   concurrency::Scheduler& scheduler)
   : agent(scheduler)
   , _file_name(file_name)
   , _target(target)
{
}

explicit file_reader(const std::string& file_name, 
   concurrency::ITarget<std::string>& target,
   concurrency::ScheduleGroup& group)
   : agent(group) 
   , _file_name(file_name)
   , _target(target)
{
}

Cada sobrecarga do construtor define os membros de dados de file_reader .A segunda e terceira sobrecarga de construtor permite que seu aplicativo para usar um agendador específico com o agente.A primeira sobrecarga usa o agendador padrão com o agente.

Adicione o método de get_error à seção da classe pública de file_reader .
```
bool get_error(std::exception& e)
{
   return try_receive(_error, e);
}
```
O método de get_error recupera qualquer erro que ocorrer durante a vida do.

Implementar o método de concurrency::agent::run na seção de protected de sua classe.

void run()
{
   FILE* stream;
   try
   {
      // Open the file.
      if (fopen_s(&stream, _file_name.c_str(), "r") != 0)
      {
         // Throw an exception if an error occurs.            
         throw std::exception("Failed to open input file.");
      }

      // Create a buffer to hold file data.
      char buf[1024];

      // Set the buffer size.
      setvbuf(stream, buf, _IOFBF, sizeof buf);

      // Read the contents of the file and send the contents
      // to the target.
      while (fgets(buf, sizeof buf, stream))
      {
         asend(_target, std::string(buf));
      }   

      // Send the empty string to the target to indicate the end of processing.
      asend(_target, std::string(""));

      // Close the file.
      fclose(stream);
   }
   catch (const std::exception& e)
   {
      // Send the empty string to the target to indicate the end of processing.
      asend(_target, std::string(""));

      // Write the exception to the error buffer.
      send(_error, e);
   }

   // Set the status of the agent to agent_done.
   done();
}

O método de run abre o arquivo e ler dados a partir dele.O método de run usa a manipulação de exceção para capturar erros que ocorrem durante o processamento de arquivo.

Cada vez que este método lê dados de arquivo, chama a função de concurrency::asend para enviar dados que o buffer de destino.Envia a cadeia de caracteres vazia ao buffer de destino para indicar o final do processamento.

O exemplo a seguir mostra o conteúdo completo de file_reader.h.

#pragma once

class file_reader : public concurrency::agent
{
public:
   explicit file_reader(const std::string& file_name, 
      concurrency::ITarget<std::string>& target)
      : _file_name(file_name)
      , _target(target)
   {
   }

   explicit file_reader(const std::string& file_name, 
      concurrency::ITarget<std::string>& target,
      concurrency::Scheduler& scheduler)
      : agent(scheduler)
      , _file_name(file_name)
      , _target(target)
   {
   }

   explicit file_reader(const std::string& file_name, 
      concurrency::ITarget<std::string>& target,
      concurrency::ScheduleGroup& group)
      : agent(group) 
      , _file_name(file_name)
      , _target(target)
   {
   }

   // Retrieves any error that occurs during the life of the agent.
   bool get_error(std::exception& e)
   {
      return try_receive(_error, e);
   }

protected:
   void run()
   {
      FILE* stream;
      try
      {
         // Open the file.
         if (fopen_s(&stream, _file_name.c_str(), "r") != 0)
         {
            // Throw an exception if an error occurs.            
            throw std::exception("Failed to open input file.");
         }

         // Create a buffer to hold file data.
         char buf[1024];

         // Set the buffer size.
         setvbuf(stream, buf, _IOFBF, sizeof buf);

         // Read the contents of the file and send the contents
         // to the target.
         while (fgets(buf, sizeof buf, stream))
         {
            asend(_target, std::string(buf));
         }   

         // Send the empty string to the target to indicate the end of processing.
         asend(_target, std::string(""));

         // Close the file.
         fclose(stream);
      }
      catch (const std::exception& e)
      {
         // Send the empty string to the target to indicate the end of processing.
         asend(_target, std::string(""));

         // Write the exception to the error buffer.
         send(_error, e);
      }

      // Set the status of the agent to agent_done.
      done();
   }

private:
   std::string _file_name;
   concurrency::ITarget<std::string>& _target;
   concurrency::overwrite_buffer<std::exception> _error;
};

Superior[]

Usando a classe de file_reader no aplicativo

Esta seção mostra como usar a classe de file_reader para ler o conteúdo de um arquivo de texto.Também mostra como criar um objeto de concurrency::call que receberá os dados do arquivo e calcula sua soma de verificação Adler-32.

Para usar o file_reader classe em seu aplicativo

Em BasicAgent.cpp, adicione a seguinte declaração de #include .
```
#include "file_reader.h"
```
Em BasicAgent.cpp, adicione as seguintes políticas de using .
```
using namespace concurrency;
using namespace std;
```
Na função de _tmain , crie um objeto de concurrency::event que sinais o final do processamento.
```
event e;
```

Crie um objeto de call que atualiza a soma de verificação quando receber dados.

// The components of the Adler-32 sum.
unsigned int a = 1;
unsigned int b = 0;

// A call object that updates the checksum when it receives data.
call<string> calculate_checksum([&] (string s) {
   // If the input string is empty, set the event to signal
   // the end of processing.
   if (s.size() == 0)
      e.set();
   // Perform the Adler-32 checksum algorithm.
   for_each(begin(s), end(s), [&] (char c) {
      a = (a + c) % 65521;
      b = (b + a) % 65521;
   });
});

Este objeto de call também define o objeto de event quando ele recebe a cadeia de caracteres vazia para sinalizar o final do processamento.

Crie um objeto de file_reader que ler do arquivo test.txt e gravar os conteúdos de aquele arquivo ao objeto de call .
```
file_reader reader("test.txt", calculate_checksum);
```
Inicie o agente e espere para concluir.
```
reader.start();
agent::wait(&reader);
```
Espere o objeto de call para receber os dados e para concluir.
```
e.wait();
```

Verifique o leitor de arquivo para erros.Se nenhum erro ocorreu, calcule a soma Adler-32 final e imprimir a soma no console.

std::exception error;
if (reader.get_error(error))
{
   wcout << error.what() << endl;
}   
else
{      
   unsigned int adler32_sum = (b << 16) | a;
   wcout << L"Adler-32 sum is " << hex << adler32_sum << endl;
}

O exemplo a seguir mostra o arquivo completo de BasicAgent.cpp.

// BasicAgent.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "file_reader.h"

using namespace concurrency;
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
   // An event object that signals the end of processing.
   event e;

   // The components of the Adler-32 sum.
   unsigned int a = 1;
   unsigned int b = 0;

   // A call object that updates the checksum when it receives data.
   call<string> calculate_checksum([&] (string s) {
      // If the input string is empty, set the event to signal
      // the end of processing.
      if (s.size() == 0)
         e.set();
      // Perform the Adler-32 checksum algorithm.
      for_each(begin(s), end(s), [&] (char c) {
         a = (a + c) % 65521;
         b = (b + a) % 65521;
      });
   });

   // Create the agent.
   file_reader reader("test.txt", calculate_checksum);

   // Start the agent and wait for it to complete.
   reader.start();
   agent::wait(&reader);

   // Wait for the call object to receive all data and complete.
   e.wait();

   // Check the file reader for errors.
   // If no error occurred, calculate the final Adler-32 sum and print it 
   // to the console.
   std::exception error;
   if (reader.get_error(error))
   {
      wcout << error.what() << endl;
   }   
   else
   {      
      unsigned int adler32_sum = (b << 16) | a;
      wcout << L"Adler-32 sum is " << hex << adler32_sum << endl;
   }
}

Superior[]

Entrada de exemplo

Este é o conteúdo do exemplo de arquivo de entrada text.txt:

A saída de exemplo

Quando usado com a entrada do programa, este exemplo produz a saída a seguir:

Programação robusta

Para evitar membros simultâneas de acesso a dados, nós recomendamos que você adicione métodos que executam o trabalho à seção de protected ou de private de sua classe.Adicione somente os métodos que envia ou recebem mensagens para ou do agente à seção de public de sua classe.

Sempre chamar o método de concurrency::agent::done para mover o agente ao estado concluído.Normalmente você chama esse método antes que você retorna o método de run .