Create a new Silverlight application in Visual Studio 2010. Call the application WCFService, and allow Visual Studio to create a Web Application project named WCFService.Web to host your application.

Right-click the WCFService.Web project and select Add

Figure 7.2. Adding the StartingHands.cs class to the project

Now you need to implement the StartingHands.cs class. It is very similar to the class used in Chapter 5's DataGrid example. To save yourself some typing, you can copy the code from that project. As shown in bold in the following code, the only differences are the namespace and the return type of the GetHands() method. Instead of using an ObservableCollection, it will return a simple List<StartingHands>.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace WCFService.Web
{
    public class StartingHands
    {
        public string Nickname { get; set; }
        public string Notes { get; set; }
        public string Card1 { get; set; }
        public string Card2 { get; set; }

        public static List<StartingHands> GetHands()
        {
            List<StartingHands> hands = new List<StartingHands>();

            hands.Add(
                new StartingHands()
                {
                    Nickname = "Big Slick",
                    Notes = "Also referred to as Anna Kournikova.",
                    Card1 = "As",
                    Card2 = "Ks"
                });

            hands.Add(
            new StartingHands()
            {
                Nickname = "Pocket Rockets",
                Notes = "Also referred to as Bullets.",
                Card1 = "As",
                Card2 = "Ad"
            });

hands.Add(
                new StartingHands()
                {
                    Nickname = "Blackjack",
                    Notes = "The casino game blackjack.",
                    Card1 = "As",
                    Card2 = "Js"
                });

            hands.Add(
                new StartingHands()
                {
                    Nickname = "Cowboys",
                    Notes = "Also referred to as King Kong",
                    Card1 = "Ks",
                    Card2 = "Kd"
                });

            hands.Add(
                new StartingHands()
                {
                    Nickname = "Doyle Brunson",
                    Notes = "Named after poker great Doyle Brunson",
                    Card1 = "Ts",
                    Card2 = "2s"
                });


            return hands;
        }
    }
}

Next, you need to add the WCF service that will call the StartingHands.GetHands() method. Right-click the WCFService.Web project and select Add

Figure 7.3. Adding the Silverlight-enabled WCF service

This will add a service named StartingHandService.svc to the project with an attached code-behind file named StartingHandService.svc.cs. View that code behind. You will see that Visual Studio has already created the base WCF service, including a sample method called DoWork(), as follows:

namespace WCFService.Web
{
    [ServiceContract(Namespace = "")]
    [AspNetCompatibilityRequirements(
        RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    public class StartingHandService
    {
        [OperationContract]
        public void DoWork()
        {
            // Add your operation implementation here
            return;
        }

        // Add more operations here and mark them with [OperationContract]
    }
}

Replace the DoWork() method with a GetHands() method that returns a List<StartingHands> collection, as follows:

namespace WCFService.Web
{
    [ServiceContract(Namespace = "")]
    [AspNetCompatibilityRequirements(RequirementsMode =
        AspNetCompatibilityRequirementsMode.Allowed)]
    public class StartingHandService
    {
        [OperationContract]
        public List<StartingHands> GetHands()        {
                return StartingHands.GetHands();
        }
        // Add more operations here and mark them
        // with [OperationContract]
    }
}

This method simply returns the results from calling the StartingHands.GetHands() method. Note that you will need to add a using statement for System.Collections.Generic.

Now that you have a Silverlight-enabled WCF service, you need to add a reference in your Silverlight project so that your Silverlight application can access the service. To do this, right-click References within the WCFService in Solution Explorer and select Add Service Reference, as shown in Figure 7-4. This brings up the Add Service Reference dialog box.

Figure 7.4. Choosing to add a service reference

In the Add Service Reference dialog box, click the Discover button, as shown in Figure 7-5.

Visual Studio will find the StartingHandService.svc and will populate the Services list in the Add Service Reference dialog box. Note that you may need to build the solution before Visual Studio will find your service. Expand the StartingHandService.svc node to show the StartingHandService. Click StartingHandService to see the GetHands() web method in the Operations listing, as shown in Figure 7-6. Enter StartingHandServiceReference as the Namespace field, and then click OK to continue.

Figure 7.5. Finding the services in the solution

Figure 7.6. Adding a service reference for StartingHandService

Open the Visual Studio Object Browser by selecting View

Figure 7.7. Object Browser for StartingHandService

Look at the members listed on the right side of the Object Browser. There are a number of items that are added, but take specific note of the method named GetHandsAsync() and the event named GetHandsCompleted. You will need to use bothof these in order to call your web service from Silverlight.

Now it's time to create the Silverlight application's UI. Open the MainPage.xaml file in Visual Studio. Place the cursor within the root Grid and double-click the DataGrid control in the Toolbox. Once the DataGrid has been added, right-click on it in designer and select Reset Layout

<Grid x:Name="LayoutRoot" Background="White">
    <sdk:DataGrid AutoGenerateColumns="False" Name="dataGrid1" />
</Grid>

Rename the DataGrid to grdData and set the Margin to 15. Next, add the following Column definitions, which are from the previous DataGrid exercise in Chapter 5. The DataGrid contains three columns: one template column containing the two cards in the hand and two text columns containing the nickname and notes about the hand.

<sdk:DataGrid AutoGenerateColumns="False" Name="grdData" Margin="15">
    <sdk:DataGrid.Columns>
        <sdk:DataGridTemplateColumn Header="Hand">
            <sdk:DataGridTemplateColumn.CellTemplate>
                <DataTemplate>
                    <Grid>
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition />
                            <ColumnDefinition />
                        </Grid.ColumnDefinitions>

                        <Border
                            Margin="2" CornerRadius="4"
                            BorderBrush="Black"
                            BorderThickness="1" />
                        <Rectangle
                            Margin="4" Fill="White"
                            Grid.Column="0" />
                        <Border
                            Margin="2" CornerRadius="4"
                            BorderBrush="Black"
                            BorderThickness="1"
                            Grid.Column="1" />
                        <Rectangle
                            Margin="4" Fill="White"
                            Grid.Column="1" />
                        <TextBlock
                            Text="{Binding Card1}"
                            HorizontalAlignment="Center"
                            VerticalAlignment="Center" "
                            Grid.Column="0" />
                        <TextBlock
                            Text="{Binding Card2}"
                            HorizontalAlignment="Center"
                            VerticalAlignment="Center"
                            Grid.Column="1" />

                    </Grid>
                </DataTemplate>
            </sdk:DataGridTemplateColumn.CellTemplate>
        </sdk:DataGridTemplateColumn>

        <sdk:DataGridTextColumn
            Header="Nickname"
            Binding="{Binding Nickname}"  />
        <sdk:DataGridTextColumn
            Header="Notes"
            Binding="{Binding Notes}" />

    </sdk:DataGrid.Columns>
</sdk:DataGrid>

Save the MainPage.xaml file and navigate to the code behind for the application, located in the MainPage.xaml.cs file. Wire up the Loaded event handler for the page, as follows:

public partial class MainPage : UserControl
{
    public MainPage()
    {
        InitializeComponent();
        this.Loaded += new RoutedEventHandler(Page_Loaded);
    }
    void Page_Loaded(object sender, RoutedEventArgs e)
    {
        throw new NotImplementedException();
    }
}

Next, you need to call the WCF service. In Silverlight, web services can be called only asynchronously, so the browser's execution is not blocked by the transaction. In order to do this, you need to get an instance of the service reference (commonly referred to as the web service proxy class) named StartingHandService, which you added earlier. You will then wire up an event handler for the service's GetHandsCompleted event, which you examined in the Object Browser (in step 11). This is the event handler that will be called when the service has completed execution. Finally, you will execute the GetHandsAsync() method.

Within the Page_Loaded event handler, first obtain an instance of StartingHandService. Then, in the GetHandsCompleted event handler, bind the ItemsSource of the DataGrid to the result returned from the service call, as shown in the following code. Note that normally you will want to check the result to make certain that the web service call was successful, and alert the user accordingly in case of failure.

using WCFService.StartingHandServiceReference;

...

public partial class MainPage : UserControl
{
    public MainPage()
    {
        InitializeComponent();
        this.Loaded += new RoutedEventHandler(Page_Loaded);
    }

    void Page_Loaded(object sender, RoutedEventArgs e)
    {
        StartingHandServiceClient service = new StartingHandServiceClient();
        service.GetHandsCompleted += new
                    EventHandler<GetHandsCompletedEventArgs>(
                    service_GetHandsCompleted);
        service.GetHandsAsync();
    }

    void service_GetHandsCompleted(object sender, GetHandsCompletedEventArgs e)
    {
        this.grdData.ItemsSource = e.Result;
    }
}

Test your application. If all goes well, you should see the populated DataGrid, as shown earlier in Figure 7-1.