Windows Communication Foundation

https://learn.microsoft.com/en-us/dotnet/framework/wcf/
Admin
Windows Communication Foundation (WCF) is a Microsoft .NET framework for building service-oriented...
Tokens:821,603
Snippets:9,598
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Configure and Start ServiceHost

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/discoverable-service-that-registers-with-the-discovery-proxy

Setup of ServiceHost with ServiceDiscoveryBehavior and announcement endpoints to register with a proxy.

```C#
// Define the base address of the service
Uri baseAddress = new Uri("net.tcp://localhost:9002/CalculatorService/" + Guid.NewGuid().ToString());
// Define the endpoint address where announcement messages will be sent
Uri announcementEndpointAddress = new Uri("net.tcp://localhost:9021/Announcement");

// Create the service host
ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress);
try
{
    // Add a service endpoint
    ServiceEndpoint netTcpEndpoint = serviceHost.AddServiceEndpoint(typeof(ICalculatorService),
        new NetTcpBinding(), string.Empty);

    // Create an announcement endpoint, which points to the Announcement Endpoint hosted by the proxy service.
    AnnouncementEndpoint announcementEndpoint = new AnnouncementEndpoint(new NetTcpBinding(),
        new EndpointAddress(announcementEndpointAddress));

    // Create a ServiceDiscoveryBehavior and add the announcement endpoint
    ServiceDiscoveryBehavior serviceDiscoveryBehavior = new ServiceDiscoveryBehavior();
    serviceDiscoveryBehavior.AnnouncementEndpoints.Add(announcementEndpoint);

    // Add the ServiceDiscoveryBehavior to the service host to make the service discoverable
    serviceHost.Description.Behaviors.Add(serviceDiscoveryBehavior);

    // Start listening for messages
    serviceHost.Open();

    Console.WriteLine("Calculator Service started at {0}", baseAddress);
    Console.WriteLine();
    Console.WriteLine("Press <ENTER> to terminate the service.");
    Console.WriteLine();
    Console.ReadLine();

    serviceHost.Close();
}
catch (CommunicationException e)
{
    Console.WriteLine(e.Message);
}
catch (TimeoutException e)
{
    Console.WriteLine(e.Message);
}

if (serviceHost.State != CommunicationState.Closed)
{
    Console.WriteLine("Aborting the service...");
    serviceHost.Abort();
}
```

--------------------------------

### Implement and Host a WCF Service in a Windows Service

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/how-to-host-a-wcf-service-in-a-managed-windows-service

This example includes the service contract, implementation, Windows Service host logic, and the installer class required for registration.

```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.ComponentModel;
using System.ServiceModel;
using System.ServiceProcess;
using System.Configuration;
using System.Configuration.Install;

namespace Microsoft.ServiceModel.Samples
{
    // Define a service contract.
    [ServiceContract(Namespace = "http://Microsoft.ServiceModel.Samples")]
    public interface ICalculator
    {
        [OperationContract]
        double Add(double n1, double n2);
        [OperationContract]
        double Subtract(double n1, double n2);
        [OperationContract]
        double Multiply(double n1, double n2);
        [OperationContract]
        double Divide(double n1, double n2);
    }

    // Implement the ICalculator service contract in a service class.
    public class CalculatorService : ICalculator
    {
        // Implement the ICalculator methods.
        public double Add(double n1, double n2)
        {
            double result = n1 + n2;
            return result;
        }

        public double Subtract(double n1, double n2)
        {
            double result = n1 - n2;
            return result;
        }

        public double Multiply(double n1, double n2)
        {
            double result = n1 * n2;
            return result;
        }

        public double Divide(double n1, double n2)
        {
            double result = n1 / n2;
            return result;
        }
    }

    public class CalculatorWindowsService : ServiceBase
    {
        public ServiceHost serviceHost = null;
        public CalculatorWindowsService()
        {
            // Name the Windows Service
            ServiceName = "WCFWindowsServiceSample";
        }

        public static void Main()
        {
            ServiceBase.Run(new CalculatorWindowsService());
        }

        // Start the Windows service.
        protected override void OnStart(string[] args)
        {
            if (serviceHost != null)
            {
                serviceHost.Close();
            }

            // Create a ServiceHost for the CalculatorService type and
            // provide the base address.
            serviceHost = new ServiceHost(typeof(CalculatorService));

            // Open the ServiceHostBase to create listeners and start
            // listening for messages.
            serviceHost.Open();
        }

        protected override void OnStop()
        {
            if (serviceHost != null)
            {
                serviceHost.Close();
                serviceHost = null;
            }
        }
    }

    // Provide the ProjectInstaller class which allows
    // the service to be installed by the Installutil.exe tool
    [RunInstaller(true)]
    public class ProjectInstaller : Installer
    {
        private ServiceProcessInstaller process;
        private ServiceInstaller service;

        public ProjectInstaller()
        {
            process = new ServiceProcessInstaller();
            process.Account = ServiceAccount.LocalSystem;
            service = new ServiceInstaller();
            service.ServiceName = "WCFWindowsServiceSample";
            Installers.Add(process);
            Installers.Add(service);
        }
    }
}
```

