Partilhar via

Tutorial: Tutorial REST do Azure WCF Relay

  • Artigo

Este tutorial descreve como criar um aplicativo host do Azure Relay que expõe uma interface baseada em REST. O REST permite que um cliente web, como um navegador, aceda às APIs do Service Bus através de pedidos de HTTP.

O tutorial usa o modelo de programação REST do Windows Communication Foundation (WCF) para construir um serviço REST no Azure Relay. Para obter mais informações, consulte Modelo de programação REST do WCF e Projetando e implementando serviços.

Você executa as seguintes tarefas neste tutorial:

  • Instale os pré-requisitos para este tutorial.
  • Crie um namespace de retransmissão.
  • Defina um contrato de serviço WCF baseado em REST.
  • Implemente o contrato WCF baseado em REST.
  • Hospede e execute o serviço WCF baseado em REST.
  • Execute e teste o serviço.

Pré-requisitos

Para concluir este tutorial, precisa dos seguintes pré-requisitos:

Criar um namespace de retransmissão

Para começar a utilizar as funcionalidades do reencaminhamento no Azure, deve criar, em primeiro lugar, um espaço de nomes de serviço. Um espaço de nomes fornece um contentor de âmbito para abordar os recursos do Azure na sua aplicação. Siga as instruções aqui para criar um espaço de nomes de Reencaminhamento.

Definir um contrato de serviço WCF baseado em REST para usar com o Azure Relay

Ao criar um serviço no estilo WCF REST, você deve definir o contrato. O contrato especifica quais as operações suportadas pelo anfitrião. Uma operação de serviço se assemelha a um método de serviço Web. Defina um contrato com uma interface C++, C# ou Visual Basic. Cada método da interface corresponde a uma operação de serviço específica. Aplique o atributo ServiceContractAttribute a cada interface e aplique o atributo OperationContractAttribute a cada operação.

Gorjeta

Se um método em uma interface que tem o ServiceContractAttribute não tem o OperationContractAttribute, esse método não é exposto. O código usado para essas tarefas aparece no exemplo a seguir ao procedimento.

A principal diferença entre um contrato WCF e um contrato no estilo REST é a adição de uma propriedade ao OperationContractAttribute: WebGetAttribute. Esta propriedade permite-lhe mapear um método na sua interface para um método no outro lado da interface. Este exemplo usa o atributo WebGetAttribute para vincular um método a HTTP GET. Essa abordagem permite que o Service Bus recupere e interprete com precisão os comandos enviados para a interface.

Para criar um contrato com uma interface

  1. Inicie o Microsoft Visual Studio como administrador. Para fazer isso, clique com o botão direito do mouse no ícone do programa Visual Studio e selecione Executar como administrador.

  2. No Visual Studio, selecione Criar um novo projeto.

  3. Em Criar um novo projeto, escolha Aplicativo de Console (.NET Framework) para C# e selecione Avançar.

  4. Nomeie o projeto como ImageListener. Use o Local padrão e selecione Criar.

    Para um projeto C#, o Visual Studio cria um arquivo Program.cs . Esta classe contém método Main() vazio, necessário para que um projeto de aplicação de consola seja criado corretamente.

  5. No Gerenciador de Soluções, clique com o botão direito do mouse no projeto ImageListener e selecione Gerenciar Pacotes NuGet.

  6. Selecione Procurar, procure e escolha WindowsAzure.ServiceBus. Selecione Instalar e aceite os termos de uso.

    Esta etapa adiciona referências ao Service Bus e ao System.ServiceModel.dll. Este pacote adiciona automaticamente referências às bibliotecas do Service Bus e ao WCF System.ServiceModel.

  7. Adicione explicitamente uma referência ao System.ServiceModel.Web.dll projeto. No Gerenciador de Soluções, clique com o botão direito do mouse em Referências na pasta do projeto e selecione Adicionar Referência.

  8. Em Adicionar Referência, selecione Framework e digite System.ServiceModel.Web em Pesquisar. Marque a caixa de seleção System.ServiceModel.Web e selecione OK.

