CODEWITHSUNDEEP
c#wcf
Ben
Ben

Reputation: 1221

Constructor not being called in type derieved from DuplexChannelFactory<T>

I have question about the article in here. The related code is as follow.

    public CustomClientChannel(string configurationPath) : base(typeof(T))
    {
        this.configurationPath = configurationPath;
        base.InitializeEndpoint((string)null, null);
    }

    protected override ServiceEndpoint CreateDescription()
    {

        ServiceEndpoint serviceEndpoint = base.CreateDescription();
        ExeConfigurationFileMap map = new ExeConfigurationFileMap();
        map.ExeConfigFilename = this.configurationPath;
        Configuration config = ConfigurationManager.OpenMappedExeConfiguration(map, ConfigurationUserLevel.None);
        ServiceModelSectionGroup group = ServiceModelSectionGroup.GetSectionGroup(config);
        ChannelEndpointElement selectedEndpoint = null;
        ......
    }

The first function is the constructor of the class and the second one overloads the CreateDescription function in DuplexChannelFactory since the class inherents from DuplexChannelFactory.

However, when I use this class to create an object, the code runs directly into CreateDescription().

Therefore, even though I pass a configurationPath to the constructor, the this.configurationPath is still null.

If I inherent CustomClientChannel class from ChannelFactory, then it works fine.

Please help to see what is wrong and what is the difference between ChannelFactory and DuplexChannelFactory? I am using netTcpBinding. Thank you.

Upvotes: 1

Views: 136

Answers (2)

GazTheDestroyer
GazTheDestroyer

Reputation: 21251

Your constructor is calling into a base constructor that takes a single type.

 : base(typeof(T))

Both ChannelFactory<T> and DuplexChannelFactory<T> implement a protected constructor that takes a single type, but they are different.

ChannelFactory<T> wants the channel type.

DuplexChannelFactory<T> want the callback instance type

In other words, they do completely different things and can have completely different code paths. Protected constructors are to be used by derived types only, and generally infer some level of knowledge of how the class hierarchy works.

You would be better picking the public constructor that you would normally use, and calling that instead. If that is not possible then you need to work out the appropriate DuplexChannelFactory constructor to call instead.

Upvotes: 1

tom redfern
tom redfern

Reputation: 31760

Let's start with

what is the difference between ChannelFactory and DuplexChannelFactory?

First it is necessary to understand the difference between simplex and duplex communications in WCF.

A simplex connection is like sending a text message and then receiving a delivery notification - even though at a lower transport level there may be multiple calls between your phone and the carrier, from a communications level, you are sending the text message in one direction only.

A duplex connection is like making a phone call, you are able to send voice data to your carrier, and your carrier can send voice data in the other direction at the same time. This requires a simplex channel open in both directions.

Both ChannelFactory and DuplexChannelFactory can be used to create a client channel to a service.

Which one you choose is down to whether the service you are calling exposes simplex or duplex service operations, and whether you, as a comsumer, need to consume these operations.

If the service exposes normal (i.e, simplex) operations, for example:

void DoCoSomething(int x);

List<Things> GetThings();

etc...

...then you can consume these operations with ChannelFactory.

If the service exposes a callback contract:

public interface IMyDuplexCallback
{
    [OperationContract(IsOneWay = true)]
    void NotifyMeOf(string message);
}

for example, in order to send notifications or message of some kind to the consumers, and you as a consumer want to take advantage of this, you can use the DuplexChannelFactory to call the service (after implementing the callback contract on your client of course).

As a general rule, duplex communication in WCF is complex at best, and is therefore best avoided.

Appreciate this does not address your original question.

Upvotes: 0

Related Questions