BindingElement Class

Definition

Namespace:

System.ServiceModel.Channels

Assembly:

System.ServiceModel.Primitives.dll

Package:

System.ServiceModel.Primitives v8.1.0

Source:

BindingElement.cs

The elements of the bindings that build the channel factories and channel listeners for various types of channels that are used to process outgoing and incoming messages.

public ref class BindingElement abstract

public abstract class BindingElement

type BindingElement = class

Public MustInherit Class BindingElement

Inheritance

Object

BindingElement

Derived

System.ServiceModel.Channels.CompositeDuplexBindingElement

System.ServiceModel.Channels.ContextBindingElement

System.ServiceModel.Channels.HttpCookieContainerBindingElement

System.ServiceModel.Channels.MessageEncodingBindingElement

System.ServiceModel.Channels.OneWayBindingElement

System.ServiceModel.Channels.PeerResolverBindingElement

System.ServiceModel.Channels.PrivacyNoticeBindingElement

System.ServiceModel.Channels.ReliableSessionBindingElement

System.ServiceModel.Channels.SecurityBindingElement

System.ServiceModel.Channels.StreamUpgradeBindingElement

System.ServiceModel.Channels.TransactionFlowBindingElement

System.ServiceModel.Channels.TransportBindingElement

System.ServiceModel.Channels.UseManagedPresentationBindingElement

System.ServiceModel.Discovery.DiscoveryClientBindingElement

Examples

The following example shows how to add a transport binding element to a custom binding and then build a channel listener that can accept incoming messages.

CustomBinding binding = new CustomBinding();
binding.Elements.Add(new HttpTransportBindingElement());
BindingParameterCollection paramCollection = new BindingParameterCollection();
IChannelListener<IReplyChannel> listener = binding.BuildChannelListener<IReplyChannel>
    (new Uri("http://localhost:8000/ChannelApp"), paramCollection);

listener.Open();
IReplyChannel channel = listener.AcceptChannel();
Console.WriteLine("Listening for messages");
channel.Open();
RequestContext request = channel.ReceiveRequest();
Message msg = request.RequestMessage;
Console.WriteLine("Message Received");
Console.WriteLine("Message Action: {0}", msg.Headers.Action);

if (msg.Headers.Action == "hello")
{
    Message reply = Message.CreateMessage(MessageVersion.Default, "wcf");
    request.Reply(reply);
}

msg.Close();
channel.Close();
listener.Close();

Dim binding As New CustomBinding()
binding.Elements.Add(New HttpTransportBindingElement())
Dim paramCollection As New BindingParameterCollection()

Dim listener As IChannelListener(Of IReplyChannel)
listener = binding.BuildChannelListener(Of IReplyChannel)(New Uri("http://localhost/channelApp"), paramCollection)

listener.Open()
Dim channel As IReplyChannel = listener.AcceptChannel()
Console.WriteLine("Listening for messages")
channel.Open()
Dim request As RequestContext = channel.ReceiveRequest()
Dim msg As Message = request.RequestMessage
Console.WriteLine("Message Received")
Console.WriteLine("Message Action: {0}", msg.Headers.Action)

If (msg.Headers.Action = "hello") Then

    Dim reply As Message = Message.CreateMessage(MessageVersion.Default, "wcf")
    request.Reply(reply)
End If

msg.Close()
channel.Close()
listener.Close()

Remarks

A binding consists of an ordered set of binding elements that inherit from this abstract base class. The TransportBindingElement class inherits from the BindingElement class.

Creating a binding and binding element for your transport is optional if you are just using the channel model. It is possible to do everything you need through the channel factory and listener as long as they are made public.

The Windows Communication Foundation (WCF) service model uses a factory pattern where the binding is used to create the channel stack. If you want to use the WCF service model, then using a transport binding element is required. Placing this binding element into a binding is a good practice because it removes the requirement for users to create their own custom binding for your transport. It is best to create both a binding and binding element, and hide the channel factory and listener inside the assembly.

On the sending side, a binding is used to build a IChannelFactory, which in turn builds a channel stack and returns a reference to the top channel in the stack. The application can then use this channel to send messages.

Similarly, on the receiving side a binding is used to build a IChannelListener, which listens for incoming messages. The IChannelListener provides messages to the listening application by creating channel stacks and handing the application a reference to the top channel. The application then uses this channel to receive incoming messages.

Note

If you are adding message headers that must be encrypted you must return a ChannelProtectionRequirements instance with your requirements from the GetProperty<T>(BindingContext) method when asked for ChannelProtectionRequirements.

Constructors

BindingElement()	Initializes a new instance of the BindingElement class.
BindingElement(BindingElement)	Initializes a new instance of the BindingElement class from a specified binding element.

Methods

BuildChannelFactory<TChannel>(BindingContext)	Initializes a channel factory for producing channels of a specified type from the binding context.
CanBuildChannelFactory<TChannel>(BindingContext)	Returns a value that indicates whether the binding element can build a channel factory for a specific type of channel.
Clone()	When overridden in a derived class, returns a copy of the binding element object.
Equals(Object)	Determines whether the specified object is equal to the current object. (Inherited from Object)
GetHashCode()	Serves as the default hash function. (Inherited from Object)
GetProperty<T>(BindingContext)	When overridden in a derived class, returns a typed object requested, if present, from the appropriate layer in the binding stack.
GetType()	Gets the Type of the current instance. (Inherited from Object)
MemberwiseClone()	Creates a shallow copy of the current Object. (Inherited from Object)
ToString()	Returns a string that represents the current object. (Inherited from Object)