Como: Usar o transporte HTTP

Artigo
08/25/2010

Você pode usar o transporte HTTP para criar aplicativos em um dispositivo que se conectará a um Windows Communication Foundation (WCF) serviço na área de trabalho.

Este tópico descreve como configurar o serviço do WCF para lidar com dispositivos de conexão e como criar o aplicativo cliente.Ela explica as diferenças na configuração do serviço WCF e codificação do lado do cliente que você deve considerar para permitir que dispositivos móveis se conectar ao serviço.Para obter informações adicionais sobre como criar aplicativos WCF para a área de trabalho, consulte o Getting Started Tutorial na documentação do WCF.

Para criar o serviço WCF para a área de trabalho

Crie um novo projeto de serviço Web.

Modificar o arquivo Web.config sistema autônomo mostrado no exemplo a seguir.Modificar os elementos e atributos do seguinte:

Change the <endpoint>binding attribute value to "basicHttpBinding".The .NET Compact Framework oferece suporte à codificação de texto, mas a codificação binária não.
Alterar o behaviorConfiguration atributo para referir-se o nome do novo comportamento.
Substitua o <behavior> sistema autônomo mostra o exemplo do elemento.
Se você precisar registrar o manipulador de serviço HTTP no arquivo Web.config, adicione um novo <system.WebServer> elemento com as informações mostradas no exemplo.

<?xml version="1.0"?>

<configuration xmlns="https://schemas.microsoft.com/.NetConfiguration/v2.0">
  <system.serviceModel>
    <services>
      <service name="CalculatorService" behaviorConfiguration="MyServiceTypeBehaviors">
        <endpoint contract="ICalculatorService" binding="basicHttpBinding"/>
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="MyServiceTypeBehaviors">
          <serviceMetadata httpGetEnabled="true" />
          <serviceDebug httpHelpPageEnabled="true" includeExceptionDetailInFaults="true" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>

  <system.web>
    <compilation debug="true"/>
  </system.web>

  <system.webServer>
    <handlers>
      <add name="HttpSvcHandler" path="*.svc" verb="*" type="System.ServiceModel.Activation.HttpHandler, System.ServiceModel, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" resourceType="Unspecified" />
    </handlers>
  </system.webServer>

</configuration>

No código fonte para o serviço WCF, remova os parâmetros especificados no ServiceContract e OperationContract atributos do seu código.

Observação:
Th exemplo de não faz implementar suporte Para parâmetros especificados em contratos tais Como ServiceContract e OperationContract.Se você precisar de suporte ao parâmetro para esses contratos, você pode usar o WCF .NET Compact Framework Ferramenta Utilitário de ServiceModel (NetCFSvcUtil.exe) para gerar o código do cliente. Essa ferramenta cria o suporte para muitos desses parâmetros em aplicativos que sejam baseiam o .NET Compact Framework. NetCFSvcUtil.exe está disponível no potência Toys para .NET Compact Framework. Para obter mais informações, consulte potência Toys para o .NET Compact estrutura.

Th exemplo de não faz implementar suporte Para parâmetros especificados em contratos tais Como ServiceContract e OperationContract.Se você precisar de suporte ao parâmetro para esses contratos, você pode usar o WCF .NET Compact Framework Ferramenta Utilitário de ServiceModel (NetCFSvcUtil.exe) para gerar o código do cliente. Essa ferramenta cria o suporte para muitos desses parâmetros em aplicativos que sejam baseiam o .NET Compact Framework. NetCFSvcUtil.exe está disponível no potência Toys para .NET Compact Framework. Para obter mais informações, consulte potência Toys para o .NET Compact estrutura.

O exemplo a seguir mostra o código de fonte do serviço WCF para um aplicativo de calculadora simplificada.

<ServiceContract()>  _
Public Interface ICalculatorService
    <OperationContract()>  _
    Function Add(ByVal n1 As Double, ByVal n2 As Double) As Double 
    '<OperationContract()>  _
    Function Subtract(ByVal n1 As Double, ByVal n2 As Double) As Double