--------------------------------

### Open the ServiceHost

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/how-to-expose-a-contract-to-soap-and-web-clients

Start the service host to begin listening for incoming requests.

```csharp
host.Open();
```

```vb
host.Open()
```

--------------------------------

### Download and Enumerate Metadata with MetadataExchangeClient

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/how-to-use-metadataexchangeclient-to-retrieve-metadata

This example demonstrates initializing a MetadataExchangeClient with an HTTP GET address, enabling reference resolution, and iterating through the retrieved MetadataSection objects.

```csharp
// Get metadata documents.
Console.WriteLine("URI of the metadata documents retrieved:");
MetadataExchangeClient metaTransfer
  = new MetadataExchangeClient(httpGetMetaAddress.Uri, MetadataExchangeClientMode.HttpGet);
metaTransfer.ResolveMetadataReferences = true;
MetadataSet otherDocs = metaTransfer.GetMetadata();
foreach (MetadataSection doc in otherDocs.MetadataSections)
    Console.WriteLine(doc.Dialect + " : " + doc.Identifier);
```

--------------------------------

### Common ServiceModelReg.exe Usage Examples

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/servicemodelreg-exe

Standard commands for installing, uninstalling, and repairing WCF and WF components.

```Console
ServiceModelReg.exe -ia
  Installs all components
ServiceModelReg.exe -i -c:httpnamespace -c:etw
  Installs HTTP namespace reservation and ETW manifests
ServiceModelReg.exe -u -c:etw
  Uninstalls ETW manifests
ServiceModelReg.exe -r
  Repairs an extended install
```

--------------------------------

### Initial WCF Configuration File

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/how-to-publish-metadata-for-a-service-using-a-configuration-file

A starting configuration file template for a WCF service.

```xml
<configuration>  
  <system.serviceModel>  
    <services>  
      <service name="Metadata.Example.SimpleService">  
        <endpoint address=""  
                  binding="basicHttpBinding"  
                  contract="Metadata.Example.ISimpleService" />  
      </service>  
    </services>  
    <behaviors>  
  
    </behaviors>  
  </system.serviceModel>  
</configuration>  
```

--------------------------------

### Sample Console Output

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/message-security-sample

Example output showing calculator operations and client termination instructions.

```text
Add(100,15.99) = 115.99
Subtract(145,76.54) = 68.46
Multiply(9,81.25) = 731.25
Divide(22,7) = 3.14285714285714
Press <ENTER> to terminate client.
```

--------------------------------

### Console Output Example

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/custom-message-encoder-compression-encoder

Expected console output when running the server and interacting with the service.

```text
Press Enter key to Exit.

        Server Echo(string input) called:
        Client message: Simple hello

        Server BigEcho(string[] input) called:
        64 client messages
```

--------------------------------

### Instantiate and Use a WCF Client

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/accessing-services-using-a-wcf-client

Demonstrates creating a client instance using a specific endpoint configuration and calling a service operation.

```csharp
// Create a client object with the given client endpoint configuration.
CalculatorClient calcClient = new CalculatorClient("CalculatorEndpoint");
// Call the Add service operation.
double value1 = 100.00D;
double value2 = 15.99D;
double result = calcClient.Add(value1, value2);
Console.WriteLine("Add({0},{1}) = {2}", value1, value2, result);
```

```vb
' Create a client object with the given client endpoint configuration.
Dim calcClient As CalculatorClient = _
New CalculatorClient("CalculatorEndpoint")

' Call the Add service operation.
Dim value1 As Double = 100.00D
Dim value2 As Double = 15.99D
Dim result As Double = calcClient.Add(value1, value2)
Console.WriteLine("Add({0},{1}) = {2}", value1, value2, result)
```

--------------------------------

### Install Storage Manager and Instance Provider

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/durable-instance-context

Initializes the storage manager and instance provider, then registers them with the DispatchRuntime for each endpoint.

```C#
IStorageManager storageManager =
    StorageManagerFactory.GetStorageManager(storageManagerType);

InstanceContextInitializer contextInitializer =
    new InstanceContextInitializer(storageManager);

InstanceProvider instanceProvider =
    new InstanceProvider(description.ServiceType);

foreach (ChannelDispatcherBase cdb in serviceHostBase.ChannelDispatchers)
{
    ChannelDispatcher cd = cdb as ChannelDispatcher;

    if (cd != null)
    {
        foreach (EndpointDispatcher ed in cd.Endpoints)
        {
            ed.DispatchRuntime.InstanceContextInitializers.Add(contextInitializer);
            ed.DispatchRuntime.InstanceProvider = instanceProvider;
        }
    }
}
```

