Sdílet prostřednictvím

Přenos: UDP

  • Článek

Ukázka přenosu UDP ukazuje, jak implementovat jednosměrové vysílání UDP a vícesměrové vysílání jako vlastní přenos Windows Communication Foundation (WCF). Ukázka popisuje doporučený postup vytvoření vlastního přenosu ve WCF pomocí rozhraní kanálu a následujících osvědčených postupů WCF. Postup vytvoření vlastního přenosu je následující:

  1. Rozhodněte, který kanál Message Exchange Patterns (IOutputChannel, IInputChannel, IDuplexChannel, IRequestChannel nebo IReplyChannel) ChannelFactory a ChannelListener budou podporovat. Pak se rozhodněte, jestli budete podporovat varianty relací těchto rozhraní.

  2. Vytvořte objekt pro vytváření kanálů a naslouchací proces, který podporuje váš model výměny zpráv.

  3. Zajistěte, aby všechny výjimky specifické pro síť byly normalizovány do příslušné odvozené třídy CommunicationException.

  4. Přidejte element vazby<>, který přidá vlastní přenos do zásobníku kanálu. Další informace naleznete v tématu Přidání elementu vazby.

  5. Přidejte oddíl rozšíření elementu vazby, který zpřístupní nový element vazby do konfiguračního systému.

  6. Přidejte rozšíření metadat pro komunikaci schopností s jinými koncovými body.

  7. Přidejte vazbu, která předem nakonfiguruje sadu prvků vazby podle dobře definovaného profilu. Další informace naleznete v tématu Přidání standardní vazby.

  8. Přidejte oddíl vazby a element konfigurace vazby, který zpřístupní vazbu konfiguračnímu systému. Další informace naleznete v tématu Přidání podpory konfigurace.

Vzory výměny zpráv

Prvním krokem při psaní vlastního přenosu je rozhodnout, které vzory výměny zpráv (MEP) jsou pro dopravu vyžadovány. Existují tři poslanci, kteří si můžou vybrat:

  • Datagram (IInputChannel/IOutputChannel)

    Při použití datagramu MEP odešle klient zprávu pomocí výměny "fire and forget". Oheň a zapomenutá výměna je ta, která vyžaduje potvrzení úspěšného doručení mimo pásmo. Zpráva může být ztracena při přenosu a nikdy se nedostanou ke službě. Pokud se operace odeslání úspěšně dokončí na straně klienta, nezaručuje, že vzdálený koncový bod obdržel zprávu. Datagram je základním stavebním blokem pro zasílání zpráv, protože nad ním můžete vytvářet vlastní protokoly– včetně spolehlivých protokolů a zabezpečených protokolů. Kanály datagramu IOutputChannel klienta implementují rozhraní a kanály datagramu služby implementují IInputChannel rozhraní.

  • Request-Response (IRequestChannel/IReplyChannel)

    V tomto MEP se odešle zpráva a přijme se odpověď. Vzor se skládá z párů požadavků a odpovědí. Příkladem volání požadavků a odpovědí jsou vzdálená volání procedur (RPC) a GET prohlížeče. Tento model se také označuje jako Half-Duplex. V tomto MEP implementují IRequestChannel klientské kanály a kanály služeb implementují IReplyChannel.

  • Duplex (IDuplexChannel)

    Duplexní mep umožňuje, aby klient odeslal libovolný počet zpráv a přijal je v libovolném pořadí. Duplexní MEP je jako telefonní konverzace, kde každé slovo, které se mluví, je zpráva. Vzhledem k tomu, že obě strany mohou odesílat a přijímat v tomto MEP, rozhraní implementované kanály klienta a služby je IDuplexChannel.

Každý z těchto poslanců může také podporovat zasedání. Přidaná funkce poskytovaná kanálem pracujícím s relacemi je, že koreluje všechny zprávy odeslané a přijaté v kanálu. Model Odpovědi na požadavek je samostatná relace se dvěma zprávami, protože požadavek a odpověď korelují. Naproti tomu vzor požadavku-odpověď, který podporuje relace, znamená, že všechny páry požadavků a odpovědí v daném kanálu jsou vzájemně korelovány. Získáte tak celkem šest členů EP – Datagram, Request-Response, Duplex, Datagram s relacemi, Request-Response with sessions a Duplex with sessions ( Duplex with sessions).

Poznámka:

Pro přenos UDP je jediným podporovaným protokolem MEP datagram, protože UDP je ze své podstaty protokol "fire and forget".