End Interface


Public Class CalculatorService
    Implements ICalculatorService

    Public Function Add(ByVal n1 As Double, ByVal n2 As Double) As Double Implements ICalculatorService.Add
        Return n1 + n2

    End Function

    Public Function Subtract(ByVal n1 As Double, ByVal n2 As Double) As Double Implements ICalculatorService.Subtract
        Return n1 - n2

    End Function
End Class

[ServiceContract()]
public interface ICalculatorService
{
    [OperationContract]
    double Add(double n1, double n2);
    [OperationContract]
    double Subtract(double n1, double n2);
}

public class CalculatorService : ICalculatorService
{
    public double Add(double n1, double n2) { return n1 + n2; }
    public double Subtract(double n1, double n2) { return n1 - n2; }
}

conjunto o serviço do WCF para uma porta específica em seu servidor Web.

Use qualquer número da porta entre 10000 e 650000.Este exemplo usa a porta 50505.
Inicie o servidor Web.

Se você deseja exibir a saída de WSDL (linguagem WSDL) e executar o serviço no host local, navegue até https://localhost:50505/CalculatorService/Service.svc?wsdl.Use o mesmo número da porta e nome do projeto Web que você especificou para o serviço do WCF.

Se você pretende se conectar ao servidor Web a partir de um computador remoto ou dispositivo, conjunto até um diretório virtual para apontar para o diretório que contém o projeto Web.

Observação:
T Ele ASP.NET Development Server Em Visual Studio Responda somente às solicitações da sua computador de desenvolvimento local. Recomendamos que use o Serviços de Informações da Internet (Serviços de Informações da Internet) para especificar um diretório virtual.Isso permite que você se conecte ao servidor Web de um dispositivo remoto sistema autônomo longo sistema autônomo o servidor está acessível.

T Ele ASP.NET Development Server Em Visual Studio Responda somente às solicitações da sua computador de desenvolvimento local. Recomendamos que use o Serviços de Informações da Internet (Serviços de Informações da Internet) para especificar um diretório virtual.Isso permite que você se conecte ao servidor Web de um dispositivo remoto sistema autônomo longo sistema autônomo o servidor está acessível.

Verifique se que você pode acessar o diretório de um navegador área de trabalho e um navegador de dispositivo.

Para criar o cliente .NET Compact estrutura

Enquanto o serviço está em execução, abra uma linha de comando e navegar até o diretório onde se encontra o serviço do WCF.

Da linha de comando, execute a ferramenta Utilitário de área de trabalho de ServiceModel WCF (SvcUtil.exe) para gerar um proxy de cliente do WCF.Eis um exemplo da invocação da linha de comando do SvcUtil em que o serviço está hospedado em localhost:

svcutil.exe /language:c# https://localhost:50505/CalculatorService/Service.svc

O exemplo a seguir mostra um proxy de cliente gerado pelo SvcUtil baseado no exemplo a calculadora simples.

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:2.0.50727.42
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------



