上接稳扎稳打Silverlight(23) - 2.0通信之调用WCF的双向通信(Duplex Service)

<UserControl x:Class="Silverlight20.Communication.Duplexservice"
        xmlns="http://scheR_224_11845@as.microsoft.com/winfx/2006/xaml/presentation"    
        xmlns:x="http://scheR_224_11845@as.microsoft.com/winfx/2006/xaml">
        <StackPanel HorizontalAlignment="Left" Margin="5">
        
                <TextBox x:Name="txtStockCode" Text="请输入股票代码" Margin="5" />
                <Button x:Name="btnSubmit" Content="获取股票信息" Click="btnSubmit_Click" Margin="5" />
                <Button x:Name="btnStop" Content="停止获取" Click="btnStop_Click"    Margin="5" />
                <TextBlock x:Name="lblStockmessage" Margin="5" />
        
        </StackPanel>
</UserControl>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;

using System.serviceModel;

using System.serviceModel.ChAnnels;

using System.Threading;

using System.IO;

namespace Silverlight20.Communication

{

         public partial class Duplexservice : UserControl

        {

                SynchronizationContext _syncContext;

                 // 是否接收服务端发送过来的消息

                 bool _status = true;

                 public Duplexservice()

                {

                        initializeComponent();

                }

                 private void btnSubmit_Click( object sender,RoutedEventArgs E)

                {

                        _status = true;

                         // UI 线程

                        _syncContext = SynchronizationContext.Current;

                        PollingDuplexhttpBinding binding = new PollingDuplexhttpBinding()

                        {

                                 // InactivityTimeout - 服务端与客户端在此超时时间内无任何消息交换的情况下，服务会关闭其会话

                                inactivityTimeout = TimeSpan.Fromminutes(1)

                        };

                         // 构造 IDuplexSessionChAnnel 的信道工厂

                        IChAnnelFactory<IDuplexSessionChAnnel> factory =

                                binding.buildChAnnelFactory<IDuplexSessionChAnnel>( new BindingParameterCollection());

                         // 打开信道工厂

                        IAsyncResult factoryOpenResult =

                                factory.beginOpen( new AsyncCallBACk(OnOpenCompleteFactory),factory);

                         if (factoryOpenResult.CompletedSynchronously)

                        {

                                 // 如果信道工厂被打开的这个 异步操作 已经被 同步完成 则执行下一步

                                CompleteOpenFactory(factoryOpenResult);

                        }

                }

                 private void btnStop_Click( object sender,RoutedEventArgs E)

                {

                        _status = false;

                }

                 void OnOpenCompleteFactory(IAsyncResult result)

                {

                         // 该异步操作已被同步完成的话则不做任何操作，反之则执行下一步

                         if (result.CompletedSynchronously)

                                 return;

                         else

                                CompleteOpenFactory(result);

                }

                 void CompleteOpenFactory(IAsyncResult result)

                {

                        IChAnnelFactory<IDuplexSessionChAnnel> factory = result.AsyncState as IChAnnelFactory<IDuplexSessionChAnnel>;

                         // 完成异步操作，以打开信道工厂

                        factory.Endopen(result);

                         // 在信道工厂上根据指定的地址创建信道

                        IDuplexSessionChAnnel chAnnel =

                                factory.CreateChAnnel( new EndpointAddress( "http://localhost:3036/Duplexservice.svc"));

                        // 打开信道

                        IAsyncResult chAnnelOpenResult =

                                chAnnel.beginOpen(new AsyncCallBACk(OnOpenCompleteChAnnel),chAnnel);

                        if (chAnnelOpenResult.CompletedSynchronously)

                        {

                                // 如果信道被打开的这个 异步操作 已经被 同步完成 则执行下一步

                                CompleteOpenChAnnel(chAnnelOpenResult);

                        }

                }

                void OnOpenCompleteChAnnel(IAsyncResult result)

                {

                        // 该异步操作已被同步完成的话则不做任何操作，反之则执行下一步

                        if (result.CompletedSynchronously)

                                return;

                        else

                                CompleteOpenChAnnel(result);

                }

                void CompleteOpenChAnnel(IAsyncResult result)