--------------------------------

### Using a Custom ServiceHost in Main

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/extending/extending-hosting-using-servicehostfactory

Shows how to instantiate the custom DerivedHost class within the application's entry point.

```C#
public static void Main()
{
   ServiceHost host = new DerivedHost( typeof( MyService ) );
   host.Open();

   ...
}
```

--------------------------------

### Security Header Examples

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/security-protocols

Examples of WS-Security headers for request and response messages.

```XML
<o:Security s:mustUnderstand="1" xmlns:o="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"><u:Timestamp u:Id="uuid-e8f6dc3b-407d-4387-bd33-97aedfd8bf13-2"> ... </u:Timestamp><o:BinarySecurityToken> ... </o:BinarySecurityToken><sc:DerivedKeyToken u:Id="_0" xmlns:sc="http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512"> ... </sc:DerivedKeyToken><sc:DerivedKeyToken u:Id="_1" xmlns:sc="http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512"> ... </sc:DerivedKeyToken><e:ReferenceList xmlns:e="http://www.w3.org/2001/04/xmlenc#"> ... </e:ReferenceList><e:EncryptedData Id="_8" Type="http://www.w3.org/2001/04/xmlenc#Element" xmlns:e="http://www.w3.org/2001/04/xmlenc#"> ... </e:EncryptedData></o:Security>
```

```XML
<o:Security s:mustUnderstand="1" xmlns:o="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"><u:Timestamp u:Id="uuid-7b03568e-66ae-49da-82ee-5d12d372876e-3"> ... </u:Timestamp><sc:DerivedKeyToken u:Id="_0" xmlns:sc="http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512"> ... </sc:DerivedKeyToken><sc:DerivedKeyToken u:Id="_1" xmlns:sc="http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512"> ... </sc:DerivedKeyToken><e:ReferenceList xmlns:e="http://www.w3.org/2001/04/xmlenc#"> ... </e:ReferenceList><e:EncryptedData Id="_6" Type="http://www.w3.org/2001/04/xmlenc#Element" xmlns:e="http://www.w3.org/2001/04/xmlenc#"> ... </e:EncryptedData></o:Security>
```

--------------------------------

### Sample Client Console Output

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/ws-transport-with-message-credential

Example output showing the user authentication prompt and calculator service operation results.

```Console
Username authentication required.
Provide a valid machine or domain account. [domain\user]
   Enter username:
YourDomainName\YourAccountName
   Enter password:
********
YourDomainName\YourAccountName
Add(100,15.99) = 115.99
Subtract(145,76.54) = 68.46
Multiply(9,81.25) = 731.25
Divide(22,7) = 3.14285714285714

Press <ENTER> to terminate client.
```

--------------------------------

### Host the WCF Service

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/create-a-service-arbitrary-data-using-wcf

These snippets demonstrate setting up the console application, configuring the base address, creating the ServiceHost, adding the required behaviors, and opening the host.

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

```C#
string baseAddress = "http://" + Environment.MachineName + ":8000/Service";
```

```C#
ServiceHost host = new ServiceHost(typeof(RawDataService), new Uri(baseAddress));
```

```C#
host.AddServiceEndpoint(typeof(IReceiveData), new WebHttpBinding(), "").Behaviors.Add(new WebHttpBehavior());
```

```C#
host.Open();
Console.WriteLine("Host opened");
```

--------------------------------

### Endpoint Configuration Example

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/configuration-editor-tool-svcconfigeditor-exe

Example of an endpoint configuration element after setting a name attribute.

```xml
<endpoint binding="basicHttpBinding" name="somename" />
```

--------------------------------

### JSON Request and Response Examples

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/creating-wcf-ajax-services-without-aspnet

Example JSON payloads for a simple service request and its corresponding response.

```json
"na"
```

```json
["Nairobi", "Naples", "Nashville"]
```

--------------------------------

### Context Header Example

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/context-exchange-protocol

Example of the wsc:Context SOAP header structure used when HTTP cookies are not utilized.

```xml
<Context xmlns="http://schemas.microsoft.com/ws/2006/05/context">
<property name="myContext">context-2</property>
</Context>
```

--------------------------------

### Sample Execution Output

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/service-description

Example console output showing calculator results followed by the service description information.