ICommunicationObject a životní cyklus objektu WCF

WCF má běžný stavový počítač, který se používá ke správě životního cyklu objektů, jako IChannelje , IChannelFactorya IChannelListener které se používají ke komunikaci. Existuje pět stavů, ve kterých mohou tyto komunikační objekty existovat. Tyto stavy jsou reprezentovány výčtem CommunicationState a jsou následující:

  • Vytvořeno: Jedná se o stav ICommunicationObject při prvním vytvoření instance. V tomto stavu nedojde k žádnému vstupu a výstupu (V/V).

  • Otevření: Objekty přecházejí do tohoto stavu při Open zavolání. V tomto okamžiku jsou vlastnosti neměnné a vstup/výstup může začínat. Tento přechod je platný pouze ze stavu Vytvoření.

  • Otevřeno: Objekty přecházejí do tohoto stavu po dokončení otevřeného procesu. Tento přechod je platný pouze ze stavu otevření. V tomto okamžiku je objekt plně použitelný pro přenos.

  • Závěr: Objekty přecházejí do tohoto stavu, pokud Close je volána pro řádné vypnutí. Tento přechod je platný pouze ze stavu Otevření.

  • Uzavřeno: Objekty ve stavu Uzavřeno už nejsou použitelné. Obecně platí, že většina konfigurací je stále přístupná pro kontrolu, ale nemůže dojít k žádné komunikaci. Tento stav je ekvivalentem vyřazení.

  • Chyba: V chybném stavu jsou objekty přístupné pro kontrolu, ale už je nelze použít. Pokud dojde k neobnovitelné chybě, objekt přejde do tohoto stavu. Jediný platný přechod z tohoto stavu je do Closed stavu.

Pro každý přechod stavu se aktivují události. Metodu Abort lze volat kdykoli a způsobí, že objekt přejde okamžitě z jeho aktuálního stavu do uzavřeného stavu. Volání Abort ukončí veškerou nedokončenou práci.

Channel Factory a naslouchací proces kanálu

Dalším krokem při psaní vlastního přenosu je vytvoření implementace IChannelFactory pro klientské kanály a IChannelListener kanály služeb. Vrstva kanálu používá vzor továrny pro vytváření kanálů. WCF poskytuje pomocné rutiny základní třídy pro tento proces.

V této ukázce je implementace továrny obsažena v UdpChannelFactory.cs a implementace naslouchacího procesu je obsažena v UdpChannelListener.cs. Implementace IChannel jsou v UdpOutputChannel.cs a UdpInputChannel.cs.

Továrna kanálu UDP

Odvozeno UdpChannelFactory od ChannelFactoryBase. Ukázka přepisuje GetProperty , aby poskytovala přístup ke verzi zprávy kodéru zpráv. Ukázka také přepíše OnClose , abychom mohli instanci, kdy stavový počítač přejde, zbourat BufferManager .

Výstupní kanál UDP

Implementuje UdpOutputChannelIOutputChannel. Konstruktor ověří argumenty a vytvoří cílový EndPoint objekt na základě předaného objektu EndpointAddress .

this.socket = new Socket(this.remoteEndPoint.AddressFamily, SocketType.Dgram, ProtocolType.Udp);

Kanál může být elegantně uzavřen nebo nedrželně. Pokud je kanál uzavřen elegantně, soket je uzavřen a volání je provedeno metodu základní třídy OnClose . Pokud dojde k výjimce, volání Abort infrastruktury, aby se zajistilo vyčištění kanálu.

this.socket.Close(0);

Pak implementujeme Send() a BeginSend()/EndSend(). Rozdělí se do dvou hlavních částí. Nejprve zprávu serializujeme do bajtového pole.

ArraySegment<byte> messageBuffer = EncodeMessage(message);

Pak na drát odešleme výsledná data.

this.socket.SendTo(messageBuffer.Array, messageBuffer.Offset, messageBuffer.Count, SocketFlags.None, this.remoteEndPoint);

The UdpChannelListener

Ukázka UdpChannelListener implementuje odvození z ChannelListenerBase třídy. K příjmu datagramů používá jeden soket UDP. Metoda OnOpen přijímá data pomocí soketu UDP v asynchronní smyčce. Data se pak převedou na zprávy pomocí architektury Kódování zpráv.

message = MessageEncoderFactory.Encoder.ReadMessage(new ArraySegment<byte>(buffer, 0, count), bufferManager);

Vzhledem k tomu, že stejný kanál datagramu představuje zprávy, které přicházejí z řady zdrojů, jedná se UdpChannelListener o jeden naslouchací proces. K tomuto naslouchacímu procesu je současně přidružený jeden aktivní IChannel . Ukázka vygeneruje další pouze v případě, že se následně odstraní kanál vrácený metodou AcceptChannel . Když se zpráva přijme, začtou se do tohoto jednoúčelového kanálu.

UdpInputChannel

Třída UdpInputChannel implementuje IInputChannel. Skládá se z fronty příchozích zpráv naplněných soketem UdpChannelListener. Tyto zprávy jsou vyřazeny z fronty metodou IInputChannel.Receive .

Přidání elementu vazby

Teď, když jsou továrny a kanály vytvořené, musíme je zpřístupnit modulu runtime ServiceModel prostřednictvím vazby. Vazba je kolekce prvků vazby, která představuje zásobník komunikace přidružený k adrese služby. Každý prvek v zásobníku je reprezentován elementem <vazby> .

V ukázce je UdpTransportBindingElementelement vazby , který je odvozen od TransportBindingElement. Přepíše následující metody sestavení továren přidružených k naší vazbě.

public IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingContext context)
{
    return (IChannelFactory<TChannel>)(object)new UdpChannelFactory(this, context);
}

public IChannelListener<TChannel> BuildChannelListener<TChannel>(BindingContext context)
{
    return (IChannelListener<TChannel>)(object)new UdpChannelListener(this, context);
}

Obsahuje také členy pro klonování a vrácení našeho schématu BindingElement (soap.udp).

Přidání podpory metadat pro element vazby přenosu

Abychom mohli integrovat přenos do systému metadat, musíme podporovat import i export zásad. To nám umožňuje generovat klienty naší vazby prostřednictvím nástroje ServiceModel Metadata Utility (Svcutil.exe).

Přidání podpory WSDL

Prvek transportní vazby v vazbě je zodpovědný za export a import adresování informací v metadatech. Při použití vazby SOAP by prvek vazby přenosu měl také exportovat správný transportní identifikátor URI v metadatech.

WSDL Export

Export adresování informací implementuje UdpTransportBindingElementIWsdlExportExtension rozhraní. Metoda ExportEndpoint přidá správné informace o adresování na port WSDL.

if (context.WsdlPort != null)
{
    AddAddressToWsdlPort(context.WsdlPort, context.Endpoint.Address, encodingBindingElement.MessageVersion.Addressing);
}

Implementace UdpTransportBindingElementExportEndpoint metody také exportuje transportní identifikátor URI, když koncový bod používá vazbu SOAP.

WsdlNS.SoapBinding soapBinding = GetSoapBinding(context, exporter);
if (soapBinding != null)
{
    soapBinding.Transport = UdpPolicyStrings.UdpNamespace;
}

WSDL Import

Chcete-li rozšířit systém importu WSDL pro zpracování importu adres, musíme do konfiguračního souboru pro Svcutil.exe přidat následující konfiguraci, jak je znázorněno v souboru Svcutil.exe.config.

<configuration>
  <system.serviceModel>
    <client>
      <metadata>
        <policyImporters>
          <extension type=" Microsoft.ServiceModel.Samples.UdpBindingElementImporter, UdpTransport" />
        </policyImporters>
      </metadata>
    </client>
  </system.serviceModel>
</configuration>

Při spuštění Svcutil.exe existují dvě možnosti, jak získat Svcutil.exe pro načtení rozšíření importu WSDL:

  1. Nastavte Svcutil.exe na konfigurační soubor pomocí /SvcutilConfig:<file>.

  2. Do stejného adresáře jako Svcutil.exe přidejte oddíl konfigurace Svcutil.exe.config.

Typ UdpBindingElementImporter implementuje IWsdlImportExtension rozhraní. Metoda ImportEndpoint naimportuje adresu z portu WSDL.

BindingElementCollection bindingElements = context.Endpoint.Binding.CreateBindingElements();
TransportBindingElement transportBindingElement = bindingElements.Find<TransportBindingElement>();
if (transportBindingElement is UdpTransportBindingElement)
{
    ImportAddress(context);
}

Přidání podpory zásad

Element vlastní vazby může exportovat kontrolní výrazy zásad ve vazbě WSDL pro koncový bod služby k vyjádření schopností tohoto elementu vazby.

Export zásad

Typ UdpTransportBindingElement implementuje IPolicyExportExtension přidání podpory pro export zásad. V důsledku toho System.ServiceModel.MetadataExporter zahrnuje UdpTransportBindingElement generování zásad pro všechny vazby, které ji zahrnují.

V IPolicyExportExtension.ExportPolicy, přidáme kontrolní výraz pro UDP a další kontrolní výraz, pokud jsme v režimu vícesměrového vysílání. Důvodem je to, že režim vícesměrového vysílání ovlivňuje způsob vytváření komunikačního zásobníku, a proto musí být sladěný mezi oběma stranami.

ICollection<XmlElement> bindingAssertions = context.GetBindingAssertions();
XmlDocument xmlDocument = new XmlDocument();
bindingAssertions.Add(xmlDocument.CreateElement(
UdpPolicyStrings.Prefix, UdpPolicyStrings.TransportAssertion, UdpPolicyStrings.UdpNamespace));
if (Multicast)
{
    bindingAssertions.Add(xmlDocument.CreateElement(
        UdpPolicyStrings.Prefix,
        UdpPolicyStrings.MulticastAssertion,
        UdpPolicyStrings.UdpNamespace));
}

Vzhledem k tomu, že vlastní prvky vazby přenosu jsou zodpovědné za zpracování adresování, IPolicyExportExtension musí implementace na straně UdpTransportBindingElement musí také zpracovat export příslušných kontrolních výrazů zásad WS-Adresování, které označují verzi používaného WS-Adresování.

AddWSAddressingAssertion(context, encodingBindingElement.MessageVersion.Addressing);

Import zásad

Abychom rozšířili systém importu zásad, musíme do konfiguračního souboru přidat následující konfiguraci pro Svcutil.exe, jak je znázorněno v souboru Svcutil.exe.config.

<configuration>
  <system.serviceModel>
    <client>
      <metadata>
        <policyImporters>
          <extension type=" Microsoft.ServiceModel.Samples.UdpBindingElementImporter, UdpTransport" />
        </policyImporters>
      </metadata>
    </client>
  </system.serviceModel>
</configuration>

Pak implementujeme IPolicyImporterExtension z naší registrované třídy (UdpBindingElementImporter). V ImportPolicy()aplikaci se podíváme na kontrolní výrazy v našem oboru názvů a zpracujeme je pro generování přenosu a zkontrolujeme, jestli se jedná o vícesměrové vysílání. Musíme také odebrat kontrolní výrazy, které zpracováváme ze seznamu vazebních kontrolních výrazů. Při spuštění Svcutil.exe existují dvě možnosti integrace:

  1. Nastavte Svcutil.exe na konfigurační soubor pomocí /SvcutilConfig:<file>.

  2. Do stejného adresáře jako Svcutil.exe přidejte oddíl konfigurace Svcutil.exe.config.

Přidání standardní vazby

Náš element vazby lze použít následujícími dvěma způsoby:

  • Prostřednictvím vlastní vazby: Vlastní vazba umožňuje uživateli vytvořit vlastní vazbu založenou na libovolné sadě prvků vazby.

  • Pomocí systémové vazby, která zahrnuje náš element vazby. WCF poskytuje řadu těchto systémově definovaných vazeb, například BasicHttpBinding, NetTcpBindinga WsHttpBinding. Každá z těchto vazeb je přidružená k dobře definovanému profilu.

Ukázka implementuje vazbu SampleProfileUdpBindingprofilu, která je odvozena z Binding. Obsahuje SampleProfileUdpBinding až čtyři prvky vazby: UdpTransportBindingElement, TextMessageEncodingBindingElement CompositeDuplexBindingElementa ReliableSessionBindingElement.

public override BindingElementCollection CreateBindingElements()
{
    BindingElementCollection bindingElements = new BindingElementCollection();
    if (ReliableSessionEnabled)
    {
        bindingElements.Add(session);
        bindingElements.Add(compositeDuplex);
    }
    bindingElements.Add(encoding);
    bindingElements.Add(transport);
    return bindingElements.Clone();
}

Přidání vlastního importu standardních vazeb

Svcutil.exe a WsdlImporter typ ve výchozím nastavení rozpoznává a importuje systémové vazby definované systémem. V opačném případě se vazba naimportuje jako CustomBinding instance. Pro povolení Svcutil.exe a WsdlImporter importu SampleProfileUdpBindingUdpBindingElementImporter funguje také jako vlastní standardní importér vazeb.

Vlastní import standardní vazby implementuje metodu ImportEndpointIWsdlImportExtension v rozhraní, aby prozkoumala CustomBinding instanci importovanou z metadat a zjistila, jestli mohla být vygenerována konkrétní standardní vazbou.

if (context.Endpoint.Binding is CustomBinding)
{
    Binding binding;
    if (transportBindingElement is UdpTransportBindingElement)
    {
        //if TryCreate is true, the CustomBinding will be replace by a SampleProfileUdpBinding in the
        //generated config file for better typed generation.
        if (SampleProfileUdpBinding.TryCreate(bindingElements, out binding))
        {
            binding.Name = context.Endpoint.Binding.Name;
            binding.Namespace = context.Endpoint.Binding.Namespace;
            context.Endpoint.Binding = binding;
        }
    }
}

Obecně platí, že implementace vlastního importu standardních vazeb zahrnuje kontrolu vlastností importovaných prvků vazby a ověření, že se změnily pouze vlastnosti, které by mohly být nastaveny standardní vazbou, a všechny ostatní vlastnosti jsou jejich výchozí hodnoty. Základní strategií pro implementaci importu standardních vazeb je vytvoření instance standardní vazby, šíření vlastností z prvků vazby do standardní instance vazby, kterou standardní vazba podporuje, a porovnání prvků vazby ze standardní vazby s importovanými prvky vazby.

Přidání podpory konfigurace

Abychom mohli zpřístupnit přenos prostřednictvím konfigurace, musíme implementovat dvě části konfigurace. První je BindingElementExtensionElement pro UdpTransportBindingElement. To znamená, že CustomBinding implementace mohou odkazovat na náš element vazby. Druhá je Configuration pro nás SampleProfileUdpBinding.

Element Binding – rozšíření

Oddíl je BindingElementExtensionElement oddílUdpTransportElement, který zpřístupňuje UdpTransportBindingElement konfiguračnímu systému. Pomocí několika základních přepsání definujeme název oddílu konfigurace, typ elementu vazby a způsob vytvoření elementu vazby. Pak můžeme naši část rozšíření zaregistrovat v konfiguračním souboru, jak je znázorněno v následujícím kódu.

<configuration>
  <system.serviceModel>
    <extensions>
      <bindingElementExtensions>
        <add name="udpTransport" type="Microsoft.ServiceModel.Samples.UdpTransportElement, UdpTransport" />
      </bindingElementExtensions>
    </extensions>
  </system.serviceModel>
</configuration>

Na rozšíření lze odkazovat z vlastních vazeb, aby se jako přenos používal UDP.

<configuration>
  <system.serviceModel>
    <bindings>
      <customBinding>
       <binding configurationName="UdpCustomBinding">
         <udpTransport/>
       </binding>
      </customBinding>
    </bindings>
  </system.serviceModel>
</configuration>

Oddíl vazby

Oddíl je StandardBindingCollectionElement oddílSampleProfileUdpBindingCollectionElement, který zpřístupňuje SampleProfileUdpBinding konfiguračnímu systému. Většina implementace je delegována na SampleProfileUdpBindingConfigurationElement, která je odvozena od StandardBindingElement. Obsahuje SampleProfileUdpBindingConfigurationElement vlastnosti, které odpovídají vlastnostem v SampleProfileUdpBindinga funkce mapují z vazby ConfigurationElement . Nakonec přepište metodu OnApplyConfiguration v našem SampleProfileUdpBinding, jak je znázorněno v následujícím vzorovém kódu.

protected override void OnApplyConfiguration(string configurationName)
{
    if (binding == null)
        throw new ArgumentNullException("binding");

    if (binding.GetType() != typeof(SampleProfileUdpBinding))
    {
        throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
            "Invalid type for binding. Expected type: {0}. Type passed in: {1}.",
            typeof(SampleProfileUdpBinding).AssemblyQualifiedName,
            binding.GetType().AssemblyQualifiedName));
    }
    SampleProfileUdpBinding udpBinding = (SampleProfileUdpBinding)binding;

    udpBinding.OrderedSession = this.OrderedSession;
    udpBinding.ReliableSessionEnabled = this.ReliableSessionEnabled;
    udpBinding.SessionInactivityTimeout = this.SessionInactivityTimeout;
    if (this.ClientBaseAddress != null)
        udpBinding.ClientBaseAddress = ClientBaseAddress;
}