                {

                        IDuplexSessionChAnnel chAnnel = result.AsyncState as IDuplexSessionChAnnel;

                        // 完成异步操作，以打开信道

                        chAnnel.Endopen(result);

                        // 构造需要发送到服务端的 System.serviceModel.ChAnnels.message （客户端终结点与服务端终结点之间的通信单元）

                        message message = message.Createmessage(

                                chAnnel.GetProperty<messageVersion>(),// messageVersion.soap11 （Duplex 服务仅支持 Soap11）

                                "Silverlight20/IDuplexservice/SendStockCode",// Action 为请求的目的地（需要执行的某行为的路径）

                                txtStockCode.Text);

                        // 向目的地发送消息

                        IAsyncResult resultChAnnel =

                                chAnnel.beginSend(message,new AsyncCallBACk(OnSend),chAnnel);

                        if (resultChAnnel.CompletedSynchronously)

                        {

                                // 如果向目的地发送消息的这个 异步操作 已经被 同步完成 则执行下一步

                                CompleteOnSend(resultChAnnel);

                        }

                        // 监听指定的信道，用于接收返回的消息

                        receiveLoop(chAnnel);

                }

                void OnSend(IAsyncResult result)

                {

                        // 该异步操作已被同步完成的话则不做任何操作，反之则执行下一步

                        if (result.CompletedSynchronously)

                                return;

                        else

                                CompleteOnSend(result);

                }

                void CompleteOnSend(IAsyncResult result)

                {

                        try

                        {

                                IDuplexSessionChAnnel chAnnel = (IDuplexSessionChAnnel)result.AsyncState;

                                // 完成异步操作，以完成向目的地发送消息的操作

                                chAnnel.EndSend(result);

                        }

                        catch (Exception eX)

                        {

                                _syncContext.Post(WriteText,ex.ToString() + Environment.NewLinE);

                        }

                }

                void ReceiveLoop(IDuplexSessionChAnnel chAnnel)

                {

                        // 监听指定的信道，用于接收返回的消息

                        IAsyncResult result =    

                                chAnnel.beginReceive(new AsyncCallBACk(OnReceiveCompletE),chAnnel);

                        if (result.CompletedSynchronously)

                        {

                                CompleteReceive(result);

                        }

                }

                void OnReceiveComplete(IAsyncResult result)

                {

                        if (result.CompletedSynchronously)

                                return;

                        else

                                CompleteReceive(result);

                }

                void CompleteReceive(IAsyncResult result)

                {

                        IDuplexSessionChAnnel chAnnel = (IDuplexSessionChAnnel)result.AsyncState;

                        try

                        {

                                // 完成异步操作，以接收到服务端发过来的消息

                                message receivedmessage = chAnnel.EndReceive(result);

                                if (receivedmessage == null)

                                {

                                        // 服务端会话已被关闭

                                        // 此时应该关闭客户端会话，或向服务端发送消息以启动一个新的会话

                                }

                                else

                                {

                                        // 将接收到的信息输出到界面上

                                        String text = receivedmessage.GetBody<String>();

                                        _syncContext.Post(WriteText,text + Environment.NewLinE);

                                        if (!_status)

                                        {

                                                // 关闭信道

                                                IAsyncResult resultFactory =

                                                        chAnnel.beginClose(new AsyncCallBACk(OnCloseChAnnel),chAnnel);

                                                if (resultFactory.CompletedSynchronously)

                                                {

                                                        CompleteCloseChAnnel(result);

                                                }

                                        }

                                        else

                                        {

                                                // 继续监听指定的信道，用于接收返回的消息

                                                receiveLoop(chAnnel);

                                        }

                                }

                        }

                        catch (Exception eX)

                        {

                                // 出错则记日志

                                using (StreamWriter sw = new StreamWriter(@"C:\Silverlight_Duplex_Log.txt",true))

                                {

                                        sw.Write(ex.ToString());

                                        sw.WriteLine();

                                }

                        }

                }

                void OnCloseChAnnel(IAsyncResult result)

                {

                        if (result.CompletedSynchronously)

                                return;

                        else

                                CompleteCloseChAnnel(result);

                }

                void CompleteCloseChAnnel(IAsyncResult result)

                {

                        IDuplexSessionChAnnel chAnnel = (IDuplexSessionChAnnel)result.AsyncState;

                        // 完成异步操作，以关闭信道

                        chAnnel.EndClose(result);

                }

                void WriteText(object text)

                {

                        // 将信息打到界面上

                        lblStockmessage.Text += (String)text;

                }

        }

}