```Console
Add(15,3) = 18
Subtract(145,76) = 69
Multiply(9,81) = 729
Divide(22,7) = 3
GetServiceDescriptionInfo
Base addresses:
    http://<machine-name>/ServiceModelSamples/service.svc
    https://<machine-name>/ServiceModelSamples/service.svc
Service endpoints:
    Address:  http://<machine-name>/ServiceModelSamples/service.svc
    Binding:  WSHttpBinding
    Contract: IServiceDescriptionCalculator
    Address:  http://<machine-name>/ServiceModelSamples/service.svc/mex
    Binding:  MetadataExchangeHttpBinding
    Contract: IMetadataExchange

Press <ENTER> to terminate client.
```

--------------------------------

### Wrapped JSON Request Example

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/creating-wcf-ajax-services-without-aspnet

Example of a wrapped JSON object used when an operation requires multiple parameters.

```json
{"firstLetters": "na", "maxNumber": 2}
```

--------------------------------

### Define and Host a WCF Service in Code

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/endpoint-creation-overview

Examples showing the implementation of a service contract and the configuration of a service endpoint using ServiceHost.

```C#
namespace Echo
{
   // Define the contract for the IEcho service
   [ServiceContract]
   public interface IEcho
   {
       [OperationContract]
       String Hello(string name)
   }

   // Create an Echo service that implements IEcho contract
   class Echo : IEcho
   {
      public string Hello(string name)
      {
         return "Hello" + name + "!";
      }
      public static void Main ()
      {
          //Specify the base address for Echo service.
          Uri echoUri = new Uri("http://localhost:8000/");

          //Create a ServiceHost for the Echo service.
          ServiceHost serviceHost = new ServiceHost(typeof(Echo),echoUri);

          // Use a predefined WSHttpBinding to configure the service.
          WSHttpBinding binding = new WSHttpBinding();

          // Add the endpoint for this service to the service host.
          serviceHost.AddServiceEndpoint(
             typeof(IEcho),
             binding,
             echoUri
           );

          // Open the service host to run it.
          serviceHost.Open();
     }
  }
}
```

```VB.NET
' Define the contract for the IEcho service
    <ServiceContract()> _
    Public Interface IEcho
        <OperationContract()> _
        Function Hello(ByVal name As String) As String
    End Interface

' Create an Echo service that implements IEcho contract
    Public Class Echo
        Implements IEcho
        Public Function Hello(ByVal name As String) As String _
 Implements ICalculator.Hello
            Dim result As String = "Hello" + name + "!"
            Return result
        End Function

' Specify the base address for Echo service.
Dim echoUri As Uri = New Uri("http://localhost:8000/")

' Create a ServiceHost for the Echo service.
Dim svcHost As ServiceHost = New ServiceHost(GetType(HelloWorld), echoUri)

' Use a predefined WSHttpBinding to configure the service.
Dim binding As New WSHttpBinding()

' Add the endpoint for this service to the service host.
serviceHost.AddServiceEndpoint(GetType(IEcho), binding, echoUri)

' Open the service host to run it.
serviceHost.Open()
```

--------------------------------

### Create a WebServiceHost

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/how-to-create-a-basic-wcf-web-http-service

Initialize a WebServiceHost instance with the service type and base URI.

```csharp
WebServiceHost host = new WebServiceHost(typeof(Service), new Uri("http://localhost:8000/"));
```

```vb
Dim host As WebServiceHost = New WebServiceHost(GetType(Service), New Uri("http://localhost:8000/"))
```

--------------------------------

### Malicious XML Payload Example

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/security-considerations-for-data

An example of an XML message that bypasses property setter logic to force an invalid object state.

```XML
<SpaceStationAirlock>
    <innerDoorOpen>true</innerDoorOpen>
    <outerDoorOpen>true</outerDoorOpen>
</SpaceStationAirlock>
```

--------------------------------

### Complete WCF Client Configuration

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/configuration-sample

A full configuration example integrating dynamic endpoints, discovery settings, and transport configurations.