Em seguida, faça as seguintes alterações de código no projeto:

  1. Adicione as seguintes using instruções na parte superior do arquivo Program.cs .

    using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Web;
using System.IO;
    • System.ServiceModel é o espaço de nomes que permite o acesso através de programação a funcionalidades básicas do WCF. WCF Relay usa muitos dos objetos e atributos do WCF para definir contratos de serviço. Você usa esse namespace na maioria dos seus aplicativos de retransmissão.
    • System.ServiceModel.Channels ajuda a definir o canal, que é o objeto através do qual você se comunica com o Azure Relay e o navegador da Web do cliente.
    • System.ServiceModel.Web contém os tipos que permitem criar aplicativos baseados na Web.

  2. Renomeie o ImageListener namespace para Microsoft.ServiceBus.Samples.

    namespace Microsoft.ServiceBus.Samples
{
    ...

  3. Diretamente após a chave de abertura da declaração de namespace, defina uma nova interface chamada IImageContract e aplique o ServiceContractAttribute atributo à interface com um valor de https://samples.microsoft.com/ServiceModel/Relay/RESTTutorial1.

    [ServiceContract(Name = "ImageContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/RESTTutorial1")]
public interface IImageContract
{
}

    O valor do espaço de nomes difere do espaço de nomes que utiliza em todo o âmbito do seu código. O valor do namespace é um identificador exclusivo para este contrato e deve ter informações de versão. Para obter mais informações, consulte o artigo Controlo de Versões do Serviço. A especificação explícita do espaço de nomes impede que o valor de espaço de nomes predefinido seja adicionado ao nome do contrato.

  4. IImageContract Na interface, declare um método para a operação única que o IImageContract contrato expõe na interface e aplique o OperationContract atributo ao método que você deseja expor como parte do contrato público do Service Bus.

    public interface IImageContract
{
    [OperationContract]
    Stream GetImage();
}

  5. OperationContract No atributo, adicione o WebGet valor.

    public interface IImageContract
{
    [OperationContract, WebGet]
    Stream GetImage();
}

    A adição do WebGet valor permite que o serviço de retransmissão roteie solicitações HTTP GET para GetImagee converta os valores de retorno de GetImage em uma HTTP GETRESPONSE resposta. Mais adiante no tutorial, você usará um navegador da Web para acessar esse método e exibir a imagem no navegador.

  6. Imediatamente depois da definiçãoIImageContract, declare um canal que herde das interfaces IImageContract e IClientChannel.

    public interface IImageChannel : IImageContract, IClientChannel { }

    Um canal é o objeto de WCF através do qual o serviço e o cliente passam informações entre si. Mais tarde, você cria o canal em seu aplicativo host. Em seguida, o Azure Relay usa esse canal para passar as solicitações HTTP GET do navegador para sua GetImage implementação. O relé também usa o canal para pegar o valor de GetImage retorno e traduzi-lo em um HTTP GETRESPONSE para o navegador do cliente.

  7. Selecione Build>Build Solution para confirmar a precisão do seu trabalho até agora.

Exemplo que define um contrato de retransmissão WCF

O código a seguir mostra uma interface básica que define um contrato de retransmissão WCF.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Web;
using System.IO;

namespace Microsoft.ServiceBus.Samples
{

