AddressAccessDeniedException: HTTP could not register URL http://+:8080/

Step 1 – On running the Subscriber project, you may get an AddressAccessDenied exception (especially if you are on Windows Vista). To work around this error, launch a command prompt as administrator (right click and Run As Admin). In the command prompt, type :

netsh http add urlacl url=http://+:26836/ user=DOMAIN\UserName (do you need to lookup your username or your domain name ?).

Step 2 – What I needed was to provide local access to the address on which the client was running (the callback address). A tool called HttpNamespaceManager allowed me to grant that access to the http address+port that I needed. (See http://blogs.msdn.com/b/paulwh/archive/2007/05/04/addressaccessdeniedexception-http-could-not-register-url-http-8080.aspx for details). A quick summary of how to work around this error is given below:

1. Copy the http namespace from your DOS prompt.

2. Launch HttpNamespaces exe – Click Add – Paste the copied URL into the URL textbox that appears.

3. Grant access to the following USER GROUPS – USERS and LOCAL SERVICE. Once you add these groups, select them and check the ‘GenericExecute’ box as shown below.

Summary

Once you get past the Unhandled Exception: System.ServiceModel.AddressAccessDeniedException (using the steps above), you should be able to run the Subscriber console app (make sure you run the service first by starting the MagazineService project as shown below. You CAN run both from the same Visual Studio Solution Explorer).

The post WCF and Publish Subscribe–A Full Example: Running the Client (Subscriber) appeared first on Anuj Varma, Hands-On Technology Architect, Clean Air Activist.

Step 1 : Ensure Service Loads Ok

1. Use CRL F5 to start the Magazine service  – it should start running on a local port such as http://localhost:26836/. Click on MagazineService.svc to ensure that it is setup right (you will encounter errors if something was incorrect). The first error I encountered was related to the http binding. The default http binding is ‘BasicHttpBinding’  – and BasicHttpBinding does not support sessions (need wsDualHttpBinding for that)  
2. Inserting the following inside the <system.serviceModel> element fixed the issue                           <protocolMapping> <add scheme=“http” binding=“wsDualHttpBinding“/> </protocolMapping>
3. Once the service fires up without errors (e.g. http://localhost:26836/MagazineService.svc), we are ready to generate our proxy.

Step 2: Generate the proxy

1. Add a reference to System.ServiceModel in your Subscriber (client) project.
2. On the Start menu click All Programs, and then click Visual Studio 2010. Click Visual Studio Tools and then click Visual Studio 2010 Command Prompt (you would need to ‘Run As Administrator’ if you are not logged on as the administrator).
3. c:\Program Files\Microsoft Visual Studio 10.0\VC>svcutil /language:cs /out:generatedProxy.cs /config:app.config http://localhost:26836/MagazineService.svc
4. Copy over the two files (generatedProxy.cs and app.config) to the folder containing the client project (subscriber project) – and ‘Add Existing Items’ to the project. Your solution should look something like this at this point.                                                                                                                                                                                                                                                                                                                                                                                   

Step 3: Client (Subscriber) Code

Now that we are done with the plumbing, we are ready to code our client.  Our client is just a subscriber who wants to be notified (on its callback method) whenever a new issue is available.

1. A client class : Note that we already have a client class provided by the proxy. This is called  MagazineServiceClient.

public partial class MagazineServiceClient

     2.   A callback interface: The interface IMagazineServiceCallback is also available to us through our generated proxy.

Our client is just a subscriber who wants to be notified (on its callback method) whenever a new issue is available.

Here is the complete client code:

//The service contract is defined in generatedClient.cs, generated from the service by the svcutil tool.

//Client implementation code.

class Subscriber : IMagazineServiceCallback

{

        static void Main(string[] args)

        {

            // always create an instance context to associate the service with            

            InstanceContext siteHostContext = new InstanceContext(null, new Subscriber());

            MagazineServiceClient myClient = new MagazineServiceClient(siteHostContext);

            // create a unique callback address (if you want multiple subscribers to run on the same machine)

            WSDualHttpBinding binding = (WSDualHttpBinding)myClient.Endpoint.Binding;

            string uniqueCallbackAddress = binding.ClientBaseAddress.AbsoluteUri;

            // make it unique - append a GUID

            uniqueCallbackAddress += Guid.NewGuid().ToString();

            //uniqueCallbackAddress += 9;

            binding.ClientBaseAddress = new Uri(uniqueCallbackAddress);

            // Subcribe

            Console.WriteLine("subscribing...");

            myClient.Subscribe();

            Console.WriteLine();

            Console.WriteLine("Press ENTER to unsubscribe");

            Console.ReadLine();

            Console.WriteLine("unsubscribing...");

            myClient.Unsubscribe();

            // Closes the underlying http connection

            myClient.Close();            

        }

        public void MessageReceived(string linkToNewIssue, string issueNumber, DateTime publishDate)

        {

            Console.WriteLine("MessageRecei(item{0}, item{1}, item{2}", linkToNewIssue, issueNumber, publishDate);

        }

}

At this point, your project is complete. You have a working Service and a working client. See the next post – Running your client (adding a new subscriber and getting notified of new published events).

The post WCF and Publish Subscribe–A Full Example: Client Code appeared first on Anuj Varma, Hands-On Technology Architect, Clean Air Activist.

1. Add a new Console App (Add New Project) to the WCFPublishSubscribe solution.  Call it EventGenerator.
2. Copy over the app.config and the generatedProxy.cs to this new project.
3. Publishing an event is as simple as invoking the Publish method (PublishMagazine) on the client (proxy class)

myClient.PublishMagazine("http://www.anujvarma.com", "Vol1: Issue1", System.DateTime.Now);

class EventGenerator: IMagazineServiceCallback

    {

        static void Main(string[] args)

        {

            // always create an instance context to associate the service with            

            InstanceContext siteHostContext = new InstanceContext(null, new EventGenerator());

            MagazineServiceClient myClient = new MagazineServiceClient(siteHostContext);

            Console.WriteLine("Publishing New Issue(http://www.anujvarma.com, Vol1: Number1, )");

            myClient.PublishMagazine("http://www.anujvarma.com", "Vol1: Issue1", System.DateTime.Now);

            Console.WriteLine();

            Console.WriteLine("Press ENTER to stop publishing events");

            Console.ReadLine();

            //Closing the client gracefully closes the connection and cleans up resources

            myClient.Close();

        }

        public void MessageReceived(string linkToNewIssue, string issueNumber, DateTime publishDate)

        {

            Console.WriteLine("MessageReceived(item{0}, item{1}, item{2}", linkToNewIssue, issueNumber, publishDate);

        }

    }

The post WCF and Publish Subscribe–A Full Example: The Event Generator appeared first on Anuj Varma, Hands-On Technology Architect, Clean Air Activist.

Our event based implementation thus consists of:

1. Defining an event
2. Defining an  event handler (all the handler will do is notify the various subscribers)
3. Implement the Subscribe method
4. Implement the Unsubscribe method
5. Implement the PublishMagazine method

public class NewIssueAvailableEventArgs : EventArgs

{

    public string hyperlinkURL;

    public string issueNumber;

    public DateTime datePublished;

}

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]

public class MagazineService : IMagazineService

{

    public static event NewIssueAvailableHandler NewIssueAvailableEvent;

    public delegate void NewIssueAvailableHandler(object sender, NewIssueAvailableEventArgs e);

    // instance of eventhandler

    NewIssueAvailableHandler newIssueHandler;

    // Callback to individual clients using the ClientContract

    IClientContract callback = null;

    public void PublishMagazine(string hyperLinkToIssue, string issueNumber, DateTime datePublished)

    {

        NewIssueAvailableEventArgs eargs = new NewIssueAvailableEventArgs();

        eargs.hyperlinkURL = hyperLinkToIssue;

        eargs.issueNumber = issueNumber;

        eargs.datePublished = datePublished;

        // fire the event

        NewIssueAvailableEvent(this, eargs);

    }

    public void Subscribe()

    {

        callback = OperationContext.Current.GetCallbackChannel<IClientContract>();

        // this is the handler that we will 'unsubscribe' from later

        newIssueHandler = new NewIssueAvailableHandler(MagazineService_NewIssueAvailableEvent);

        NewIssueAvailableEvent += newIssueHandler;

    }

    public void Unsubscribe()

    {

        NewIssueAvailableEvent -= newIssueHandler;

    }

    public void MagazineService_NewIssueAvailableEvent(object sender, NewIssueAvailableEventArgs e)

    {

        callback.MessageReceived(e.hyperlinkURL, e.issueNumber, e.datePublished);

    }

}

The post WCF Publish Subscribe– A Full Example: The Service Side Part 2 (Implementation) appeared first on Anuj Varma, Hands-On Technology Architect, Clean Air Activist.

The Interface defines all the capabilities of the service. What do we really want from a Publisher service?

1. A Publish method (called PublishMagazine)
2. A Subscribe method (to allow clients to subscribe to the service)
3. An Unsubscribe method (to allow clients to unsubscribe from the service)

Those are the three main things we need from our Publisher service. As long as all we need is the Publisher to get in touch with multiple subscribers, we are all set.

However, we also need a way to notify individual clients (subscribers) who have subscribed to our service. 

This can be handled via a Callback method (called MessageReceived in our example). The Callback method is best made available as part of a separate interface (known as IClientContract).

public interface IClientContract

{

    [OperationContract(IsOneWay = true)]

    void MessageReceived(string hyperlinkToNewIssue, string issueNumber, DateTime datePublished);

}

[ServiceContract(SessionMode = SessionMode.Required, CallbackContract = typeof(IClientContract))]

public interface IMagazineService

{

    [OperationContract(IsOneWay = false, IsInitiating = true)]

    void PublishMagazine(string hyperLinkToIssue, string issueNumber, DateTime datePublished);

    [OperationContract(IsOneWay = false, IsTerminating = true)]

    void Subscribe();

    [OperationContract(IsOneWay = false, IsTerminating = true)]

    void Unsubscribe();

}

public interface IClientContract

{

    [OperationContract(IsOneWay = true)]

    void MessageReceived(string hyperlinkToNewIssue, string issueNumber, DateTime datePublished);

}

The post WCF Publish Subscribe–A Full Example – The Service Side Part 1 (Interface) appeared first on Anuj Varma, Hands-On Technology Architect, Clean Air Activist.

What do you (the magazine publisher) need to do?

You need to implement the publisher side of the publish-subscribe pattern.

What do your customers (subscribers) need to do?

Each customer needs to implement the subscriber part of the publish-subscribe pattern.

The post WCF and Publish Subscribe– A Full Example: Introduction appeared first on Anuj Varma, Hands-On Technology Architect, Clean Air Activist.