```xml
<configuration>
  <system.serviceModel>

    <client>
      <!--  Create an endpoint, make kind="dynamicEndpoint" and use the endpointConfiguration to change settings of DynamicEndpoint -->
      <endpoint name="calculatorEndpoint"
                binding="wsHttpBinding"
                contract="ICalculatorService"
                kind ="dynamicEndpoint"
                endpointConfiguration="dynamicEndpointConfiguration">
      </endpoint>
    </client>

    <standardEndpoints>

      <dynamicEndpoint>
        <standardEndpoint name="dynamicEndpointConfiguration">
          <discoveryClientSettings>
            <!-- Controls where the discovery happens. In this case, Probe message is sent over UdpDiscoveryEndpoint. -->
            <endpoint kind="udpDiscoveryEndpoint" endpointConfiguration="adhocDiscoveryEndpointConfiguration" />

            <!-- Add Scopes, ScopeMatchBy, Extensions and termination criteria in FindCriteria -->
            <findCriteria scopeMatchBy="http://schemas.microsoft.com/ws/2008/06/discovery/rfc" duration="00:00:10" maxResults="1">
              <scopes>
                <add scope="http://www.microsoft.com/building42/floor1"/>
              </scopes>
              <!-- These extensions are sent from the client to the service as part of the probe message -->
              <extensions>
                <CustomMetadata>This is custom metadata that is sent to the service along with the client's find request.</CustomMetadata>
              </extensions>
            </findCriteria>
          </discoveryClientSettings>
        </standardEndpoint>
      </dynamicEndpoint>

      <udpDiscoveryEndpoint>
        <!-- Specify the discovery protocol version and UDP transport settings. -->
        <standardEndpoint name="adhocDiscoveryEndpointConfiguration" discoveryVersion="WSDiscovery11">
          <transportSettings duplicateMessageHistoryLength="2048"
                             maxPendingMessageCount="5"
                             maxReceivedMessageSize="8192"
                             maxBufferPoolSize="262144"/>
        </standardEndpoint>
      </udpDiscoveryEndpoint>

    </standardEndpoints>

  </system.serviceModel>
</configuration>
```

--------------------------------

### Generated XSD Type Example

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/contract-first-tool

Example of a C# class generated from an XSD schema, located in the project's obj directory.

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