    [ServiceContract(Name = "IImageContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
    public interface IImageContract
    {
        [OperationContract, WebGet]
        Stream GetImage();
    }

    public interface IImageChannel : IImageContract, IClientChannel { }

    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}

Implementar o contrato de serviço WCF baseado em REST

Para criar um serviço WCF Relay no estilo REST, primeiro crie o contrato usando uma interface. O passo seguinte consiste em implementar a interface. Este procedimento envolve a criação de uma classe chamada ImageService que implementa a interface definida IImageContract pelo usuário. Depois de implementar o contrato, configure a interface usando um arquivo App.config . O arquivo de configuração contém as informações necessárias para o aplicativo. Essas informações incluem o nome do serviço, o nome do contrato e o tipo de protocolo usado para se comunicar com o serviço de retransmissão. O código usado para essas tarefas aparece no exemplo a seguir ao procedimento.

Como nas etapas anteriores, há pouca diferença entre implementar um contrato no estilo REST e um contrato WCF Relay.

Para implementar um contrato do Service Bus de estilo REST

  1. Criar uma nova classe com o nome ImageService imediatamente depois da definição da interface IImageContract. A classe ImageService implementa a interface IImageContract.

    class ImageService : IImageContract
{
}

    Tal como noutras implementações de interface, pode implementar a definição num ficheiro diferente. No entanto, neste tutorial, a implementação aparece no mesmo ficheiro que a definição de interface e o métodoMain().

  2. Aplique o atributo ServiceBehaviorAttribute à IImageService classe para indicar que a classe é uma implementação de um contrato WCF.

    [ServiceBehavior(Name = "ImageService", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
class ImageService : IImageContract
{
}

    Como mencionado anteriormente, esse namespace não é um namespace tradicional. É parte da arquitetura WCF que identifica o contrato. Para obter mais informações, consulte os Nomes de contratos de dados.

  3. Adicione uma imagem .jpg ao seu projeto. Este arquivo é uma imagem que o serviço exibe no navegador de recebimento.

    1. Clique com o botão direito do mouse no projeto e selecione Adicionar.
    2. Em seguida, selecione Item existente.
    3. Use Adicionar Item Existente para procurar um .jpg apropriado e selecione Adicionar. Ao adicionar o arquivo, selecione Todos os arquivos na lista suspensa ao lado de Nome do arquivo.

    O restante deste tutorial pressupõe que o nome da imagem é image.jpg. Se você tiver um arquivo diferente, deverá renomear a imagem ou alterar o código para compensar.

  4. Para certificar-se de que o serviço em execução pode encontrar o arquivo de imagem, no Gerenciador de Soluções, clique com o botão direito do mouse no arquivo de imagem e escolha Propriedades. Em Propriedades, defina Copiar para Diretório de Saída como Copiar se for mais recente.

  5. Use o procedimento em Para criar um contrato com uma interface para adicionar uma referência ao assembly System.Drawing.dll ao projeto.

  6. Adicione as seguintes instruções associadas using :

    using System.Drawing;
using System.Drawing.Imaging;
using Microsoft.ServiceBus;
using Microsoft.ServiceBus.Web;

  7. ImageService Na classe, adicione o seguinte construtor que carrega o bitmap e se prepara para enviá-lo para o navegador cliente:

    class ImageService : IImageContract
{
    const string imageFileName = "image.jpg";

    Image bitmap;

    public ImageService()
    {
        this.bitmap = Image.FromFile(imageFileName);
    }
}

  8. Diretamente após o código anterior, adicione o ImageService seguinte GetImage método na classe para retornar uma mensagem HTTP que contém a imagem.

    public Stream GetImage()
{
    MemoryStream stream = new MemoryStream();
    this.bitmap.Save(stream, ImageFormat.Jpeg);

    stream.Position = 0;
    WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";

    return stream;
}

    Esta implementação usa MemoryStream para recuperar a imagem e prepará-la para streaming para o navegador. Ele inicia a posição do fluxo em zero, declara o conteúdo do fluxo como um .jpg e transmite as informações.

  9. Selecione Build Build Solution (Criar>solução de compilação).

Para definir a configuração para executar o serviço Web no Service Bus

  1. No Gerenciador de Soluções, clique duas vezes em App.config para abrir o arquivo no editor do Visual Studio.

    O arquivo App.config inclui o nome do serviço, o ponto de extremidade e a ligação. O ponto de extremidade é o local que o Azure Relay expõe para que clientes e hosts se comuniquem entre si. A ligação é o tipo de protocolo usado para se comunicar. A principal diferença aqui é que o ponto de extremidade de serviço configurado refere-se a uma ligação WebHttpRelayBinding .

  2. O elemento XML <system.serviceModel> é um elemento de WCF que define um ou vários serviços. Aqui, ele é usado para definir o nome do serviço e o ponto de extremidade. Na parte inferior do <system.serviceModel> elemento, mas ainda dentro <system.serviceModel>de , adicione um <bindings> elemento que tenha o seguinte conteúdo:

    <bindings>
    <!-- Application Binding -->
    <webHttpRelayBinding>
        <binding name="default">
            <security relayClientAuthenticationType="None" />
        </binding>
    </webHttpRelayBinding>
</bindings>

    Este conteúdo define as associações usadas no aplicativo. Você pode definir várias associações, mas para este tutorial você está definindo apenas uma.

    O código anterior define uma ligação WCF Relay WebHttpRelayBinding com relayClientAuthenticationType definido como None. Essa configuração indica que um ponto de extremidade usando essa associação não requer uma credencial de cliente.

  3. Depois do elemento <bindings>, adicione um elemento <services>. Assim como nos enlaces, pode definir vários serviços num único ficheiro de configuração. No entanto, neste tutorial, definirá apenas um.

    <services>
    <!-- Application Service -->
    <service name="Microsoft.ServiceBus.Samples.ImageService"
         behaviorConfiguration="default">
        <endpoint name="RelayEndpoint"
                contract="Microsoft.ServiceBus.Samples.IImageContract"
                binding="webHttpRelayBinding"
                bindingConfiguration="default"
                behaviorConfiguration="sbTokenProvider"
                address="" />
    </service>
</services>

    Esse conteúdo configura um serviço que usa o padrão webHttpRelayBindingdefinido anteriormente. Ele também usa o padrão sbTokenProvider, que é definido na próxima etapa.

  4. Após o <services> elemento , crie um <behaviors> elemento com o seguinte conteúdo, substituindo SAS_KEY pela chave SAS (Assinatura de Acesso Compartilhado). Para obter uma chave SAS do portal do Azure, consulte Obter credenciais de gerenciamento.

    <behaviors>
    <endpointBehaviors>
        <behavior name="sbTokenProvider">
            <transportClientEndpointBehavior>
                <tokenProvider>
                    <sharedAccessSignature keyName="RootManageSharedAccessKey" key="YOUR_SAS_KEY" />
                </tokenProvider>
            </transportClientEndpointBehavior>
        </behavior>
        </endpointBehaviors>
        <serviceBehaviors>
            <behavior name="default">
                <serviceDebug httpHelpPageEnabled="false" httpsHelpPageEnabled="false" />
            </behavior>
        </serviceBehaviors>
</behaviors>

  5. Ainda em App.config, no elemento , substitua <appSettings> todo o valor da cadeia de conexão pela cadeia de conexão obtida anteriormente do portal.

    <appSettings>
   <!-- Service Bus specific app settings for messaging connections -->
   <add key="Microsoft.ServiceBus.ConnectionString"
       value="Endpoint=sb://yourNamespace.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=YOUR_SAS_KEY"/>
</appSettings>

  6. Selecione Build>Build Solution para criar a solução inteira.

Exemplo que implementa o contrato de serviço WCF baseado em REST

O código a seguir mostra o contrato e a implementação de serviço para um serviço baseado em REST que está sendo executado no Service Bus usando a WebHttpRelayBinding associação.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Web;
using System.IO;
using System.Drawing;
using System.Drawing.Imaging;
using Microsoft.ServiceBus;
using Microsoft.ServiceBus.Web;

namespace Microsoft.ServiceBus.Samples
{


    [ServiceContract(Name = "ImageContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
    public interface IImageContract
    {
        [OperationContract, WebGet]
        Stream GetImage();
    }

    public interface IImageChannel : IImageContract, IClientChannel { }

    [ServiceBehavior(Name = "ImageService", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
    class ImageService : IImageContract
    {
        const string imageFileName = "image.jpg";

        Image bitmap;

        public ImageService()
        {
            this.bitmap = Image.FromFile(imageFileName);
        }

        public Stream GetImage()
        {
            MemoryStream stream = new MemoryStream();
            this.bitmap.Save(stream, ImageFormat.Jpeg);

            stream.Position = 0;
            WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";

            return stream;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}

O exemplo a seguir mostra o arquivo App.config associado ao serviço.

<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2"/>
    </startup>
    <system.serviceModel>
        <extensions>
            <!-- In this extension section we are introducing all known service bus extensions. User can remove the ones they don't need. -->
            <behaviorExtensions>
                <add name="connectionStatusBehavior"
                    type="Microsoft.ServiceBus.Configuration.ConnectionStatusElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
                <add name="transportClientEndpointBehavior"
                    type="Microsoft.ServiceBus.Configuration.TransportClientEndpointBehaviorElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
                <add name="serviceRegistrySettings"
                    type="Microsoft.ServiceBus.Configuration.ServiceRegistrySettingsElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
            </behaviorExtensions>
            <bindingElementExtensions>
                <add name="netMessagingTransport"
                    type="Microsoft.ServiceBus.Messaging.Configuration.NetMessagingTransportExtensionElement, Microsoft.ServiceBus,  Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
                <add name="tcpRelayTransport"
                    type="Microsoft.ServiceBus.Configuration.TcpRelayTransportElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
                <add name="httpRelayTransport"
                    type="Microsoft.ServiceBus.Configuration.HttpRelayTransportElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
                <add name="httpsRelayTransport"
                    type="Microsoft.ServiceBus.Configuration.HttpsRelayTransportElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
                <add name="onewayRelayTransport"
                    type="Microsoft.ServiceBus.Configuration.RelayedOnewayTransportElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
            </bindingElementExtensions>
            <bindingExtensions>
                <add name="basicHttpRelayBinding"
                    type="Microsoft.ServiceBus.Configuration.BasicHttpRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
                <add name="webHttpRelayBinding"
                    type="Microsoft.ServiceBus.Configuration.WebHttpRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
                <add name="ws2007HttpRelayBinding"
                    type="Microsoft.ServiceBus.Configuration.WS2007HttpRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
                <add name="netTcpRelayBinding"
                    type="Microsoft.ServiceBus.Configuration.NetTcpRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
                <add name="netOnewayRelayBinding"
                    type="Microsoft.ServiceBus.Configuration.NetOnewayRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
                <add name="netEventRelayBinding"
                    type="Microsoft.ServiceBus.Configuration.NetEventRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
                <add name="netMessagingBinding"
                    type="Microsoft.ServiceBus.Messaging.Configuration.NetMessagingBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
            </bindingExtensions>
        </extensions>
      <bindings>
        <!-- Application Binding -->
        <webHttpRelayBinding>
          <binding name="default">
            <security relayClientAuthenticationType="None" />
          </binding>
        </webHttpRelayBinding>
      </bindings>
      <services>
        <!-- Application Service -->
        <service name="Microsoft.ServiceBus.Samples.ImageService"
             behaviorConfiguration="default">
          <endpoint name="RelayEndpoint"
                  contract="Microsoft.ServiceBus.Samples.IImageContract"
                  binding="webHttpRelayBinding"
                  bindingConfiguration="default"
                  behaviorConfiguration="sbTokenProvider"
                  address="" />
        </service>
      </services>
      <behaviors>
        <endpointBehaviors>
          <behavior name="sbTokenProvider">
            <transportClientEndpointBehavior>
              <tokenProvider>
                <sharedAccessSignature keyName="RootManageSharedAccessKey" key="YOUR_SAS_KEY" />
              </tokenProvider>
            </transportClientEndpointBehavior>
          </behavior>
        </endpointBehaviors>
        <serviceBehaviors>
          <behavior name="default">
            <serviceDebug httpHelpPageEnabled="false" httpsHelpPageEnabled="false" />
          </behavior>
        </serviceBehaviors>
      </behaviors>
    </system.serviceModel>
    <appSettings>
        <!-- Service Bus specific app settings for messaging connections -->
        <add key="Microsoft.ServiceBus.ConnectionString"
            value="Endpoint=sb://yourNamespace.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=YOUR_SAS_KEY>"/>
    </appSettings>
</configuration>

Hospedar o serviço WCF baseado em REST para usar o Azure Relay

Esta seção descreve como executar um serviço Web usando um aplicativo de console com WCF Relay. Uma lista completa do código escrito nesta seção aparece no exemplo a seguir ao procedimento.

Para criar um endereço base para o serviço

  1. Main() Na declaração de função, crie uma variável para armazenar o namespace do seu projeto. Certifique-se de substituir yourNamespace pelo nome do namespace Relay criado anteriormente.

    string serviceNamespace = "yourNamespace";

    O Service Bus utiliza o nome do seu espaço de nomes para criar um URI exclusivo.

  2. Crie uma instância Uri para o endereço base do serviço que se baseia no espaço de nomes.

    Uri address = ServiceBusEnvironment.CreateServiceUri("https", serviceNamespace, "Image");

Para criar e configurar o anfitrião do serviço Web

Ainda no Main(), crie o host do serviço Web, usando o endereço URI criado anteriormente nesta seção.

WebServiceHost host = new WebServiceHost(typeof(ImageService), address);

O anfitrião do serviço é o objeto de WCF que cria uma instância na aplicação anfitriã. Este exemplo passa o tipo de host que você deseja criar, que é um ImageService, e também o endereço no qual você deseja expor o aplicativo host.

Para executar o anfitrião do serviço Web

  1. Ainda no Main(), adicione a seguinte linha para abrir o serviço.

    host.Open();

    O serviço está agora em execução.

  2. Apresente uma mensagem que indique que o serviço está em execução e como pará-lo.

    Console.WriteLine("Copy the following address into a browser to see the image: ");
Console.WriteLine(address + "GetImage");
Console.WriteLine();
Console.WriteLine("Press [Enter] to exit");
Console.ReadLine();

  3. Quando terminar, feche o serviço anfitrião.

    host.Close();

Exemplo de contrato de prestação de serviços e execução

O exemplo seguinte inclui o contrato de serviço e de implementação dos passos anteriores no tutorial e aloja o serviço numa aplicação de consola. Compile o código a seguir em um executável chamado ImageListener.exe.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Web;
using System.IO;
using System.Drawing;
using System.Drawing.Imaging;
using Microsoft.ServiceBus;
using Microsoft.ServiceBus.Web;

namespace Microsoft.ServiceBus.Samples
{

    [ServiceContract(Name = "ImageContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
    public interface IImageContract
    {
        [OperationContract, WebGet]
        Stream GetImage();
    }

    public interface IImageChannel : IImageContract, IClientChannel { }

    [ServiceBehavior(Name = "ImageService", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
    class ImageService : IImageContract
    {
        const string imageFileName = "image.jpg";

        Image bitmap;

        public ImageService()
        {
            this.bitmap = Image.FromFile(imageFileName);
        }

        public Stream GetImage()
        {
            MemoryStream stream = new MemoryStream();
            this.bitmap.Save(stream, ImageFormat.Jpeg);

            stream.Position = 0;
            WebOperationContext.Current.OutgoingResponse.ContentType = "image/jpeg";

            return stream;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            string serviceNamespace = "InsertServiceNamespaceHere";
            Uri address = ServiceBusEnvironment.CreateServiceUri("https", serviceNamespace, "Image");

            WebServiceHost host = new WebServiceHost(typeof(ImageService), address);
            host.Open();

            Console.WriteLine("Copy the following address into a browser to see the image: ");
            Console.WriteLine(address + "GetImage");
            Console.WriteLine();
            Console.WriteLine("Press [Enter] to exit");
            Console.ReadLine();

            host.Close();
        }
    }
}

Executar e testar o serviço

Depois de compilar a solução, faça o seguinte procedimento para executar a aplicação:

  1. Selecione F5 ou navegue até o local do arquivo executável, ImageListener\bin\Debug\ImageListener.exe, para executar o serviço. Mantenha o aplicativo em execução, porque ele é necessário para a próxima etapa.
  2. Copie e cole o endereço a partir da linha de comandos para um navegador para ver a imagem.
  3. Quando terminar, selecione Enter na janela do prompt de comando para fechar o aplicativo.

Conteúdos relacionados

Agora que você criou um aplicativo que usa o serviço de Retransmissão do Azure, consulte os seguintes artigos para saber mais: