Windows Communication Foundation

Die Windows Communication Foundation (WCF, früherer Codename Indigo) ist eine dienstorientierte Kommunikationsplattform für verteilte Anwendungen in Microsoft Windows. Sie führt viele Netzwerkfunktionen zusammen und stellt sie den Programmierern solcher Anwendungen standardisiert zur Verfügung.

Windows Communication Foundation
Basisdaten
Entwickler Microsoft
Aktuelle Version 4.5
(9. Oktober 2012)
Betriebssystem Version 3.x: ab Windows XP mit SP2
Version 4.x: ab Windows XP mit SP3
Kategorie Plattform
Lizenz Proprietäre Software
deutschsprachig ja
microsoft.com

Durch die WCF werden die Kommunikationstechnologien DCOM, Enterprise Services, MSMQ, WSE und Web-Services unter einer einheitlichen Programmierschnittstelle zusammengefasst. Mit der WCF wird das .NET Remoting abgelöst. WCF kann für die Entwicklung Service-orientierter Architekturen verwendet werden. Die Windows Communication Foundation ermöglicht auch Interoperabilität zu Java Web Services, welche mittels Web Services Interoperability Technology umgesetzt wurden.[1]

Die Windows Communication Foundation ist seit .NET Framework Version 3.0 ein fester Bestandteil des .NET Frameworks. Die Versionsnummern von WCF orientieren sich hierbei an der Version des .NET Frameworks.

Für das neue .NET Core Framework steht WCF in der bisherigen Form nicht zur Verfügung, es soll jedoch durch ein (in einem Communityprojekt) noch zu entwickelndes Core WCF ersetzt werden, client-seitig soll der Zugriff auf existierende .NET WCF Server jedoch ermöglicht werden.[2][3][4] Als Alternative empfiehlt Microsoft die Nutzung von gRPC, welches ab .NET Core 3.0 unterstützt wird.[5][6]

Konzept

Die WCF abstrahiert das Konzept des Endpunktes durch eine Trennung in Address, Binding und Contract (ABC-Prinzip).

  • Die Address (Adresse) ist ein URI, der den Ort des Dienstes beschreibt und somit seine Erreichbarkeit für die Dienstkonsumenten kennzeichnet.
  • Das Binding (Anbindung) beschreibt die Art der Kommunikation, worunter unter anderem die Merkmale der Kodierung und des Protokolls fallen.
  • Der Contract (Vertrag) stellt die Dienstdefinition, insbesondere die zur Verfügung gestellten Methoden beinhaltend, dar.

Address

Der Ort des Dienstes ist, je nach verwendetem Transportschema, der Name des Zielrechners, des Netzwerks oder einer Ressource vom Type Pipe, Communication Port oder Queue.

Binding

Zum Binding gehören Parameter wie Protokoll (HTTP, TCP, UDP und Windows-eigene Protokolle) und Kodierung (binär, SOAP-Dokument, eigenes Format), sowie Sicherheitsaspekte (Verschlüsselung, Authentifizierung).

Das .NET Framework stellt vorgefertigte Bindungen für häufige Anwendungsfälle zur Verfügung, die noch konfiguriert werden können. Auch besteht die Möglichkeit, eigene Bindings zu entwickeln (beispielsweise für das XML-RPC-Protokoll).

Contract

Verträge werden zur Entwicklungszeit als Interfaces (Schnittstellen) in einer beliebigen .NET-Sprache verfasst und zur Laufzeit durch die WCF in ein Kommunikationsprotokoll, z. B. SOAP, umgesetzt. Die Verwendung dieses Standards ist maßgeblich für einen plattformunabhängigen Dienstzugriff.

Behaviors

Das Verhalten einer WCF-Verbindung wird durch Behaviors definiert. Hierbei unterscheidet man abhängig vom Bereich zwischen:

  • Service Behavior
  • Endpoint Behavior
  • Contract Behavior
  • Operation Behavior

Beispiele

Im Folgenden werden Beispiele für die Implementierung eines einfachen WCF-Dienstes gezeigt.

Implementierung eines Contracts

Der Contract wird sowohl von der Host- als auch von der Clientanwendung verwendet und sollte sich daher in einer eigenen Assembly befinden.

using System.ServiceModel;

namespace HelloWorld.Contract
{
    [ServiceContract(Namespace = "http://de.wikipedia.org/wiki")]
    public interface IHelloWorldService
    {
        [OperationContract]
        string SayHello();
    }
}

Implementierung des Services

 
using HelloWorld.Contract;

namespace HelloWorld.Service
{
    public class HelloWorldService : IHelloWorldService
    {
        public string SayHello()
        {
            return "Hello World";
        }
    }
}

Imperative Implementierung einer Hostanwendung

 
using System;
using System.ServiceModel;
using HelloWorld.Contract;
using HelloWorld.Service;

namespace HelloWorld.ConsoleHost {
    class Program
    {
        static void Main()
        {
            using (var host = new ServiceHost(typeof (HelloWorldService), new Uri("http://localhost:8000/HelloWorld")))
            {
                host.AddServiceEndpoint(typeof (IHelloWorldService), new BasicHttpBinding(), "" target="_blank" rel="nofollow");
                host.Open();
                Console.WriteLine("Service running. Press ENTER to stop.");
                Console.ReadLine();
            }
        }
    }
}

Implementierung eines Clients

 
using System;
using System.ServiceModel;
using HelloWorld.Contract;

namespace HelloWorld.ConsoleClient
{
    class Program
    {
        static void Main()
        {
            var endpointAddress = new EndpointAddress("http://localhost:8000/HelloWorld");
            var proxy = ChannelFactory<IHelloWorldService>.CreateChannel(new BasicHttpBinding(), endpointAddress);
            var helloWorld = proxy.SayHello();
            Console.WriteLine(helloWorld);
        }
    }
}

Deklarative Implementierung einer Hostanwendung

 
using System;
using System.ServiceModel;
using HelloWorld.Contract;
using HelloWorld.Service;

namespace HelloWorld.ConsoleHost
{
    class Program
    {
        static void Main()
        {
            using (var host = new ServiceHost(typeof (HelloWorldService)))
            {
                host.Open();
                Console.WriteLine("Service running. Press ENTER to stop.");
                Console.ReadLine();
            }
        }
    }
}

Das Verhalten des Service wird in der Datei App.config bzw. Web.config deklariert. Dies erfolgt üblicherweise mit dem Service Configuration Editor (svcconfigeditor.exe) und kann von erfahrenen Entwicklern und Administratoren auch manuell in einem Texteditor konfiguriert werden.

<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <system.serviceModel>
        <bindings>
            <basicHttpBinding>
                <binding name="basicHttpBindingConfiguration" />
            </basicHttpBinding>
            <mexHttpBinding>
                <binding name="mexHttpBindingConfiguration" />
            </mexHttpBinding>
        </bindings>
        <behaviors>
            <serviceBehaviors>
                <behavior name="metadataExchangeBehavior">
                    <serviceMetadata httpGetEnabled="false" httpsGetEnabled="false" />
                </behavior>
            </serviceBehaviors>
        </behaviors>
        <services>
            <service behaviorConfiguration="metadataExchangeBehavior" name="HelloWorld.Service.HelloWorldService">
                <endpoint
                    address="" target="_blank" rel="nofollow"
                    binding="basicHttpBinding"
                    bindingConfiguration="basicHttpBindingConfiguration"
                    name="basicHttpEndpoint"
                    contract="HelloWorld.Contract.IHelloWorldService" />
                <endpoint
                    address="mex"
                    binding="mexHttpBinding"
                    bindingConfiguration="mexHttpBindingConfiguration"
                    name="mexEndpoint"
                    contract="IMetadataExchange" />
                <host>
                    <baseAddresses>
                        <add baseAddress="http://localhost:8000/HelloWorld" />
                    </baseAddresses>
                </host>
            </service>
        </services>
    </system.serviceModel>
</configuration>

Durch die Aktivierung des Metadatenaustausches (englisch: Metadata-Exchange, kurz „mex“) mittels eines entsprechenden Bindings (z. B.mexHttpBinding, mexHttpsBinding, mexTcpBinding, mexNamedPipeBinding) können die Proxyklassen und die Anwendungskonfiguration mit dem Service Model Metadata Utility (svcutil.exe) automatisch erstellt werden.

svcutil /d:"C:\ … \HelloWorld\ConsoleClient" /o:"HelloWorldProxy.cs" /config:"App.config" http://localhost:8000/HelloWorld/mex

Die generierten Proxyklassen und Anwendungskonfiguration können von einem Client sehr einfach konsumiert werden.

using System;
using de.wikipedia.org.wiki; // service namespace as declared in the contract

namespace HelloWorld.ConsoleClient
{
    class Program
    {
        static void Main()
        {
            var proxy = new HelloWorldProxy(); // no using block here!
            var helloWorld = proxy.HelloWorld();
            Console.WriteLine(helloWorld);
        }
    }
}

WCF Service Host und WCF Test Client

Eine weitere Möglichkeit ist es, den Service direkt mit Hilfe des WCF Service Host (wcfsvchost.exe) zu hosten.

wcfsvchost /service:"C:\ … \HelloWorld.Service.dll" /config:"C:\ … \App.config"

Laufende Services, welche den Metadatenaustausch unterstützen, können mit dem WCF Test Client (wcftestclient.exe) analysiert und getestet werden.

wcftestclient http://localhost:8000/HelloWorld/mex

Literatur
  • Michele Leroux Bustamante: Learning WCF: A Hands-on Guide. 2. Auflage. O’Reilly, 2007, ISBN 978-0-596-10162-6 (englisch).
  • Juval Lowy: Programming WCF Services: Mastering WCF and the Azure AppFabric Service Bus. 3. Auflage. O’Reilly, 2010, ISBN 978-0-596-80548-7 (englisch).
  • John Sharp: Windows® Communication Foundation 4 Step by Step. 1. Auflage. Microsoft Press, 2010, ISBN 978-0-7356-4556-1 (englisch).

Einzelnachweise
  1. Web Services Interoperability Technology Features. Oracle Sun developer network, abgerufen am 19. November 2011 (englisch).
  2. Main repository for the Core WCF project. Contribute to CoreWCF/CoreWCF development by creating an account on GitHub. Core WCF, 22. Juni 2019, abgerufen am 23. Juni 2019.
  3. Supporting the community with WF and WCF OSS projects. 7. Juni 2019, abgerufen am 20. Juli 2019 (amerikanisches Englisch).
  4. Why isn’t WCF supported in .Net Core? Abgerufen am 20. Juli 2019 (britisches Englisch).
  5. JunTaoLuo: gRPC-Dienste mit ASP.NET Core. Abgerufen am 24. September 2019 (deutsch).
  6. heise online: Build 2019: Microsoft konkretisiert die Pläne für .NET 5.0. Abgerufen am 24. September 2019.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. The authors of the article are listed here. Additional terms may apply for the media files, click on images to show image meta data.