11 Visual Studio 2010 Training Kit - Lab Whats New In WCF 4.docx

7/26/2019 11 Visual Studio 2010 Training Kit - Lab Whats New In WCF 4.docx

1/85

Hands-On Lab

Whats new with WCF in .NET 4?

Lab version: 1.0.0

Last updated: 12/5/2014


2/85

Contents

OVERVIEW ................................................................................................................................................... 4

SETUP .......................................................................................................................................................... 7

Task 1Installing the Web Platform, Visual Studio and Windows Server AppFabric Beta 2 .............. 7

EXERCISE 1: SERVICE WITHOUT CONFIGURATION ............................................................................ 7

Task 1Creating the Web Site ............................................................................................................. 7

Task 2Creating the WCF Service ........................................................................................................ 9

Exercise 1: Verification 12

EXERCISE 2: SERVICE BEHAVIORS ...................................................................................................... 13

Task 0Opening the Solution ............................................................................................................ 14

Task 1Enabling Behaviors ................................................................................................................ 14


EXERCISE 3: DEFAULT BINDING ............................................................................................................ 17


Task 1Changing the Default Binding ............................................................................................... 18


EXERCISE 4: SERVICE DISCOVERY ....................................................................................................... 19


Task 1Configuring Service Discovery for the DiscoveryChat Application........................................ 19

Task 2Enabling ad hoc Discovery .................................................................................................... 22


EXERCISE 5: METADATA EXTENSIONS ................................................................................................ 28


Task 1Adding an EndpointDiscoveryBehavior with Extensions ...................................................... 29


EXERCISE 6: DISCOVERY ANNOUNCEMENTS ..................................................................................... 33


Task 1Enabling Announcement Endpoint ....................................................................................... 34



3/85

EXERCISE 7: DISCOVERY PROXY .......................................................................................................... 40


Task 1 Creating a DiscoveryProxy .................................................................................................... 41

Task 2Modifying the DiscoveryChat Application to use Managed Discovery ................................. 58


EXERCISE 8: PROTOCOL BRIDGING ..................................................................................................... 63


Task 1Trying the Calculator ............................................................................................................. 64

Task 2Adding the Router Service .................................................................................................... 65

Task 3Modifying the Client to Enable Routed HTTP ....................................................................... 67


EXERCISE 9: CONTENT BASED ROUTING ............................................................................................ 70Task 0Opening the Solution ............................................................................................................ 71

Task 1Modifying the CalculatorClient to Add a Custom Header ..................................................... 71

Task 2Adding a New Entry to the Filter Table ................................................................................. 72


EXERCISE 10: BACKUP LISTS ................................................................................................................ 75


Task 1Adding a Bad Endpoint .......................................................................................................... 75

Task 2Observing the Routing Fail .................................................................................................... 76

Task 3Enabling Backup Lists ............................................................................................................ 77


EXERCISE 11: DEPLOYING THE WEB APPLICATION .......................................................................... 78


Task 1Creating the Deployment Package ........................................................................................ 79

Task 2Deploying the Package .......................................................................................................... 80

Task 3Changing the Client Application Configuration ..................................................................... 82


SUMMARY .................................................................................................................................................. 84


4/85

Overview

Windows Communication Foundation (WCF) in .NET 4 includes three new features areas.

Simplified Configuration

Service Discovery

Service Routing

In this lab, you will get a chance to try out these new features and learn how they work. You will also

experience the improved hosting and deployment capabilities of the new Windows Server AppFabric

Beta 2.

Do I have to do all the exercises?

This lab is long. To do all of it will probably take close to 2 hours. The lab is designed so that each

exercise is independent of the others. Just open the solution found under the Begin folder for the

exercise. For example, if you wanted to learn how to use Service Discovery you would start with

Exercise 4 and open the solution from the Source\Ex4-ServiceDiscover\Beginfolder

Objectives

In this Hands-On Lab, you will learn:

How simplifications to configuration make WCF easier to use

How to use Service Discovery to locate services

How to use Service Routing

How to Deploy and Monitor services using AppFabric

System Requirements

You must have the following items to complete this lab:

Microsoft Visual Studio 2010

Microsoft .NET Framework 4

Windows Server AppFabric -Download
http://msdn.microsoft.com/en-us/windowsserver/ee695849.aspxhttp://msdn.microsoft.com/en-us/windowsserver/ee695849.aspxhttp://msdn.microsoft.com/en-us/windowsserver/ee695849.aspxhttp://msdn.microsoft.com/en-us/windowsserver/ee695849.aspx


5/85

Note: This Lab targets Visual Studio 2010 and .NET Framework 4. The current version of

Windows Server AppFabric, that is Beta 2, requires .NET Framework 4 RC.

Therefore, the portion of this Lab that shows AppFabric features may not work as expectedly

until a new version of AppFabric is released.

Setup

All the requisites for this lab are verified using the Dependency Checker. To make sure that everything is

correctly configured, follow these steps:

Note:To perform the setup steps you need to run the scripts in a command window with

administrator privileges.

1. Run the Dependency checker for the Training Kit if you have not done it previously. To do this,

run the CheckDependencies.cmdscript located under the \Source\Setupfolder. Install any pre-

requisites that are missing (rescanning if necessary) and complete the wizard.

Note:For convenience, much of the code you will be managing along this hands-on lab is available as

Visual Studio code snippets.

Exercises

This Hands-On Lab comprises the following exercises.

Simplified Configuration

1. Simplified Configuration

2. Service Behavior

3. Protocol Mapping

Service Discovery

4. Service Discovery

5. Metadata Extensions

6. Discovery Announcements

7. Discovery Proxy

Routing


6/85

8. Service Routing

9. Content Based Routing

10.Backup Lists

AppFabric

11.Deploying the Web Application

Starting Materials

This Hands-On Lab includes the following starting materials.

Visual Studio solutions. Depending on the exercise you will find Visual Studio solutions for C#

and Visual Basic that you can use as starting point for the exercises.

What if I get stuck?

The source code that accompanies this hands-on lab includes an end folder where you can find a Visual

Studio solution with the code that you would obtain if you complete the steps in each exercise. You

can use this solution as a guide if you need additional help working through the exercises.

Next Step

Setup


7/85

Setup

Task 1Installing the Web Platform, Visual Studio and Windows Server AppFabric Beta 2

1. Download theMicrosoft Web Platform installer

2. Install the recommended Web Platform options plus the following

a. ASP.NET

b. .NET Extensibility

c. Web Deployment Tool 1.0

3. Download and Install Windows Server AppFabric Beta 2

a. Check only the Worker Feature and Accept all the defaults

Next Step

Exercise 1: Service without Configuration

Exercise 1: Service without

Configuration

In WCF 4 you can create a service without any configuration at all. In this exercise, you will create a

working WCF service with no configuration.

Task 1Creating the Web Site

1. Start Microsoft Visual Studio 2010from Start | All Programs | Microsoft Visual Studio 2010.

2. Create a new Empty ASP.NET Web Application.

Setting Value

Language Visual C# or Visual Basic

Target Framework .NET Framework 4

Installed Templates Web

Template ASP.NET Empty Web Application
http://www.microsoft.com/web/http://www.microsoft.com/web/http://www.microsoft.com/web/http://www.microsoft.com/web/


8/85

Name WCF4Configuration

Location Source\Ex1-NoConfig\Begin

Solution Name WCF4Configuration

Figure 1

Create a new Empty ASP.NET Web Application C#


9/85

Figure 2

Create a new Empty ASP.NET Web Application Visual Basic

Task 2Creating the WCF Service

1. Right-click the WCF4Configurationweb site, and select Add/ NewItem.

Setting Value


Installed Templates Web

Template WCF Service

Name EchoService.svc


10/85

Figure 3

Create a new service named EchoService.svc C#

Figure 4

Create a new service named EchoService.svc Visual Basic


11/85

2. Open IEchoServiceand modify it as shown

(Code Snippet - What is new in WCF4 Lab - IEchoService Interface CSharp)

C#[ServiceContract]

publicinterfaceIEchoService

{

[OperationContract]

stringEcho(stringmessage);

}

(Code Snippet - What is new in WCF4 Lab - IEchoService Interface VB)

Visual Basic

PublicInterfaceIEchoService

FunctionEcho(ByValmessage AsString) AsString

EndInterface

3. Right-click EchoService.svc,and select View Code

4. Add the following namespace

C#

using System.Globalization;

Visual Basic

Imports System.Globalization

5. Delete the DoWorkmethod and modify EchoServiceto implement the Echo operation as shown

(Code Snippet - What is new in WCF4 Lab - Echo method CSharp)

C#

publicstringEcho(stringmessage)

{

if(string.IsNullOrEmpty(message))

thrownewArgumentNullException("message");


12/85

returnstring.Format(CultureInfo.InvariantCulture, "Echo: {0}", message);

}

(Code Snippet - What is new in WCF4 Lab - Echo method VB)

Visual Basic

Public FunctionEcho(ByValmessage As String) As String Implements

IEchoService.Echo

If(String.IsNullOrEmpty(message)) Then

ThrowNewArgumentNullException("message")

End If

Return String.Format(CultureInfo.InvariantCulture, "Echo: {0}", message)

End Function

6. Open web.config and comment out the entire section by selecting itand pressing CTRL+K,CTRL+C

Next Step

Exercise 1: Verification


1. Right-click EchoService.svc,and select View in Browser, to open the service in a new browser

instance.

2. You should see a service with metadata publishing disabled


13/85


14/85

In WCF4, when you create an unnamed service behavior it applies to all unnamed services. In this

exercise, you will enable some service behaviors.

Task 0Opening the Solution

To begin this exercise you can use the solution you finished from Exercise 1. Alternatively, you can

follow the following steps to begin with Exercise 2.

1. Open the starting solution for Exercise 2 located under the Source\Ex2-

ServiceBehavior\Begin (choosing the folder that matches the language of your preference.)

Use it as the starting point for this exercise.

2. Press CTRL+SHIFT+B to build the solution.

Task 1Enabling Behaviors

1. Open web.config

2. Uncomment the section. Your service will now have the

serviceMetadata behavior and serviceDebug behavior enabled

What services will this behavior apply to?

Services without named configuration get the default behaviors declared in web.config. If you

want a service to have different behaviors add a tag and define a named behavior.

Next Step



1. Right-click EchoService.svc,and select View in Browser, to open the service in a new browser

instance.

2. You should now see a service page with a link to the WSDL because of the enabled

serviceMetaDatabehavior


15/85

Figure 6

EchoService now has metadata enabled

3. Copy the URL of the service from the browser address bar.

4. Start the WCF Test Client. To do this, open a Visual Studio Command Prompt (2010), type the

following command, and press Enter.

Visual Studio Command Prompt (2010)

C:\>WCFTestClient

5. In the WCF Test Client select File / Add Service past the URL from the browser into the endpoint

address.

Figure 7

Add the service to the WCF Test Client


16/85

6. After the service has been loaded, double-click the Echo()method, set the value to Test, and

click Invoke. The service will echo back Echo: Test

7. Invoke the service again clear the value Test, and click Invoke with an empty value

Figure 8

The server reports an internal error

8. When debugging your service it can be helpful to see the exception details. Switch back to

Visual Studio 2010, open the web.config file and change the serviceDebug behavior to set the

includeExceptionDetailInFaults attribute to true.

XML

9. Save web.configthis will cause the app domain to recycle.

10.Switch back to the WCF Test Client.

11. Invoke the service again with an empty valuecheck the Start a new proxy checkbox,and click

Invoke.

12.This time you will see the exception message in the WCF Test Client because the serviceDebug

behavior.


17/85

Figure 9

The serviceDebug behavior including exception details

Next Step

Exercise 3: Default Binding

Exercise 3: Default Binding

In the previous exercise, you were able to create and deployed a WCF Workflow Service Application that

uses a default service configuration. A default endpoint for HTTP using basicHttpBindingwas added to

the service when this one was opened. In this exercise, you will change that default endpoint to use the

wsHttpBinding.


To begin this exercise, you can use the solution you finished from Exercise 2. Alternatively, you can



ProtocolMapping\Begin (choosing the folder that matches the language of your

preference.) Use it as the starting point for this exercise.



18/85

Task 1Changing the Default Binding

In this task, you will modify the protocol mapping for the default service configuration to use

wsHttpBinding for addresses that use the http scheme.

1. Open web.config

2. Add the section as shown

(Code Snippet - What is new in WCF4 LabprotocolMapping XML)

XML

Next Step



1. Right-click EchoService.svc, and select View in Browser, to open the service in a new browser

instance.

2. Click the link for the WSDL of the service

Figure 10Click on link for the WSDL of the service

3. You should see WSDL similar to the following


19/85

Figure 11

WSDL based on the wsHttpBinding

Next Step

Exercise 4: Service Discovery

Exercise 4: Service Discovery

In this exercise, you will add an ad hoc discovery mechanism to the DiscoveryChat program using

System.ServiceModel.Discovery, an implementation of the WS-Discovery protocol. In order for a

service to be discoverable in an ad hoc manner, it needs to respond to incoming probe messages. Ad

hoc discovery implies that these probe messages come in through a well-known port over UDP

multicast.


This exercise uses a new begin solution


ServiceDiscovery\Begin (choosing the folder that matches the language of your



Task 1Configuring Service Discovery for the DiscoveryChat Application

DiscoveryChatis a chat application that automatically discovers users on the network using ad hoc or

managed discovery via a proxy.


20/85

Figure 12

Two simple chat windows with no discovery enabled

The first thing you need to do is to enable discovery in the simple chat application.

1. To enable discovery, you need to add a service behavior on the service that will be discoverable.

Open the app.configconfiguration file from the DiscoveryChatproject.

2. Add a new Service Behavior named DiscoveryBehaviorinside the element.

(Code Snippet - What is new in WCF4 LabserviceDiscovery config XML)

XML

3. Modify the service description by adding the behaviorConfigurationattribute referencing the

DiscoveryBehaviorjust created.

XML


21/85

4. Next, you need to add a UDP discovery endpoint. This is where the discovery probe messages

will be processed.

Probe Messages

A Probe message is a WS-Discovery message used by a client to search for services on thenetwork by service type. For more information about Probe messages, see section 5.2 of the

WS-Discovery Specification.

(Code Snippet - What is new in WCF4 LabudpDiscoveryEndpoint XML)

XML

Making Services Discoverable

Adding the DiscoveryBehavior makes your service discoverable. The UDP endpoint (specified

by the attribute kind = udpDiscoveryEndpoint) is where the discovery component will listen

for discovery messages.
http://go.microsoft.com/fwlink/?LinkId=87841http://go.microsoft.com/fwlink/?LinkId=87841http://go.microsoft.com/fwlink/?LinkId=87841


22/85

Task 2Enabling ad hoc Discovery

In this task, you will add code to asynchronously search for other chat users on the same subnet using

service discovery. In order to utilize discovery functionality you will need to add a reference to

System.ServiceModel.Discovery to your project and add the associated namespace directive for

System.ServiceModel.Discovery as well.

Note: This has already been done for you in this exercise.

1. Open SimpleChatin code view by clicking on it, and pressing F7

2. Locate the AdHocDiscoverymethod stub and add the following code. This code will initiate

discovery looking for services that implement the ISimpleChatServicecontract and then, as

services are found, it will add them to the list of available services.

(Code Snippet - What is new in WCF4 Lab AdHocDiscovery Method CSharp)

C#

privatevoidAdHocDiscovery()

{

this.discoveryClient = newDiscoveryClient(newUdpDiscoveryEndpoint());

this.discoveryClient.FindProgressChanged +=

new

EventHandler(this.OnFindProgressChanged);

this.discoveryClient.FindCompleted +=

newEventHandler(this.OnFindCompleted);

// Setup the form for discovery

this.ShowDiscoveryInProgress( true);

// Do async discovery

this.discoveryClient.FindAsync( new

FindCriteria(typeof(ISimpleChatService)));

}

(Code Snippet - What is new in WCF4 Lab AdHocDiscovery Method VB)

Visual Basic

PrivateSubAdHocDiscovery()

Me._discoveryClient = NewDiscoveryClient(NewUdpDiscoveryEndpoint())

AddHandler _discoveryClient.FindProgressChanged, AddressOf

OnFindProgressChanged


23/85

AddHandler _discoveryClient.FindCompleted, AddressOfOnFindCompleted

' Setup the form for discovery

Me.ShowDiscoveryInProgress(True)

' Do async discovery

Me._discoveryClient.FindAsync( New

FindCriteria(GetType(ISimpleChatService)))

EndSub

Using DiscoveryClient

The discovery process can be started either synchronous or asynchronously by using the Find

or FindAsyncmethods respectively. Furthermore, you can also add a DynamicEndpoint to your

application that searches performs discovery under the covers. In this application, you are

using the FindAsyncmethod because the asynchronous operation allows the chat peers to be

added as theyre discovered.

During discovery, you can register some events handlers. For example, FindProgressChanged

is invoked each time one of service endpoints has been discovered. If you want to be notified

when the discovery process is finished, then the handlerFindCompletedshould be used.

3. Implement the OnFindProgressChangedand OnFindCompletedhandlers as shown in the

following code by pasting it below the AdHocDiscovery() method implementation.

(Code Snippet - What is new in WCF4 Lab DiscoveryClient Event Handlers CSharp)

C#

privatevoidOnFindProgressChanged(objectsender,

FindProgressChangedEventArgs e)

{

this.PopulateUserList(e.EndpointDiscoveryMetadata);

}

privatevoidOnFindCompleted(objectsender, FindCompletedEventArgse)

{

if(e.Cancelled)

{

this.ShowStatus("Discovery cancelled");

}

elseif(e.Error != null)

{

this.discoveryClient.Close();

MessageBox.Show(


24/85

e.Error.Message,

this.Text,

MessageBoxButtons.OK,

MessageBoxIcon.Information,

MessageBoxDefaultButton.Button1,

(MessageBoxOptions)0);

}

else

{

if(this.discoveryClient.InnerChannel.State ==

CommunicationState.Opened)

{

this.discoveryClient.Close();

}

}

this.discoveryClient = null;

this.ShowDiscoveryInProgress( false);}

(Code Snippet - What is new in WCF4 Lab DiscoveryClient Event Handlers VB)

Visual Basic

PrivateSubOnFindProgressChanged(ByValsender AsObject, ByVale As

FindProgressChangedEventArgs)

Me.PopulateUserList(e.EndpointDiscoveryMetadata)

EndSub

PrivateSubOnFindCompleted(ByValsender AsObject, ByVale AsFindCompletedEventArgs)

Ife.Cancelled Then

Me.ShowStatus("Discovery cancelled")

ElseIfe.Error IsNotNothingThen

Me._discoveryClient.Close()

MessageBox.Show(e.Error.Message, Me.Text, MessageBoxButtons.OK,

MessageBoxIcon.Information, MessageBoxDefaultButton.Button1, CType(0,

MessageBoxOptions))

Else

IfMe._discoveryClient.InnerChannel.State = CommunicationState.Opened

Then

Me._discoveryClient.Close()

EndIf

EndIf

Me._discoveryClient = Nothing

Me.ShowDiscoveryInProgress(False)

EndSub


25/85

4. Press Ctrl+Shift+Bto build the solution.

Watch Out

DiscoveryChat will open an HTTP endpoint. If you try to do this without first creating a URL

ACL, you will get an AddressAccessDeniedException.

Figure 13AddressAccessDeniedException

5. Create a URL ACL for port 8000. To do this

a. Open a command prompt as administrator

b. Run the SetUrlACL.cmd file from the Source\Setup folder as shown

Administrator Command Prompt

SetURLACL.cmd 8000

SetURLACL.cmd

This script and the matching DelURLACL.cmd file are useful tools for managing URL ACLs.


26/85

Next Step



1. Press Ctrl+F5to start an instance of the DiscoveryChat.exeapplication without debugging.

2. Switch back to Visual Studio and press Ctrl+F5again to launch another instance of the

DiscoveryChat.exe application.

3. Switch to one of the instances of DiscoveryChat.exe,and setup the chat as follows:

a. User Name: Fred

b. Click Sign In

Figure 14

Sign in as Fred


27/85

Note:Windows Firewall may prompt you to allow the Chat client access to use the network. It

is safe to allow this.

4. Switch to the other DiscoveryChat.exeinstance, and setup the chat as follows:

a. Username: Wilma

b. Click Sign In

5. When the Wilma instance signs in, it will do ad hoc discovery immediately and locate the Fred

instance.

6. Double-click the URI in the available users list to start a chat with Fred.

a. Send Message Text: Hi Fred

b. Click Send

7. When you start the chat, you will see Wilma appear in the user list on the Fred Discovery chat

window.


28/85

Figure 15

Two instances of DiscoveryChat application that discovered each other

8. Close both instances of the DiscoveryChat application.

Next Step

Exercise 5: Metadata Extensions

Exercise 5: Metadata Extensions


29/85

The chat application works ok, but you may have noticed an issue. When Wilma discovered other chat

instances all you knew about them was the Uri of the service endpoint. Therefore, her chat window

shows a chat with the host machine name. Fred, on the other hand, knew that the chat message came

from Wilma because the chat message included her name. If you could add the name along with the

discovery messages, it would be possible to display the names in the user box instead of the endpoints.

In this exercise, you will learn how you can extend the metadata used in WS-Discovery to supply

additional information (such as the username used for the chat session).





MetadataExtensions\Begin (choosing the folder that matches the language of your



Task 1Adding an EndpointDiscoveryBehavior with Extensions

1. Open the SimpleChat class in code view from the DiscoveryChatproject. You can open the code

view by selecting the file, and pressing F7.

2. You can add XML to the endpoint metadata when responding to a discovery probe. To do this,

you will need to add namespaces directives.

(Code Snippet - What is new in WCF4 Lab ServiceModel.Description CSharp)

C#

using System.ServiceModel.Description;

(Code Snippet - What is new in WCF4 Lab ServiceModel.Description VB)

Visual Basic

ImportsSystem.ServiceModel.Description

3. Locate the OpenServicesmethod, and modify it as shown in the following code. Here you are

creating an EndpointDiscoveryBehavior instance, and as part of that behavior you are a adding

an XML element, in this case the user name to the extension collection. This extension is sent

along with the responses to clients looking for that endpoint. Lastly, you are applying that

behavior to your service endpoint.

(Code Snippet - What is new in WCF4 Lab OpenServices Method CSharp)

C#

privatevoidOpenServices()


30/85

{

// Create a singleton instance for the host

ChatServicechatService = newChatService(this);

chatServiceHost = newServiceHost(chatService, this.localAddress);

// Create a discovery behavior

EndpointDiscoveryBehavior endpointDiscoveryBehavior = new

EndpointDiscoveryBehavior();

// Add an extension element with the username

endpointDiscoveryBehavior.Extensions.Add(

newXElement(

"root",

newXElement("Name", this.userName)));

// Find the endpoint

ServiceEndpointsimpleEndpoint =

this.chatServiceHost.Description.Endpoints.Find( typeof(ISimpleChatService));

// Add your behavior to the endpoint before opening it

simpleEndpoint.Behaviors.Add(endpointDiscoveryBehavior);

ShowStatus("Opening chat service...");

chatServiceHost.BeginOpen(

(result) =>

{

chatServiceHost.EndOpen(result);

ShowStatus("Chat service ready");

},null);

}

(Code Snippet - What is new in WCF4 Lab OpenServices Method VB)

Visual Basic

PrivateSubOpenServices()

' Create a singleton instance for the host

DimchatService AsNewChatService(Me)

Me.chatServiceHost = NewServiceHost(chatService, Me._localAddress)

' Create a discovery behavior

DimendpointDiscoveryBehavior = NewEndpointDiscoveryBehavior()

' Add an extension element with the username

endpointDiscoveryBehavior.Extensions.Add(

NewXElement(

"root",


31/85

NewXElement("Name", Me._userName)))

' Find the endpoint

DimsimpleEndpoint =

Me.chatServiceHost.Description.Endpoints.Find( GetType(ISimpleChatService))

' Add your behavior to the endpoint before opening it

simpleEndpoint.Behaviors.Add(endpointDiscoveryBehavior)

Me.ShowStatus("Opening chat service...")

Me.chatServiceHost.BeginOpen( Sub(result)

chatServiceHost.EndOpen(result)

Me.ShowStatus("Chat service ready")

EndSub, Nothing)

EndSub

4. Now that the name is sent along with service endpoint information, you need to modify thePopulateUserListmethod to invoke the GetPeerName method. The GetPeerNamemethod

returns the first node named Name from the extension metadata . The PeerUserclass will use

it as the display name in the list box. To do this, replace the current call to the AddUsermethod

with the following one.

C#

privatevoidPopulateUserList(

EndpointDiscoveryMetadata endpointDiscoveryMetadata)

{

if(!EndpointIsSelf(endpointDiscoveryMetadata.Address.Uri))

{this.AddUser(newPeerUser(GetPeerName(endpointDiscoveryMetadata),

endpointDiscoveryMetadata.Address));

}

}

Visual Basic

PrivateSubPopulateUserList(ByValendpointDiscoveryMetadata As

EndpointDiscoveryMetadata)

IfNot(Me.EndpointIsSelf(endpointDiscoveryMetadata.Address.Uri)) Then

Me.AddUser(NewPeerUser(GetPeerName(endpointDiscoveryMetadata),endpointDiscoveryMetadata.Address))

EndIf

EndSub



32/85

Next Step



1. Press Ctrl+F5to start an instance of the DiscoveryChatapplication without debugging.

2. Switch back to Visual Studio, and press Ctrl+F5again to launch another instance of the

application.

3. Switch to one of the instances and setup the chat as follows:

a. User Name: Fred

b. Click Sign In

4. Switch to the other DiscoveryChatinstance and setup the chat as follows:

a. User Name: Wilma

b. Click Sign In

5. Wilmas chat window will discover Freds after signing in. Switch to Freds chat window and

click on the Discover Usersbutton to find Wilma.

6. You should see the other instances username appear in the Available Userspane. You can

double-click on it to start a chat.


33/85

Figure 16

Extensions allow us to send the username in discovery metadata

7. Close both instances of the DiscoveryChatapplication.

Next Step

Exercise 6: Discovery Announcements

Exercise 6: Discovery Announcements

Most chat applications notify you when other users sign in. This application can discover other users but

it would be better if you were notified when other users sign in. Discovery supports this feature with

announcements. Using Discovery APIs service can announce their presence on the network; this

functionality is used in the chat applications to notify peers of their arrival.





34/85


DiscoveryAnnouncements\Begin (choosing the folder that matches the language of your



Task 1Enabling Announcement Endpoint

1. Open the App.configfile in the DiscoveryChatproject.

2. To take advantage of announcements, you will need to add an announcement endpoint. To do

this, locate the DiscoveryBehaviorbehavior you added earlier in this lab and modify it as shown

in the following code.

(Code Snippet - What is new in WCF4 LabDiscoveryBehavior udpEndpoint XML)

XML

Announcement Endpoint

Adding an announcement endpoint to the discovery service behavior creates a default

announcement client for the service. This ensures that the service will send an online and

offline announcement when the service is opened and closed respectively, the

announcements will be sent out on the endpoint specified.

3. Now you need to add an announcement service to your code to receive announcement

messages. Open SimpleChat.cs(C#) or SimpleChat.vb(Visual Basic), and declare the following

member fields; you can do that after the discoveryClientmember declaration.

(Code Snippet - What is new in WCF4 Lab AnnouncementService Member CSharp)

C#

privateAnnouncementServiceannouncementService;

privateServiceHostannouncementServiceHost;

(Code Snippet - What is new in WCF4 Lab AnnouncementService Member VB)


35/85

Visual Basic

PrivateannouncementService As AnnouncementService

PrivateannouncementServiceHost As ServiceHost

4. Create the OpenAnnouncementServicemethod as shown in the following code.

(Code Snippet - What is new in WCF4 Lab OpenAnnouncementService Method CSharp)

C#

privatevoidOpenAnnouncementService()

{

this.announcementService = newAnnouncementService();

// Add event handlers

this.announcementService.OnlineAnnouncementReceived +=

newEventHandler(this.OnOnlineAnnouncement);

this.announcementService.OfflineAnnouncementReceived +=newEventHandler(this.OnOfflineAnnouncement);

// Create the service host with a singleton

this.announcementServiceHost = newServiceHost(this.announcementService);

// Add the announcement endpoint

this.announcementServiceHost.AddServiceEndpoint( new

UdpAnnouncementEndpoint());

// Open the host async

this.announcementServiceHost.BeginOpen(

(result) =>{

announcementServiceHost.EndOpen(result);

},

null);

}

(Code Snippet - What is new in WCF4 Lab OpenAnnouncementService Method VB)

Visual Basic

PrivateSub OpenAnnouncementService()

Me.announcementService = NewAnnouncementService()

' Add event handlers

AddHandler announcementService.OnlineAnnouncementReceived, AddressOf

OnOnlineAnnouncement

AddHandler announcementService.OfflineAnnouncementReceived, AddressOf

OnOfflineAnnouncement


36/85

' Create the service host with a singleton

Me.announcementServiceHost = NewServiceHost(Me.announcementService)

' Add the announcement endpoint

Me.announcementServiceHost.AddServiceEndpoint( New

UdpAnnouncementEndpoint())

' Open the host async

Me.announcementServiceHost.BeginOpen( Sub(result)

announcementServiceHost.EndOpen(result), Nothing)

EndSub

Announcement Service

The self-hosted implementation of the announcement service exposes two different events

you might be interested in when using Announcements: OnlineAnnouncementReceivedandOfflineAnnouncementReceived. Those events are fired when Online (Hello) and Offline (Bye)

announcement messages are received respectively.

5. Now you need to implement the handlers for these announcements. When new users come

online, you will add them to the list. Add the OnOnlineAnnouncementmethod as shown in the

following code.

(Code Snippet - What is new in WCF4 Lab OnOnlineAnnouncement Method CSharp)

C#privatevoidOnOnlineAnnouncement(objectsender, AnnouncementEventArgse)

{

EndpointDiscoveryMetadata metadata =

e.EndpointDiscoveryMetadata;

// You are looking for services that

// implement the ISimpleChatService contract

FindCriteriacriteria =

newFindCriteria(typeof(ISimpleChatService));

if(criteria.IsMatch(metadata))

{

if(this.GetUser(metadata.Address.Uri) == null)

{

this.PopulateUserList(metadata);

}

}

}


37/85

(Code Snippet - What is new in WCF4 Lab OnOnlineAnnouncement Method VB)

Visual Basic

PrivateSubOnOnlineAnnouncement(ByValsender AsObject, ByVale As

AnnouncementEventArgs)Dimmetadata AsEndpointDiscoveryMetadata= e.EndpointDiscoveryMetadata

' You are looking for services that

' implement the ISimpleChatService contract

Dimcriteria AsNewFindCriteria(GetType(ISimpleChatService))

Ifcriteria.IsMatch(metadata) Then

IfMe.GetUser(metadata.Address.Uri) IsNothingThen

Me.PopulateUserList(metadata)

EndIf

EndIf

EndSub

6. When users go offline you will remove them and close any active chat windows. Add the

OnOfflineAnnouncementmethod as shown in the following code.

(Code Snippet - What is new in WCF4 Lab OnOfflineAnnouncement Method CSharp)

C#

privatevoidOnOfflineAnnouncement(objectsender, AnnouncementEventArgse)

{

EndpointDiscoveryMetadata metadata =

e.EndpointDiscoveryMetadata;

FindCriteriacriteria =

newFindCriteria(typeof(ISimpleChatService));

if(criteria.IsMatch(metadata))

{

this.RemoveUser(metadata.Address.Uri);

}

}

(Code Snippet - What is new in WCF4 Lab OnOfflineAnnouncement Method VB)

Visual Basic

PrivateSubOnOfflineAnnouncement(ByValsender AsObject, ByVale As

AnnouncementEventArgs)

Dimmetadata AsEndpointDiscoveryMetadata= e.EndpointDiscoveryMetadata


38/85


Ifcriteria.IsMatch(metadata) Then

Me.RemoveUser(metadata.Address.Uri)

EndIf

EndSub

7. Locate the OpenServicesmethod, and add a call to OpenAnnouncementService serviceat the

end of the method implementation.

C#

this.ShowStatus("Opening chat service...");

this.chatServiceHost.BeginOpen(

(result) =>

{

chatServiceHost.EndOpen(result);

this.ShowStatus("Chat service ready");},

null);

this.OpenAnnouncementService();

}

Visual Basic

Me.ShowStatus("Opening chat service...")

Me.chatServiceHost.BeginOpen( Sub(result)

chatServiceHost.EndOpen(result)Me.ShowStatus("Chat service ready")

EndSub, Nothing)

Me.OpenAnnouncementService()

EndSub

8. Press CTRL+SHIFT+Bto build the solution.

Next Step



Now you will test the application to verify that the clients are able to detect the announcements.

1. Press CTRL+F5to start an instance of the DiscoveryChatapplication without debugging.


39/85

2. Switch back to Visual Studio and press Ctrl+F5again to launch another instance of the

DiscoveryChat application.

3. Switch to one of the instances of DiscoveryChatand setup the chat as follows:

a. User Name: Fred

b. Click Sign in


a. User Name: Wilma

b. Click Sign in

5. When Wilma signed in, Freds chat window should detect the online announcement and

automatically add her to the list of available users.

Figure 17

Users are automatically discovered

6. Verify that the offline announcement is working by clicking the Sign Outbutton on the Wilma's

chat window. This should cause Fred's window to remove Wilma from the list of available

users.


40/85

7. Try signing in and out from both applications. Each application is aware of the online / offline

announcements of the other.

8. Close both instances of the DiscoveryChat application.

Next Step

Exercise 7: Discovery Proxy

Exercise 7: Discovery Proxy

All the previous exercises have relied on a well-known UDP multicast endpoint for discovery. The port

and multicast address are specified by the WS-Discovery protocol documentation. The utilization of this

multicast discovery is referred to as ad hoc discovery. Ad hoc discovery is limited to recognizing only

services on the same subnet. Managed discovery allows you to locate services no matter where they

are, as long as they are registered with a discovery proxy. In this section of the lab, you will create a

discovery proxy.

The following diagram shows how a Discovery Proxy responds on behalf of the target services:

Figure 18

Discovery Proxy used in service discovery.


41/85

Discovery Proxy

For more information about Discovery Proxy and WS-Discovery message exchanges, see section 3 of

theWS-Discovery Specification.


To begin this exercise, you can use the solution you finished from Exercise 6. Alternatively, you can



DiscoveryProxy\Begin (choosing the folder that matches the language of your preference.)



Task 1Creating a DiscoveryProxy

TheSystem.ServiceModel.Discoverynamespace includes a base class to help you in building your

Discovery Proxy. To implement your proxy you will have to override a number of methods provided by

the System.ServiceModel.Discovery.DiscoveryProxyclass. These methods are all asynchronous to

guarantee maximum scalability for the server. For this Hands-on Lab, you will focus on supporting only

Announcements in the proxy. When a chat client goes online or offline the cache of metadata will be

updated. Then you will respond to find requests when a client wants to query the proxy for list of chat

clients.

1. Add a new Console Application. To do this, in Solution Explorerright-click the Beginsolutionand point to Add and click New Project anduse the following settings

Setting Value


Target Framework .NET Framework 4

Installed Templates Windows

Template Console Application

Name ChatProxy

Location Source\Ex7-DiscoveryProxy\Begin
http://go.microsoft.com/fwlink/?LinkId=87841http://go.microsoft.com/fwlink/?LinkId=87841http://go.microsoft.com/fwlink/?LinkId=87841http://go.microsoft.com/fwlink/?LinkId=87841


42/85

Figure 19

Adding a new Console Application Project named ChatProxy (C#)


43/85

Figure 20

Adding a new Console Application Project named ChatProxy (Visual Basic)

2. Console applications use the .NET Framework Client Profile by default. To build a discovery

proxy you need to change the target framework of the ChatProxyproject to .NET Framework 4.

a. In C#, to do this in Solution Explorer,right-click the ChatProxyproject, and select

Properties then change to the .NET Framework 4 profile. Visual Studio will warn you

that it has to unload and reload the project before continuing.

b. In Visual Basic, to do this in Solution Explorer,right-click the ChatProxyproject and

select Properties in the Compile tab, click Advance Compile Options, change to the .Net

Framework 4profile. Visual Studio will warn you that it has to unload and reload the

project before continuing.


44/85

Figure 21

Change to the full .NET Framework 4 Profile (C#)


45/85

Figure 22

Change to the full .NET Framework 4 Profile (Visual Basic)

3. Right-click ChatProxyproject, and click Add Reference. Using the Projectstab, add a project

reference to the DiscoveryChatproject. Repeat these steps, using the .NETtab to add a

reference to the System.ServiceModeland System.ServiceModel.Discoverylibraries.


5. Your discovery proxy will need a class to implement the proxy service. Next step is to create the

ChatDiscoveryProxyclass. In Solution Explorer, right-click ChatProxyproject, point to Add, and

then click Class. TypeChatDiscoveryProxyin the Namebox.


46/85

Figure 23

Adding a new Class called ChatDiscoveryProxy (C#)

Figure 24

Adding a new Class called ChatDiscoveryProxy (Visual Basic)


47/85

6. Add the following using directives for the new class.

(Code Snippet - What is new in WCF4 Lab ChatDiscoveryProxy Using Statements CSharp)

C#

usingSystem.ServiceModel;

using System.ServiceModel.Discovery;

using System.Collections.ObjectModel;

usingMicrosoft.Samples.Discovery.Contracts;

(Code Snippet - What is new in WCF4 Lab ChatDiscoveryProxy Using Statements VB)

Visual Basic

ImportsSystem.ServiceModel

ImportsSystem.ServiceModel.Discovery

ImportsSystem.Collections.ObjectModelImportsMicrosoft.Samples.Discovery.Contracts

7. Make your class inherit from System.ServiceModel.Discovery.DiscoveryProxybase class.

C#

publicclassChatDiscoveryProxy: DiscoveryProxy

Visual Basic

Public Class ChatDiscoveryProxy

Inherits DiscoveryProxy

8. In this lab, your class will maintain a thread-safe in-memory cache. For this reason, you need to

make your WCF service instance to be a singleton. In addition, because it is thread safe and you

want to guarantee maximum scalability, you will also allow multiple concurrent calls. Modify

the ChatDiscoveryProxyclass signature, to add the following attributes.

(Code Snippet - What is new in WCF4 LabProxy ServiceBehavior CSharp)

C#

[ServiceBehavior(

InstanceContextMode = InstanceContextMode.Single,

ConcurrencyMode = ConcurrencyMode.Multiple)]

publicclassChatDiscoveryProxy: System.ServiceModel.Discovery.DiscoveryProxy

(Code Snippet - What is new in WCF4 LabProxy ServiceBehavior VB)


48/85

Visual Basic

PublicClassChatDiscoveryProxy

Note:Using an in-memory cache means that if your discovery proxy host shutdowns, all

information regarding services is lost. More robust implementations would use durable

storage, such as a database; this will insure that service metadata is not lost even when the

service is down.

9. You will need to create a thread safe collection class to hold instances of services you have

discovered. Right-click ChatProxyproject, point to Add, and then clickClass. Type

ChatServiceCollectionin the Namebox.

Note: For more information see,Collections and Synchronization (Thread Safety).

10.Add the following using directives for the new class.

C#


Visual Basic

Imports System.ServiceModel.Discovery

11.Mark your class as internal(C#) friend(Visual Basic), and make it inherit from the

SynchronizedKeyedCollectionbase class.

C#

internalclassChatServiceCollection: SynchronizedKeyedCollection

Visual BasicFriendClassChatServiceCollection

InheritsSynchronizedKeyedCollection(OfUri, EndpointDiscoveryMetadata)

12. Implement the GetKeyForItemmethod of the SynchronizedKeyedCollectionclass as shown in

following code.
http://msdn.microsoft.com/en-us/library/573ths2x(VS.71).aspxhttp://msdn.microsoft.com/en-us/library/573ths2x(VS.71).aspxhttp://msdn.microsoft.com/en-us/library/573ths2x(VS.71).aspxhttp://msdn.microsoft.com/en-us/library/573ths2x(VS.71).aspx


49/85

(Code Snippet - What is new in WCF4 Lab GetKeyForItem Method CSharp)

C#

internalclassChatServiceCollection:

SynchronizedKeyedCollection

{

protectedoverrideUriGetKeyForItem(EndpointDiscoveryMetadataitem)

{

if(item == null)

{

thrownewArgumentNullException("item");

}

returnitem.Address.Uri;

}

}

(Code Snippet - What is new in WCF4 Lab GetKeyForItem Method VB)

Visual Basic

FriendClassChatServiceCollection

InheritsSynchronizedKeyedCollection(OfUri, EndpointDiscoveryMetadata)

ProtectedOverridesFunctionGetKeyForItem(ByValitem As

System.ServiceModel.Discovery.EndpointDiscoveryMetadata) AsSystem.Uri

Ifitem IsNothingThen

ThrowNewArgumentNullException("item")EndIf

Returnitem.Address.Uri

EndFunction

EndClass

13.Switch back to the ChatDiscoveryProxyclass implementation, and add a static

ChatServiceCollectionproperty and its backing field as shown in following code.

(Code Snippet - What is new in WCF4 Lab ChatServiceCollection Member CSharp)

C#

public classChatDiscoveryProxy: DiscoveryProxy

{

privatestaticChatServiceCollectioncache = newChatServiceCollection();

internalstaticChatServiceCollectionCache

{


50/85

get{ returncache; }

}

}

(Code Snippet - What is new in WCF4 Lab ChatServiceCollection Member VB)Visual Basic

PublicClassChatDiscoveryProxy

InheritsDiscoveryProxy

PrivateSharedcache_Renamed AsNewChatServiceCollection()

FriendSharedReadOnlyPropertyCache() AsChatServiceCollection

Get

Returncache_Renamed

EndGet

EndPropertyEnd Class

14.To complete the service, you will add several helper classes, which are already developed for

simplicity. To do this, right-click the ChatProxyproject, point to Add,and click Existing Item.

Then, browse to the Source\Assets\ChatProxy(choosing the folder that matches the language

of your preference)folder, and add the following files:

a. AsyncResult.cs

b. CompletedAsyncResult.cs

c. FindAsyncResult.cs

d. EndpointDiscoveryMetadataExtensions.cs

15.When an onlineannouncement is received, you need to determine if the service is one that you

want to cache. If so, add it to your cache. Override the OnBeginOnlineAnnouncementmethod

inside the ChatDiscoveryProxyclass by adding the following code.

(Code Snippet - What is new in WCF4 Lab OnBeginOnlineAnnouncement Method CSharp)

C#

protectedoverrideIAsyncResult

OnBeginOnlineAnnouncement(DiscoveryMessageSequence messageSequence,

EndpointDiscoveryMetadata

endpointDiscoveryMetadata,

AsyncCallbackcallback,

objectstate)

{

if(endpointDiscoveryMetadata == null)

{


51/85

thrownewArgumentNullException("endpointDiscoveryMetadata" );

}

// You care only about ISimpleChatService services

FindCriteriacriteria = newFindCriteria(typeof(ISimpleChatService));

if(criteria.IsMatch(endpointDiscoveryMetadata))

{

endpointDiscoveryMetadata.WriteLine( "Adding");

Cache.Add(endpointDiscoveryMetadata);

}

returnnewCompletedAsyncResult(callback, state);

}

(Code Snippet - What is new in WCF4 Lab OnBeginOnlineAnnouncement Method VB)

Visual Basic

ProtectedOverridesFunctionOnBeginOnlineAnnouncement(ByValmessageSequence

AsDiscoveryMessageSequence , ByValendpointDiscoveryMetadata As

EndpointDiscoveryMetadata, ByValcallback AsAsyncCallback, ByValstate As

Object) AsIAsyncResult

IfendpointDiscoveryMetadata IsNothingThen

ThrowNewArgumentNullException("endpointDiscoveryMetadata" )

EndIf

' You care only about ISimpleChatService services


If criteria.IsMatch(endpointDiscoveryMetadata) Then

endpointDiscoveryMetadata.WriteLine( "Adding")

Cache.Add(endpointDiscoveryMetadata)

EndIf

ReturnNewCompletedAsyncResult(callback, state)

EndFunction

16.When an offline announcement message is received, you want to remove the metadata from

the cache if it is there. Override the OnBeginOfflineAnnouncementmethod by adding thefollowing code.

(Code Snippet - What is new in WCF4 Lab OnBeginOfflineAnnouncement Method CSharp)

C#

protectedoverrideIAsyncResult

OnBeginOfflineAnnouncement(DiscoveryMessageSequencemessageSequence,


52/85

EndpointDiscoveryMetadataendpointDiscoveryMetadata, AsyncCallbackcallback,

objectstate)

{

try

{

if(endpointDiscoveryMetadata == null)

{

thrownewArgumentNullException("endpointDiscoveryMetadata");

}

// You care only about ISimpleChatService services

FindCriteriacriteria = newFindCriteria(typeof(ISimpleChatService));

if(criteria.IsMatch(endpointDiscoveryMetadata))

{

endpointDiscoveryMetadata.WriteLine( "Removing");

Cache.Remove(endpointDiscoveryMetadata.Address.Uri);

}

}

catch(KeyNotFoundException)

{

// No problem if it does not exist in the cache

}


}

(Code Snippet - What is new in WCF4 Lab OnBeginOfflineAnnouncement Method VB)

Visual Basic

ProtectedOverridesFunctionOnBeginOfflineAnnouncement(ByValmessageSequence

AsDiscoveryMessageSequence , ByValendpointDiscoveryMetadata As

EndpointDiscoveryMetadata, ByValcallback AsAsyncCallback, ByValstate As

Object) AsIAsyncResult

Try

IfendpointDiscoveryMetadata IsNothingThen

ThrowNewArgumentNullException("endpointDiscoveryMetadata")

EndIf

' You care only about ISimpleChatService services


If criteria.IsMatch(endpointDiscoveryMetadata) Then

endpointDiscoveryMetadata.WriteLine( "Removing")

Cache.Remove(endpointDiscoveryMetadata.Address.Uri)

EndIf

Catche1 AsKeyNotFoundException

' No problem if it does not exist in the cache


53/85

EndTry


EndFunction

17.Now you can override the OnBeginFindmethod, which is called when a client issues a Discovery

Find request to the proxy. Here is where you can search the cache of known service endpoints

and reply to the client Find request with any matching endpoints.

(Code Snippet - What is new in WCF4 Lab OnBeginFind Method CSharp)

C#

protectedoverrideIAsyncResultOnBeginFind(FindRequestContext

findRequestContext, AsyncCallbackcallback, objectstate)

{

if(findRequestContext == null)

{thrownewArgumentNullException("findRequestContext");

}

Console.WriteLine(

"Find request for contract {0}",

findRequestContext.Criteria.ContractTypeNames.FirstOrDefault());

// Query to find the matching endpoints

varquery = fromservice inCache

wherefindRequestContext.Criteria.IsMatch(service)

selectservice;

// Collection to contain the results of the query

varmatchingEndpoints = newCollection();

// Execute the query and add the matching endpoints

foreach(EndpointDiscoveryMetadata metadata inquery)

{

metadata.WriteLine("\tFound");

matchingEndpoints.Add(metadata);

findRequestContext.AddMatchingEndpoint(metadata);

}

returnnewFindAsyncResult(matchingEndpoints, callback, state);

}

(Code Snippet - What is new in WCF4 Lab OnBeginFind Method VB)

Visual Basic


54/85

ProtectedOverridesFunctionOnBeginFind(ByValfindRequestContext As

FindRequestContext, ByValcallback AsAsyncCallback, ByValstate AsObject) As

IAsyncResult

IffindRequestContext IsNothingThen

ThrowNewArgumentNullException("findRequestContext")

EndIf

Console.WriteLine("Find request for contract {0}",

findRequestContext.Criteria.ContractTypeNames.FirstOrDefault())

' Query to find the matching endpoints

Dimquery = Fromservice InCache

WherefindRequestContext.Criteria.IsMatch(service)

Selectservice

' Collection to contain the results of the query

DimmatchingEndpoints = NewCollection(OfEndpointDiscoveryMetadata )()

' Execute the query and add the matching endpoints

ForEachmetadata AsEndpointDiscoveryMetadata Inquery

metadata.WriteLine(Constants.vbTab & "Found")

matchingEndpoints.Add(metadata)

findRequestContext.AddMatchingEndpoint(metadata)

Nextmetadata

ReturnNewFindAsyncResult(matchingEndpoints, callback, state)

EndFunction

18.Override the OnEndFindmethod to complete the find operation.

(Code Snippet - What is new in WCF4 Lab OnEndFind Method CSharp)

C#

protectedoverridevoidOnEndFind(IAsyncResultresult)

{

FindAsyncResult.End(result);

}

(Code Snippet - What is new in WCF4 Lab OnEndFind Method VB)

Visual Basic

ProtectedOverridesSubOnEndFind(ByValresult AsSystem.IAsyncResult)

FindAsyncResult.End(result)

EndSub


55/85

Note: In this lab solution, the Discovery Proxy is implemented as a Console Application.

Production environments would use a more robust hosting solution such as a Windows

Service.

19.Override the rest of the required methods declared abstract in

System.ServiceModel.Discovery.DiscoveryProxy class.

(Code Snippet - What is new in WCF4 LabDiscoveryProxy Abstract Methods CSharp)

C#

protectedoverrideIAsyncResultOnBeginResolve(ResolveCriteria

resolveCriteria, AsyncCallbackcallback, objectstate)

{


}

protectedoverrideEndpointDiscoveryMetadata OnEndResolve(IAsyncResultresult)

{

returnCompletedAsyncResult.End(result);

}

protectedoverridevoidOnEndOfflineAnnouncement(IAsyncResultresult)

{

CompletedAsyncResult.End(result);

}

protectedoverridevoidOnEndOnlineAnnouncement(IAsyncResultresult)

{CompletedAsyncResult.End(result);

}

(Code Snippet - What is new in WCF4 LabDiscoveryProxy Abstract Methods VB)

Visual Basic

ProtectedOverridesFunctionOnBeginResolve(ByValresolveCriteria As

ResolveCriteria, ByValcallback AsAsyncCallback, ByValstate AsObject) As

IAsyncResult


EndFunction

ProtectedOverridesFunctionOnEndResolve(ByValresult AsIAsyncResult) As

EndpointDiscoveryMetadata

ReturnCompletedAsyncResult(OfEndpointDiscoveryMetadata ).End(result)

EndFunction

ProtectedOverridesSubOnEndOfflineAnnouncement(ByValresult AsIAsyncResult)


56/85

CompletedAsyncResult.End(result)

EndSub

ProtectedOverridesSubOnEndOnlineAnnouncement(ByValresult AsIAsyncResult)

CompletedAsyncResult.End(result)

EndSub

20.Now you need to modify the Mainmethod to create a ServiceHostfor your

ChatDiscoveryProxyservice. Open Program.cs (C#) or Module1.vb (Visual Basic)in the

ChatProxyproject.

21.Add the following using directives to Program.cs.

C#

usingSystem.Net;

usingSystem.ServiceModel;


Visual Basic

Imports System.Net

Imports System.ServiceModel

Imports System.ServiceModel.Discovery

22.For hosting the ChatDiscoveryProxyservice, you will create the DiscoveryEndpointendpoint for

the service host. Add the following method inside the Programclass (C#) or the Module1

module (Visual Basic).

Note: In this lab solution, you will be using TCP port 8001 for your proxy service.

(Code Snippet - What is new in WCF4 Lab HostDiscoveryEndpoint Method CSharp)

C#

privatestaticServiceHost HostDiscoveryEndpoint(stringhostName)

{

// Create a new ServiceHost with a singleton ChatDiscovery Proxy

ServiceHost myProxyHost = newServiceHost(newChatDiscoveryProxy());

stringproxyAddress = "net.tcp://"+

hostName + ":8001/discoveryproxy";

// Create the discovery endpoint

DiscoveryEndpoint discoveryEndpoint =


57/85

newDiscoveryEndpoint(

newNetTcpBinding(),

new EndpointAddress(proxyAddress));

discoveryEndpoint.IsSystemEndpoint = false;

// Add UDP Annoucement endpoint

myProxyHost.AddServiceEndpoint( new UdpAnnouncementEndpoint());

// Add the discovery endpoint

myProxyHost.AddServiceEndpoint(discoveryEndpoint);

myProxyHost.Open();

Console.WriteLine("Discovery Proxy {0}",

proxyAddress);

returnmyProxyHost;

}

(Code Snippet - What is new in WCF4 Lab HostDiscoveryEndpoint Method VB)

Visual Basic

PrivateFunctionHostDiscoveryEndpoint(ByValhostName AsString) As

ServiceHost

' Create a new ServiceHost with a singleton ChatDiscovery Proxy

DimmyProxyHost AsNewServiceHost(NewChatDiscoveryProxy())

DimproxyAddress AsString= "net.tcp://"& hostName &

":8001/discoveryproxy"

' Create the discovery endpoint

DimdiscoveryEndpoint AsNewDiscoveryEndpoint(NewNetTcpBinding(), New

EndpointAddress(proxyAddress))

discoveryEndpoint.IsSystemEndpoint = False

' Add UDP Annoucement endpoint

myProxyHost.AddServiceEndpoint( NewUdpAnnouncementEndpoint())

' Add the discovery endpoint

myProxyHost.AddServiceEndpoint(discoveryEndpoint)

myProxyHost.Open()

Console.WriteLine("Discovery Proxy {0}", proxyAddress)

ReturnmyProxyHost

EndFunction


58/85

23.Modify the Mainmethod as shown in the following code, to host the ChatDiscoveryProxy

service.

(Code Snippet - What is new in WCF4 Lab DiscoveryProxy Main Method CSharp)

C#

staticvoidMain(string[] args)

{

Console.Title = "ChatProxy Service";

Console.WriteLine("ChatProxy Console Host");

stringhostName = Dns.GetHostName();

using(ServiceHost proxyHost = HostDiscoveryEndpoint(hostName))

{

Console.WriteLine("Press to exit");

Console.ReadLine();

proxyHost.Close();}

}

(Code Snippet - What is new in WCF4 Lab DiscoveryProxy Main Method CSharp)

C#

SubMain()

Console.Title = "ChatProxy Service"

Console.WriteLine("ChatProxy Console Host")

DimhostName AsString= Dns.GetHostName()

UsingproxyHost AsServiceHost= HostDiscoveryEndpoint(hostName)

Console.WriteLine("Press to exit")

Console.ReadLine()

proxyHost.Close()

EndUsing

EndSub

24.Press Ctrl+Shift+Bto build the solution.

Task 2Modifying the DiscoveryChat Application to use Managed Discovery

Now that you have implemented a discovery proxy, you need to modify the chat application to make

use of it.

1. Open SimpleChat in code view file from the DiscoveryChatproject. You can open the code view

by selecting the file and pressing F7.


59/85

2. Locate the ManagedDiscoverymethod. The UI is already calling this method if the Managed

Discovery radio button is checked. As you have already implemented the handlers for ad hoc

discovery, the only thing pending is to add code to implement this managed discovery as shown

in the following code.

(Code Snippet - What is new in WCF4 Lab ManagedDiscovery Method CSharp)

C#

privatevoidManagedDiscovery()

{

try

{

// Create an endpoint for the proxy

DiscoveryEndpointproxyEndpoint =

newDiscoveryEndpoint(

newNetTcpBinding(),

newEndpointAddress(proxyAddressText.Text));

// Create the DiscoveryClient with a proxy endpoint

// for managed discovery

this.discoveryClient = newDiscoveryClient(proxyEndpoint);

// Same handlers as ad hoc discovery

this.discoveryClient.FindCompleted +=

newEventHandler(this.OnFindCompleted);

this.discoveryClient.FindProgressChanged +=

new

EventHandler(this.OnFindProgressChanged);

// Setup the form for discoverythis.ShowDiscoveryInProgress( true);

this.discoveryClient.FindAsync( new

FindCriteria(typeof(ISimpleChatService)));

}

catch(UriFormatException)

{

MessageBox.Show(

Resources.InvalidUriMessage,

this.Text,

MessageBoxButtons.OK,

MessageBoxIcon.Information,

MessageBoxDefaultButton.Button1,

(MessageBoxOptions)0);

}

}

(Code Snippet - What is new in WCF4 Lab ManagedDiscovery Method VB)


60/85

Visual Basic

PrivateSubManagedDiscovery()

Try

' Create an endpoint for the proxy

DimproxyEndpoint AsNewDiscoveryEndpoint(NewNetTcpBinding(), New

EndpointAddress(proxyAddressText.Text))

' Create the DiscoveryClient with a proxy endpoint

' for managed discovery

Me._discoveryClient = NewDiscoveryClient(proxyEndpoint)

' Same handlers as ad hoc discovery

AddHandler _discoveryClient.FindCompleted, AddressOfOnFindCompleted

AddHandler _discoveryClient.FindProgressChanged, AddressOf

OnFindProgressChanged

' Setup the form for discovery

Me.ShowDiscoveryInProgress( True)

Me._discoveryClient.FindAsync( New

FindCriteria(GetType(ISimpleChatService)))

Catche1 AsUriFormatException

MessageBox.Show(My.Resources.InvalidUriMessage, Me.Text,

MessageBoxButtons.OK, MessageBoxIcon.Information,

MessageBoxDefaultButton.Button1, CType(0, MessageBoxOptions))

EndTry

EndSub

3. Locate the InitializeManagedDiscoverymethod, and set the managed radio button Checked

property to True.

C#

privatevoidInitializeManagedDiscovery()

{

this.managedRadioButton.Checked = true;

}

Visual Basic

PrivateSubInitializeManagedDiscovery()

Me.managedRadioButton.Checked = True

EndSub



61/85

Next Step



Now you will test the chat application to see that the clients are able to detect the announcements.

1. Right-click the ChatProxyproject, and click Set as StartUp project.

2. Press F5to start ChatProxyconsole in the debugger.

Figure 25

ChatProxy Service running

Note:Windows Firewall may prompt you to allow the Proxy and/or Chat client access to use

the network. It is safe to allow this.

3. Switch back to Visual Studio Solution Explorer and start two instances of the DiscoveryChat

application by right-clicking the DiscoveryChat project, pointing to Debug, and clicking Start

New Instance.

4. Switch to one of the instances of the DiscoveryChatapplication and setup the chat as follows:

a. User Name: Fred

b. Click Sign in



62/85

a. User Name: Wilma

b. Click Sign in

6. When Wilma signed in, her window found Fred from the managed discovery proxy. Fred's chat

window should detect the online announcement from Wilma's window and automatically add

her.

Figure 26

Managed discovery in action

7. Verify that the offline announcement is working by clicking the Sign Outbutton on Wilma's chat

window. This should cause Fred's window to remove Wilma from the list of available users.

8. Try signing in and out from both applications. Each application is aware of the online / offline

announcements of the other.


63/85

Figure 27

ChatProxy Service in action

9. Press Shift+F5 (C#) or Ctrl+Alt+Break (Visual Basic)to stop debugging

Next Step

Exercise 8: Protocol Bridging

Exercise 8: Protocol Bridging

WCF4 includes a new routing service found in the System.ServiceModel.Routingnamespace. The

Routing Service is designed to act as a generic, configurable SOAP intermediary. It allows you to

configure Content Based Routing, set up Protocol Bridging, and handle communication errors that you

encounter. The Routing Service also makes it possible for you to update your Routing Configuration

while the Routing Service is running without restarting the service.


64/85

Figure 28

The routing service bridging http and net.tcp

Imagine that you had a client application that can only communicate using basic httpand at the same

time, you have a service that communicates using net.tcp. There are many ways to solve this problem.

For example, with WCF you can have more than one endpoint for a service so it would be possible to

expose an endpoint using basicHttpBindingfor the client.

With WCF4 System.ServiceModel.Routingyou now have another way to solve this problem. In this

exercise, you will use the routing service to bride the http and net.tcp protocol by simply configuring the

routing service.


This exercise uses a new begin solution


ProtocolBridging\Begin (choosing the folder that matches the language of your



Task 1Trying the Calculator

In this task, you will explore the calculator solution.

1. The solution contains two projects a CalculatorServiceand CalculatorClientproject

2. Open the app.config file from the CalculatorService project. Note the base address of the

CalculatorService is using a net.tcp address.

XML


65/85

3. The CalculatorClientproject has a Service Reference to the CalculatorServiceproject. Open the

app.config file for the CalculatorClientproject, and note the client section is also using net.tcp

to communicate with the calculator service.

XML

4. The solution is set to use multiple startup projects. If this is not the case, right-click the solution

node in Solution Explorer, and select Set StartUp Projectsto configure them. Press Ctrl+F5 to

start the solution. This will launch the CalculatorServiceand CalculatorClientapplications.

5. The CalculatorClient will be pre-loaded with random values. Press Invoke to invoke the service

over net.tcp. You will see something similar to the following.

Figure 29

The Calculator Service and Client Application connected over TCP

Task 2Adding the Router Service

Your calculator works great if you are able to connect with net.tcp, but what if you had a requirement

that the calculator application could access the calculator service over the Internet?


66/85

In this task, you will change the CalculatorClient to connect to a router service bridging the http and

net.tcp protocols

1. Right-click the Ex8-ProtocolBridingsolution, select Add / Existing Project, and add the

RouterServiceproject from the Source\Assets (Choosing the folder that matches the language

of your preference.)

2. The routing service has to be configured Open the web.configfile from the RouterService

project.

3. The routing service is both a service and a client. The first thing you will do is add the client

endpoint and binding configuration to the web.configfile. Add the following configuration as

shown

(Code Snippet - What is new in WCF4 LabRoutingService calc endpoint XML)

XML

4. The routing service uses a filter table to map incoming messages to client endpoints. The next

thing you need to do is to create the filter table and service behavior that will apply it in the

configuration. Add the following portion after the section

(Code Snippet - What is new in WCF4 LabRouting service behavior XML)

XML


67/85

What does the filter table do?

This filter table will match all requests and route them to the regularCalculatorEndpoint

listening at net.tcp://localhost:9090/CalculatorService

5. The last thing you need to do is to add a service definition for the router service. Your router

service will be listening on http and routing requests to the calculator service, which is listening

on net.tcpthis effectively bridges the protocols. Add the following configuration after the

section.

(Code Snippet - What is new in WCF4 LabRouting service XML)

XML

Task 3Modifying the Client to Enable Routed HTTP


68/85

1. Your client application will need a client endpoint definition to use with the router service.

Open the app.configfile from the CalculatorClientproject, and add the following configuration

after the existing endpoint.

(Code Snippet - What is new in WCF4 LabCalcClient endpoint XML)

XML

Named endpoints in configuration

If your client section contains more than one endpoint definition, you will have to provide anendpoint name when creating a client proxy. Look at the CalculateResultsmethod of

MainWindow, which has been written to pass the endpoint name to the proxy constructor.

Next Step



In this verification, you will test the CalculatorClientapplication to see if it can route requests over HTTP

as well as over TCP connections.

1. Right-click the Ex-8ProtocolBriding solution, and select Set Startup Projects.

2. Select the Multiple Startup Projects radio button, and set all three projects to Start.


69/85

Figure 30

Set Multiple Startup projects

3. Click OKto dismiss the solution properties dialog.

4. Press F5to debug the solution. All three projects should now start.

5. Select Routed HTTP Connectionin the CalculatorClienttoolbar dropdown.

Figure 31

Select the Routed HTTP Connection option


70/85

6. Click Invoke Serviceto test the routed connection, it should invoke the service successfully.

Figure 32

The CalculatorClient invoking the service using routed HTTP

Next Step

Exercise 9: Content Based Routing

Exercise 9: Content Based Routing

In the previous exercise, you routed all requests bound for your service bridging the protocol from HTTP

to TCP. However, there are many cases where you want to route requests based on the content of the

message. While you can route based on content from the message body for performance it is

recommended that you route based on content in the message headers.

In this exercise, you will add a variation of the calculator service that uses rounding. You will then route

to this service messages that contain a special header while other messages that do not have the header

will use the regular calculator service.


71/85

Figure 33

The routing service routing based on message header content


This exercise uses a new begin solutionwhich contains a new service, the RoundingCalculatorService

project and some updates to the CalculatorClient application


ContentRouting\Begin(choosing the folder that matches the language of your preference.)



Task 1Modifying the CalculatorClient to Add a Custom Header

The CalculatorClient application now has a button on the toolbar to indicate if you want to use the

Rounding calculator. Even though this is a different service, you will send the message to the same

routing service. In this task, you will write the code to add a custom header that the router will use to

route the message.

1. In the CalculatorClient project open MainWindow.xaml.cs (C#) orMainWindow.xaml.vb

(Visual Basic)

2. Locate the AddOptionalRoundingHeadermethod and modify it as shown to add a custom

header to outgoing messages that will use the RoundingCalculator.

(Code Snippet - What is new in WCF4 LabAddOptionalRoundingHeader method CSharp)

C#

privatevoidAddOptionalRoundingHeader(

CalculatorServiceClient proxy)


72/85

{

if(this.checkRounding.IsChecked.Value == true)

{

OperationContextctx = OperationContext.Current;

MessageHeadersmessageHeadersElement = ctx.OutgoingMessageHeaders;

ctx.OutgoingMessageHeaders.Add(

MessageHeader.CreateHeader(

"RoundingCalculator",

"http://my.custom.namespace/" ,

"1"));

}

}

(Code Snippet - What is new in WCF4 LabAddOptionalRoundingHeader method VB)

Visual Basic

PrivateSubAddOptionalRoundingHeader(ByValproxy AsCalculatorServiceClient)If(Me.checkRounding.IsChecked.Value = True) Then

Dimctx = OperationContext.Current

DimmessageHeadersElement = ctx.OutgoingMessageHeaders

ctx.OutgoingMessageHeaders.Add(

MessageHeader.CreateHeader(

"RoundingCalculator",

"http://my.custom.namespace/" ,

"1"))

EndIf

EndSub

Task 2Adding a New Entry to the Filter Table

In this task, you will modify the router to detect this new header and route the message to the rounding

calculator.

1. Because your header uses a custom namespace, you will need to create a namespace table. In

the RouterServiceproject open the web.configfile and add the following configuration to the

section.

(Code Snippet - What is new in WCF4 LabNamespace Table XML)

XML


73/85

2. Now you can define a new kind of filter that will match using an XPath expression. Add the

following filter definition to the web.configfile. This filter will match on messages with the

custom RoundingCalculatorHeader with a value of 1.

(Code Snippet - What is new in WCF4 LabXPathFilter XML)

XML

3. You need to add a new endpoint address for the RoundingCalculatorServiceso that you can

route to it. Modify the web.configfile in the RouterServiceproject, and add the new endpoint

definition to the section as shown.

(Code Snippet - What is new in WCF4 Lab roundingCalculatorEndpoint XML)

XML

4. Finally, you need to add the new filter to the filter table. The filter table evaluates matches

based on the order of priority in the filters with higher numbers having higher priority. Because

you want the XPathFilterto match messages before the MatchAll filter you need to give it a

higher priority. Open the web.configof the RouterService, and modify the

configuration as shown.

(Code Snippet - What is new in WCF4 Lab filterTable1 XPathFilter XML)

XML


74/85

Next Step



1. Press F5

Documents

11 Visual Studio 2010 Training Kit - Lab Whats New In WCF 4.docx