Pokud chcete tuto obslužnou rutinu zaregistrovat v konfiguračním systému, přidáme do příslušného konfiguračního souboru následující část.

<configuration>
  <configSections>
     <sectionGroup name="system.serviceModel">
        <sectionGroup name="bindings">
          <section name="sampleProfileUdpBinding" type="Microsoft.ServiceModel.Samples.SampleProfileUdpBindingCollectionElement, UdpTransport" />
        </sectionGroup>
     </sectionGroup>
  </configSections>
</configuration>

Pak se na něj dá odkazovat z konfiguračního oddílu serviceModel.

<configuration>
  <system.serviceModel>
    <client>
      <endpoint configurationName="calculator"
                address="soap.udp://localhost:8001/"
                bindingConfiguration="CalculatorServer"
                binding="sampleProfileUdpBinding"
                contract= "Microsoft.ServiceModel.Samples.ICalculatorContract">
      </endpoint>
    </client>
  </system.serviceModel>
</configuration>

Testovací služba UDP a klient

Testovací kód pro použití tohoto ukázkového přenosu je k dispozici v adresářích UdpTestService a UdpTestClient. Kód služby se skládá ze dvou testů – jeden test nastavuje vazby a koncové body z kódu a druhý z nich provádí prostřednictvím konfigurace. Oba testy používají dva koncové body. Jeden koncový bod používá metodu reliableSession> nastavenou SampleUdpProfileBinding na true.< Druhý koncový bod používá vlastní vazbu s UdpTransportBindingElement. To je ekvivalentní použití SampleUdpProfileBinding s <reliableSession> nastavena na false. Oba testy vytvoří službu, přidají koncový bod pro každou vazbu, otevřou službu a pak počká, až uživatel přejde na ENTER, než službu zavře.

Při spuštění aplikace pro testování služby by se měl zobrazit následující výstup.

Testing Udp From Code.
Service is started from code...
Press <ENTER> to terminate the service and start service from config...

Pak můžete spustit testovací klientskou aplikaci na publikovaných koncových bodech. Klientská testovací aplikace vytvoří klienta pro každý koncový bod a odešle do každého koncového bodu pět zpráv. Následující výstup je v klientovi.

Testing Udp From Imported Files Generated By SvcUtil.
0
3
6
9
12
Press <ENTER> to complete test.

Následuje úplný výstup služby.

Service is started from code...
Press <ENTER> to terminate the service and start service from config...
Hello, world!
Hello, world!
Hello, world!
Hello, world!
Hello, world!
   adding 0 + 0
   adding 1 + 2
   adding 2 + 4
   adding 3 + 6
   adding 4 + 8

Pokud chcete spustit klientskou aplikaci pro koncové body publikované pomocí konfigurace, stiskněte klávesu ENTER ve službě a pak znovu spusťte testovacího klienta. Ve službě by se měl zobrazit následující výstup.

Testing Udp From Config.
Service is started from config...
Press <ENTER> to terminate the service and exit...

Opětovné spuštění klienta vrátí stejné jako předchozí výsledky.

Pokud chcete znovu vygenerovat kód klienta a konfiguraci pomocí Svcutil.exe, spusťte aplikaci služby a pak z kořenového adresáře ukázky spusťte následující Svcutil.exe.

svcutil http://localhost:8000/udpsample/ /reference:UdpTransport\bin\UdpTransport.dll /svcutilConfig:svcutil.exe.config

Všimněte si, že Svcutil.exe negeneruje konfiguraci rozšíření vazby pro nástroj SampleProfileUdpBinding, takže ho musíte přidat ručně.

<configuration>
  <system.serviceModel>
    <extensions>
      <!-- This was added manually because svcutil.exe does not add this extension to the file -->
      <bindingExtensions>
        <add name="sampleProfileUdpBinding" type="Microsoft.ServiceModel.Samples.SampleProfileUdpBindingCollectionElement, UdpTransport" />
      </bindingExtensions>
    </extensions>
  </system.serviceModel>
</configuration>

Nastavení, sestavení a spuštění ukázky

  1. Pokud chcete sestavit řešení, postupujte podle pokynů v části Sestavení ukázek Windows Communication Foundation.

  2. Pokud chcete spustit ukázku v konfiguraci s jedním nebo více počítači, postupujte podle pokynů v části Spuštění ukázek windows Communication Foundation.

  3. Přečtěte si předchozí část Testovací služba a klient UDP.