namespace TestXSD3.ContractTypes
{
    using System.Xml.Serialization;

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Xml", "4.0.30319.17330")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://tempuri.org/ServiceSchema.xsd")]
    [System.Xml.Serialization.XmlRootAttribute(Namespace="http://tempuri.org/ServiceSchema.xsd", IsNullable=true)]
    public partial class SearchRequest
    {

        private string versionField;

        private string marketField;

        private string uILanguageField;

        private string queryField;

        private string appIdField;

        private double latitudeField;

        private bool latitudeFieldSpecified;

        private double longitudeField;

        private bool longitudeFieldSpecified;

        private double radiusField;

        private bool radiusFieldSpecified;

        public SearchRequest()
        {
            this.versionField = "2.2";
        }

        /// <remarks/>
        [System.ComponentModel.DefaultValueAttribute("2.2")]
        public string Version
        {
            get
            {
                return this.versionField;
            }
            set
            {
                this.versionField = value;
            }
        }

        /// <remarks/>
        public string Market
        {
            get
            {
                return this.marketField;
            }
            set
            {
                this.marketField = value;
            }
        }

        /// <remarks/>
        public string UILanguage
        {
            get
            {
                return this.uILanguageField;
            }
            set
            {
                this.uILanguageField = value;
            }
        }

        /// <remarks/>
        public string Query
        {
            get
            {
                return this.queryField;
            }
            set
            {
                this.queryField = value;
            }
        }

        /// <remarks/>
        public string AppId
        {
            get
            {
                return this.appIdField;
            }
            set
            {
                this.appIdField = value;
            }
        }

        /// <remarks/>
        public double Latitude
        {
            get
            {
                return this.latitudeField;
            }
            set
            {
                this.latitudeField = value;
            }
        }

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool LatitudeSpecified
        {
            get
            {
                return this.latitudeFieldSpecified;
            }
            set
            {
                this.latitudeFieldSpecified = value;
            }
        }

        /// <remarks/>
        public double Longitude
        {
            get
            {
                return this.longitudeField;
            }
            set
            {
                this.longitudeField = value;
            }
        }

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool LongitudeSpecified
        {
            get
            {
                return this.longitudeFieldSpecified;
            }
            set
            {
                this.longitudeFieldSpecified = value;
            }
        }
```

--------------------------------

### Create an HTTP GET request message in C#

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/interoperability-with-pox-applications

Constructs a POX request message with custom HTTP properties to perform a GET operation.

```C#
Message request = Message.CreateMessage( MessageVersion.None, String.Empty );
request.Headers.To = "http://localhost:8100/customers";

HttpRequestMessageProperty property = new HttpRequestMessageProperty();
property.Method = "GET";
property.SuppressEntityBody = true;
request.Properties.Add( HttpRequestMessageProperty.Name, property );
```

--------------------------------

### Implement Conditional GET in WCF Service

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/caching-support-for-wcf-web-http-services

Demonstrates using CheckConditionalRetrieve to validate ETags and SetETag to update the response header for conditional GET requests.

```csharp
[WebGet(UriTemplate = "{id}"), Description("Returns the specified customer from customers collection. Returns NotFound if there is no such customer. Supports conditional GET.")]
public Customer GetCustomer(string id)
{
    lock (writeLock)
    {
        // return NotFound if there is no item with the specified id.
        object itemEtag = customerEtags[id];
        if (itemEtag == null)
        {
            throw new WebFaultException(HttpStatusCode.NotFound);
        }

        // return NotModified if the client did a conditional GET and the customer item has not changed
        // since when the client last retrieved it
        WebOperationContext.Current.IncomingRequest.CheckConditionalRetrieve((long)itemEtag);
        Customer result = this.customers[id] as Customer;

        // set the customer etag before returning the result
        WebOperationContext.Current.OutgoingResponse.SetETag((long)itemEtag);
        return result;
    }
}
```

--------------------------------

### Create a ServiceHost instance

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/how-to-expose-a-contract-to-soap-and-web-clients

Initialize the service host with the service type and base URI.

```csharp
ServiceHost host = new ServiceHost(typeof(Service), new Uri("http://localhost:8000"));
```

```vb
Dim host As New ServiceHost(GetType(Service), New Uri("http://localhost:8000"))
```

--------------------------------

### Service Execution Output

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/transport-custom-transactions-over-udp-sample

Console output displayed when starting the UdpTestService.

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

--------------------------------

### Define GZip Policy in XML

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/custom-message-encoder-compression-encoder

Example of the policy assertion exported by the GZipMessageEncodingBindingElement.

```xml
<wsp:Policy wsu:Id="BufferedHttpSampleServer_ISampleServer_policy">
    <wsp:ExactlyOne>
      <wsp:All>
        <gzip:text xmlns:gzip=
        "http://schemas.microsoft.com/ws/06/2004/mspolicy/netgzip1" />
       <wsaw:UsingAddressing />
     </wsp:All>
   </wsp:ExactlyOne>
</wsp:Policy>
```

--------------------------------

### Display Client Console Output

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/custom-binding-security

Example output displayed in the client console window after running the sample.

```text
Press <ENTER> to terminate client.
Result(100)
Result(50)
Result(882.5)
Result(441.25)
Equation(0 + 100 - 50 * 17.65 / 2 = 441.25)
```

--------------------------------

### Security Header: EncryptBeforeSign

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/security-protocols-version-1-0

Example security headers demonstrating the EncryptBeforeSign configuration.

```xml
<wsse:Security>
  <wsu:Timestamp>
  ...
  </wsu:Timestamp>
  <wsc:SecurityContextToken>
  ...
  </wsc:SecurityContextToken>
  <wsc:DerivedKeyToken>
  ...
  </wsc:DerivedKeyToken>
  <wsc:DerivedKeyToken>
  ...
  </wsc:DerivedKeyToken>
  <ds:Signature>
  ...
  </ds:Signature>
  <xenc:ReferenceList>
  ...
  </xenc:ReferenceList>
</wsse:Security>
```

```xml
<wsse:Security>
<wsu:Timestamp>
  ...
  </wsu:Timestamp>
  <wsc:DerivedKeyToken>
  ...
  </wsc:DerivedKeyToken>
  <wsc:DerivedKeyToken>
  ...
  </wsc:DerivedKeyToken>
  <ds:Signature>
  ...
  </ds:Signature>
  <xenc:ReferenceList>
  ...
  </xenc:ReferenceList>
</wsse:Security>
```

--------------------------------

### Implement Service

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/how-to-use-svcutil-exe-to-export-metadata-from-compiled-service-code

Example of a service implementation compiled into Service.exe that references the contracts.

```C#
// The following service implementation is compiled into Service.exe.
// This service uses the contracts specified in Contracts.dll.  
[ServiceBehavior(ConfigurationName = "MyService")]  
public class MyService : IPersonFinder  
{  
    public Address GetAddress(Person person)  
    {  
        Address address = new Address();  
        address.person = person;  
        return address;  
    }  
}  
```

--------------------------------

### Implement Workflow Client Logic in C#

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/creating-a-long-running-workflow-service

This code demonstrates how to instantiate service proxies to start a workflow and send follow-up messages.

```csharp
static void Main(string[] args)
{
   // Send initial message to start the workflow service
   Console.WriteLine("Sending start message");
   StartOrderClient startProxy = new StartOrderClient();
   string orderId = startProxy.StartOrder("Kim Abercrombie");

   // The workflow service is now waiting for the second message to be sent
   Console.WriteLine("Workflow service is idle...");
   Console.WriteLine("Press [ENTER] to send an add item message to reactivate the workflow service...");
   Console.ReadLine();

   // Send the second message
   Console.WriteLine("Sending add item message");
   AddItemClient addProxy = new AddItemClient();
   AddItem item = new AddItem();
   item.p_itemId = "Zune HD";
   item.p_orderId = orderId;

   string orderResult = addProxy.AddItem(item);
   Console.WriteLine("Service returned: " + orderResult);
}
```

--------------------------------

### Service Configuration Output

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/transport-custom-transactions-over-udp-sample

Console output when the service is started using configuration.

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

--------------------------------

### Display tool help

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/how-to-use-the-com-service-model-configuration-tool

Shows the available command-line options for the tool.

```Console
ComSvcConfig.exe /?
```

--------------------------------

### Configure WCF Client for Windows Credentials

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/how-to-secure-a-service-with-windows-credentials

Sets up a WSHttpBinding with Windows message security and initializes the service client.

```vbnet
Imports System.Collections.Generic
Imports System.ServiceModel



Public Class Program

    Shared Sub Main()
        Dim b As New WSHttpBinding(SecurityMode.Message)
        b.Security.Message.ClientCredentialType = MessageCredentialType.Windows

        Dim ea As New EndpointAddress("net.tcp://machinename:8036/endpoint")
        Dim cc As New CalculatorClient(b, ea)
        cc.Open()

        ' Alternatively, use a binding name from a configuration file generated by the
        ' SvcUtil.exe tool to create the client. Omit the binding and endpoint address 
        ' because that information is provided by the configuration file.
        ' CalculatorClass cc = new CalculatorClient("ICalculator_Binding")
    End Sub
End Class


<System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0"), System.ServiceModel.ServiceContractAttribute([Namespace]:="http://Microsoft.ServiceModel.Samples", ConfigurationName:="ICalculator")> _
Public Interface ICalculator

    <System.ServiceModel.OperationContractAttribute(Action:="http://Microsoft.ServiceModel.Samples/ICalculator/Add", ReplyAction:="http://Microsoft.ServiceModel.Samples/ICalculator/AddResponse")> _
    Function Add(ByVal n1 As Double, ByVal n2 As Double) As Double

    <System.ServiceModel.OperationContractAttribute(Action:="http://Microsoft.ServiceModel.Samples/ICalculator/Subtract", ReplyAction:="http://Microsoft.ServiceModel.Samples/ICalculator/SubtractResponse")> _
    Function Subtract(ByVal n1 As Double, ByVal n2 As Double) As Double

    <System.ServiceModel.OperationContractAttribute(Action:="http://Microsoft.ServiceModel.Samples/ICalculator/Multiply", ReplyAction:="http://Microsoft.ServiceModel.Samples/ICalculator/MultiplyResponse")> _
    Function Multiply(ByVal n1 As Double, ByVal n2 As Double) As Double

    <System.ServiceModel.OperationContractAttribute(Action:="http://Microsoft.ServiceModel.Samples/ICalculator/Divide", ReplyAction:="http://Microsoft.ServiceModel.Samples/ICalculator/DivideResponse")> _
    Function Divide(ByVal n1 As Double, ByVal n2 As Double) As Double
End Interface 'ICalculator

<System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")> _
Public Interface ICalculatorChannel
    : Inherits ICalculator, System.ServiceModel.IClientChannel
End Interface 'ICalculatorChannel

<System.Diagnostics.DebuggerStepThroughAttribute(), System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")> _
Public Class CalculatorClient
    Inherits System.ServiceModel.ClientBase(Of ICalculator)
    Implements ICalculator

    Public Sub New()
        '
    End Sub


    Public Sub New(ByVal endpointConfigurationName As String)
        MyBase.New(endpointConfigurationName)

    End Sub


    Public Sub New(ByVal endpointConfigurationName As String, ByVal remoteAddress As String)
        MyBase.New(endpointConfigurationName, remoteAddress)

    End Sub


    Public Sub New(ByVal endpointConfigurationName As String, ByVal remoteAddress As System.ServiceModel.EndpointAddress)
        MyBase.New(endpointConfigurationName, remoteAddress)

    End Sub


    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 ICalculator.Add
        Return MyBase.Channel.Add(n1, n2)

    End Function 'Add


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

    End Function 'Subtract


    Public Function Multiply(ByVal n1 As Double, ByVal n2 As Double) As Double Implements ICalculator.Multiply
        Return MyBase.Channel.Multiply(n1, n2)

    End Function 'Multiply


    Public Function Divide(ByVal n1 As Double, ByVal n2 As Double) As Double Implements ICalculator.Divide
        Return MyBase.Channel.Divide(n1, n2)

    End Function 'Divide
End Class
```

--------------------------------

### Initialize SyndicationFeed

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/how-to-create-a-basic-atom-feed

Create a new feed instance and configure metadata such as authors, categories, and descriptions.

```C#
SyndicationFeed feed = new SyndicationFeed("My Blog Feed", "This is a test feed", new Uri("http://SomeURI"), "FeedOneID", new DateTimeOffset(DateTime.Now));
feed.Authors.Add(new SyndicationPerson("someone@microsoft.com"));
feed.Categories.Add(new SyndicationCategory("How To Sample Code"));
feed.Description = new TextSyndicationContent("This is a sample that illustrates how to expose a feed using ATOM with WCF");
```

```VB.NET
Dim feed As New SyndicationFeed("My Blog Feed", "This is a test feed", New Uri("http://SomeURI"), "FeedOneID", new DateTimeOffset(DateTime.Now))
feed.Authors.Add(New SyndicationPerson("someone@microsoft.com"))
feed.Categories.Add(New SyndicationCategory("How To Sample Code"))
feed.Description = New TextSyndicationContent("This is a sample that illustrates how to expose a feed imports ATOM with WCF")
```

--------------------------------

### CommunicationObject Constructors

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/extending/understanding-state-changes

Constructors for initializing a CommunicationObject, which always starts in the Created state.

```csharp
protected CommunicationObject() : this(new object()) { … }
```

```csharp
protected CommunicationObject(object mutex) { … }
```

```csharp
protected CommunicationObject(object mutex, object eventSender) { … }
```

--------------------------------

### Service Console Output

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/transacted-msmq-binding

Example output displayed in the service console window during processing.

```Console
The service is ready.
Press <ENTER> to terminate service.

Processing Purchase Order: 7b31ce51-ae7c-4def-9b8b-617e4288eafd
        Customer: somecustomer.com
        OrderDetails
                Order LineItem: 54 of Blue Widget @unit price: $29.99
                Order LineItem: 890 of Red Widget @unit price: $45.89
        Total cost of this order: $42461.56
        Order status: Pending
```

--------------------------------

### Initialize WCF Client with Configuration

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/how-to-secure-a-service-with-windows-credentials

C# code to instantiate a generated client using a binding name from the configuration file and perform a service call.

```csharp
// 4th Procedure:
//  Using config instead of the binding-related code
// In this case, use a binding name from a configuration file generated by the
// SvcUtil.exe tool to create the client. Omit the binding and endpoint address
// because that information is provided by the configuration file.

CalculatorClient cc = new CalculatorClient("ICalculator_Binding");
cc.Open();

// Now call the service and display the results
// Call the Add service operation.
double value1 = 100.00D;
double value2 = 15.99D;
double result = cc.Add(value1, value2);
Console.WriteLine($"Add({value1},{value2}) = {result}");

// Closing the client gracefully closes the connection and cleans up resources.
cc.Close();
```

--------------------------------

### Service Output Example

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/samples/message-security-over-message-queuing

Sample console output showing client identification and order processing details.

```text
The service is ready.
Press <ENTER> to terminate service.

Client's Identity CN=client.com; ECA6629A3C695D01832D77EEE836E04891DE9D3C
Processing Purchase Order: 6536e097-da96-4773-9da3-77bab4345b5d
        Customer: somecustomer.com
        OrderDetails
                Order LineItem: 54 of Blue Widget @unit price: $29.99
                Order LineItem: 890 of Red Widget @unit price: $45.89
        Total cost of this order: $42461.56
        Order status: Pending
```

--------------------------------

### EncryptBeforeSign Security Header Structure

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/security-protocols-version-1-0

Example structure for security headers configured with EncryptBeforeSign.

```XML
<wsse:Security>
  <wsu:Timestamp>
  ...
  </wsu:Timestamp>
  <saml:Assertion>
  ...
  </saml:Assertion>
  <wsc:DerivedKeyToken>
  ...
  </wsc:DerivedKeyToken>
  <wsc:DerivedKeyToken>
  ...
  </wsc:DerivedKeyToken>
  <ds:Signature>
  ...
  </ds:Signature>
  <xenc:ReferenceList>
  ...
  </xenc:ReferenceList>
</wsse:Security>
```

```XML
<wsse:Security>
  <wsu:Timestamp>
  ...
  </wsu:Timestamp>
  <wsc:DerivedKeyToken>
  ...
  </wsc:DerivedKeyToken>
  <wsc:DerivedKeyToken>
  ...
  </wsc:DerivedKeyToken>
  <ds:Signature>
  ...
  </ds:Signature>
  <xenc:ReferenceList>
  ...
  </xenc:ReferenceList>
</wsse:Security>
```

--------------------------------

### Initialize DiscoveryProxy service host

Source: https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/how-to-implement-a-discovery-proxy

Define the probe and announcement URIs and instantiate the ServiceHost for the DiscoveryProxy.

```csharp
Uri probeEndpointAddress = new Uri("net.tcp://localhost:8001/Probe");
Uri announcementEndpointAddress = new Uri("net.tcp://localhost:9021/Announcement");

// Host the DiscoveryProxy service
ServiceHost proxyServiceHost = new ServiceHost(new DiscoveryProxyService());
```
Tokens:
Raw