[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
[System.ServiceModel.ServiceContractAttribute(ConfigurationName="ICalculatorService")]
public interface ICalculatorService
{

    [System.ServiceModel.OperationContractAttribute(Action="https://fabrikam.com/ICalculatorService/Add", ReplyAction="https://fabrikam.com/ICalculatorService/AddResponse")]
    double Add(double n1, double n2);

    [System.ServiceModel.OperationContractAttribute(Action="https://fabrikam.com/ICalculatorService/Subtract", ReplyAction="https://fabrikam.com/ICalculatorService/SubtractResponse")]
    double Subtract(double n1, double n2);
}

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
public interface ICalculatorServiceChannel : ICalculatorService, System.ServiceModel.IClientChannel
{
}

[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
public partial class CalculatorServiceClient : System.ServiceModel.ClientBase<ICalculatorService>, ICalculatorService
{

    public CalculatorServiceClient()
    {
    }

    public CalculatorServiceClient(string endpointConfigurationName) : 
            base(endpointConfigurationName)
    {
    }

    public CalculatorServiceClient(string endpointConfigurationName, string remoteAddress) : 
            base(endpointConfigurationName, remoteAddress)
    {
    }

    public CalculatorServiceClient(string endpointConfigurationName, System.ServiceModel.EndpointAddress remoteAddress) : 
            base(endpointConfigurationName, remoteAddress)
    {
    }

    public CalculatorServiceClient(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress) : 
            base(binding, remoteAddress)
    {
    }

    public double Add(double n1, double n2)
    {
        return base.Channel.Add(n1, n2);
    }

    public double Subtract(double n1, double n2)
    {
        return base.Channel.Subtract(n1, n2);
    }
}

Remova elementos e atributos não suportados do código de proxy gerados do cliente, incluindo o seguinte:

All System.ServiceModel atributos.
Referências à IClientChannel classe.
Referências a <endpoint> nomes de configuração.
Implementações de método que telefonar métodos do ServiceContract interface de canal internos.

O exemplo a seguir mostra o código após essas modificações.

'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:2.0.50727.312
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On



Public Interface ICalculatorService

    Function Add(ByVal n1 As Double, ByVal n2 As Double) As Double

    Function Subtract(ByVal n1 As Double, ByVal n2 As Double) As Double
End Interface

Partial Public Class CalculatorServiceClient
    Inherits System.ServiceModel.ClientBase(Of ICalculatorService)
    Implements ICalculatorService

    ' Add a variable containing the endpoint address.
    Public Shared ServiceEndPoint As New System.ServiceModel.EndpointAddress("https://fabrikam.com/CalcService/CalculatorService/Service.svc")

    Public Sub New(ByVal binding As System.ServiceModel.Channels.Binding, ByVal remoteAddress As System.ServiceModel.EndpointAddress)
        MyBase.New(binding, remoteAddress)
    End Sub

    Public Function Add(ByVal n1 As Double, ByVal n2 As Double) As Double Implements ICalculatorService.Add
        Return MyBase.Channel.Add(n1, n2)
    End Function

    Public Function Subtract(ByVal n1 As Double, ByVal n2 As Double) As Double Implements ICalculatorService.Subtract
        Return MyBase.Channel.Subtract(n1, n2)
    End Function
End Class

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:2.0.50727.42
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------


public interface ICalculatorService
{

    double Add(double n1, double n2);

    double Subtract(double n1, double n2);
}

public partial class CalculatorServiceClient : System.ServiceModel.ClientBase<ICalculatorService>, ICalculatorService
{

    // Add a variable to specify the server address.
    public static System.ServiceModel.EndpointAddress ServiceEndPoint = new System.ServiceModel.EndpointAddress("https://fabrikam.com/CalcService/CalculatorService/Service.svc");

    public CalculatorServiceClient(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress) : 
            base(binding, remoteAddress)
    {
    }

    public double Add(double n1, double n2)
    {
        return base.Channel.Add(n1, n2);
    }

    public double Subtract(double n1, double n2)
    {
        return base.Channel.Subtract(n1, n2);
    }
}

Crie um projeto de cliente.
Adicione o proxy de cliente gerada para o projeto.
No código proxy gerado, alterar a referência totalmente qualificado de ClientBase<TChannel> definido o usuário ClientBase classe.

No código proxy gerado, adicione implementações do método invocando o Call método em definido do usuário ClientBase classe.

Public Function Add(ByVal n1 As Double, ByVal n2 As Double) As Double Implements ICalculatorService.Add
    Return System.Convert.ToDouble(MyBase.Call("Add", "https://fabrikam.com/CalcService/ICalculatorService/Add", New String() {"n1", "n2"}, New Object() {n1, n2}, GetType(Double)))
End Function

public double Add(double n1, double n2)
{
    return (double)base.Call("Add", "https://fabrikam.com/CalcService/ICalculatorService/Add", new string[] { "n1", "n2" }, new object[] { n1, n2 }, typeof(double));
}

Adicione a classe base para o proxy para o projeto.Essa classe é nomeada ClientBase.

Altere a referência da classe base de seu proxy de cliente para apontar para sua implementação de ClientBase.

Observação:
Neste exemplo , o CustomBodyWriter classe na ClientBase oferece suporte somente tipos primitivos. Para oferecer suporte a tipos de não-primitivo, é necessário estender o OnWriteBodyContents método. Por exemplo, você poderia chamar um serializador personalizado para serializar os dados da mensagem.Nesse caso, você poderia traduzir código atributos no proxy do cliente gerado atributos que pode consumir o serializador do XML.Nesse cenário, primeiro você deve adicionar a seguinte comutador quando você executa o SvcUtil: /serializer:xmlserializer http://ponto de extremidade.

Neste exemplo , o CustomBodyWriter classe na ClientBase oferece suporte somente tipos primitivos. Para oferecer suporte a tipos de não-primitivo, é necessário estender o OnWriteBodyContents método. Por exemplo, você poderia chamar um serializador personalizado para serializar os dados da mensagem.Nesse caso, você poderia traduzir código atributos no proxy do cliente gerado atributos que pode consumir o serializador do XML.Nesse cenário, primeiro você deve adicionar a seguinte comutador quando você executa o SvcUtil: /serializer:xmlserializer http://ponto de extremidade.

O código a seguir mostra um exemplo do ClientBase classe.

Public Class ClientBase(Of TChannel As Class)

    Private requestChannel As IRequestChannel
    Private messageVersion As MessageVersion


    Public Sub New(ByVal binding As System.ServiceModel.Channels.Binding, ByVal remoteAddress As System.ServiceModel.EndpointAddress)
        'this.remoteAddress = remoteAddress;
        Me.messageVersion = binding.MessageVersion

        Dim channelFactory As IChannelFactory(Of IRequestChannel)
        channelFactory = binding.BuildChannelFactory(Of IRequestChannel)(New BindingParameterCollection())
        channelFactory.Open()
        Me.requestChannel = channelFactory.CreateChannel(remoteAddress)

    End Sub


    Public Function [Call](ByVal op As String, ByVal action As String, ByVal varnames() As String, ByVal varvals() As Object, ByVal returntype As Type) As Object
        requestChannel.Open(TimeSpan.MaxValue)

        Dim msg As Message = Message.CreateMessage(Me.messageVersion, action, New CustomBodyWriter(op, varnames, varvals, "<ns passed in from Proxy>"))

        Dim reply As Message = requestChannel.Request(msg, TimeSpan.MaxValue)
        Dim reader As XmlDictionaryReader = reply.GetReaderAtBodyContents()
        reader.ReadToFollowing(op + "Result")
        Return reader.ReadElementContentAs(returntype, Nothing)

    End Function
End Class


Friend Class CustomBodyWriter
    Inherits BodyWriter
    Private op As String
    Private varnames() As String
    Private varvals() As Object
    Private ns As String


    Public Sub New(ByVal op As String, ByVal varnames() As String, ByVal varvals() As Object, ByVal ns As String)
        MyBase.New(True)
        Me.op = op
        Me.varnames = varnames
        Me.varvals = varvals
        Me.ns = ns

    End Sub


    Protected Overrides Sub OnWriteBodyContents(ByVal writer As XmlDictionaryWriter)
        writer.WriteStartElement(op, ns)
        Dim i As Integer
        For i = 0 To varnames.Length
            writer.WriteElementString(varnames(i), varvals(i).ToString())
        Next i
        writer.WriteEndElement()

    End Sub
End Class

public class ClientBase<TChannel>
    where TChannel : class
{
    private IRequestChannel requestChannel;
    private MessageVersion messageVersion;

    public ClientBase(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress)
    {
        //this.remoteAddress = remoteAddress;
        this.messageVersion = binding.MessageVersion;

        IChannelFactory<IRequestChannel> channelFactory = binding.BuildChannelFactory<IRequestChannel>(
            new BindingParameterCollection());
        channelFactory.Open();
        this.requestChannel = channelFactory.CreateChannel(remoteAddress);
    }

    public object Call(string op, string action, string[] varnames, object[] varvals, Type returntype)
    {
        requestChannel.Open(TimeSpan.MaxValue);

        //Message msg =                     
        //Message.CreateMessage(MessageVersion.<FromBinding>,
        //      action,
        //      new CustomBodyWriter(op, varnames, varvals,                 
        //"<ns passed in from Proxy>"));

        Message msg =                   
        Message.CreateMessage(this.messageVersion, action,
              new CustomBodyWriter(op, varnames, varvals,               
        "<ns passed in from Proxy>"));

        Message reply = requestChannel.Request(msg, TimeSpan.MaxValue);
        XmlDictionaryReader reader = reply.GetReaderAtBodyContents();
        reader.ReadToFollowing(op + "Result");
        return reader.ReadElementContentAs(returntype, null);
    }

}

internal class CustomBodyWriter : BodyWriter
{
    private string op;
    private string[] varnames;
    private object[] varvals;
    private string ns;

    public CustomBodyWriter(string op, string[] varnames, object[] varvals, string ns)
        : base(true)
    {
        this.op = op;
        this.varnames = varnames;
        this.varvals = varvals;
        this.ns = ns;
    }

    protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
    {
        writer.WriteStartElement(op, ns);
        for (int i = 0; i < varnames.Length; i++)
            writer.WriteElementString(varnames[i], varvals[i].ToString());
        writer.WriteEndElement();
    }
}

Adicione uma classe para instanciar e usar o proxy de cliente.

O exemplo a seguir mostra o código que chama o proxy do cliente.

Shared Sub Main(ByVal args() As String)
    Dim serverAddress As String = CalculatorServiceClient.ServiceEndPoint.Uri.AbsoluteUri
    ' Using basic http connection. WS binding should be also available.
    Dim proxy As ICalculatorService = New CalculatorServiceClient(New BasicHttpBinding, New EndpointAddress(serverAddress))
    MessageBox.Show("Add 3 + 6...")
    MessageBox.Show(proxy.Add(3, 6).ToString)
    MessageBox.Show("Subtract 8 - 3...")
    MessageBox.Show(proxy.Subtract(8, 3).ToString)
End Sub

static void Main()
{
    string serverAddress = CalculatorServiceClient.ServiceEndPoint.Uri.AbsoluteUri;
    // Using basic http connection. WS binding should be also available.
    ICalculatorService proxy = new CalculatorServiceClient(new BasicHttpBinding(), new EndpointAddress(serverAddress));


    MessageBox.Show("Add 3 + 6...");
    MessageBox.Show((proxy.Add(3, 6)).ToString());
    MessageBox.Show("Subtract 8 - 3...");        
    MessageBox.Show((proxy.Subtract(8, 3)).ToString());

}

Construir o aplicativo cliente e implantá-lo em seu dispositivo.
Quando o serviço WCF está sendo executado e o dispositivo está conectado à rede, inicie o aplicativo cliente no dispositivo.

Compilando o código

O código-fonte para o serviço do WCF requer referências aos namespaces seguintes:

O código-fonte para o ClientBase classe requer referências aos namespaces seguintes:

O código-fonte para a classe que contém o Main método no aplicativo cliente requer referências aos namespaces seguintes:

Segurança

Este exemplo não implementa quaisquer recursos de segurança do WCF.Para obter mais informações sobre os recursos de segurança com suporte, consulte sistema de sistema sistema de mensagens no .NET Compact estrutura.

Consulte também

Conceitos

sistema de sistema sistema de mensagens no .NET Compact estrutura

Outros recursos

Desenvolvimento do Windows Communication Foundation (WCF) e o .NET Compact estrutura

Compartilhar via