深入浅出Windows应用开发(四)

WebRequest request=HttpWebRequest.Create("http://www.baidu.com");

//设置为Get请求
request.Method="GET"
//通过HTTP头设置请求的Cookie
request.Headers["Cookie"]="name==value"
//设置身份验证的网络凭据
reqeust.Credentials=new NetworkCredential("accountKey","accountkeyOrPassword');
//发起GetResponse请求
request.BeginGetResponse(ResponseCallback,request);
//请求回调方法
private async void ResponseCallback(IAsyncResult result){
	HttpWebRequest httpWebRequest=(HttpWebRequest)result.AsyncState;
	WebResponse webResponse=httpWebRequest.EndGetResponse(result);
	... ...获取请求返回的内容
}

//请求回调方法
private async void ResponseCallback(IAsyncResult result){
	HttpWebRequest httpWebRequest=(HttpWebRequest)result.AsyncState;
	WebResponse webResponse=httpWebRequest.EndGetResponse(result);
//获取请求返回的内容
using(Stream stream=webResponse.GetResponseStream()){
	using(StreamReader reader=new StreamReader(stream)){
	//请求返回的字符串内容
	string content=reader.ReadToEnd();
}
}
}

	try{
	HttpWebRequest httpWebRequest=(HttpWebRequest)result.AsyncState;
	WebResponse webResponse=httpWebRequest.EndGetResponse(result);
	using(Stream stream=webResponse.GetResponse()){
	using(StreamReader reader=new StreamReader(stream)){
	string content=reader.ReadToEnd();
	
}
}
}catch(WebException e){
	switch(e.Status){
	case WebExceptionStatus.ConnectFailure:
	exceptionInfo="ConnectFailure:远程服务器连接失败.";
	break;
	case WebExceptionStatus.MessageLengthLimitExceeded:
	exceptionInfo="MessageLengthLimitExceeded:网络请求的消息长度受到限制."
	break;
	case WebExceptionStatus.Pending:
	exceptionInfo="Pending:内部异步请求挂起";
	break;
	case WebExceptionStatus.RequestCanceled:
	exceptionInfo="RequestCanceled:该请求将被取消";
	break；
	case WebExceptionStatus.SendFailure:
	exceptionInfo="SendFailure发送失败,未能将完整请求发送到远程服务器";
	break;
	case WebExceptionStatus.UnknownError:
	exceptionInfo="UnknownError:未知错误.";
	break;
	case WebExceptionStatus.Success:
	exceptionInfo="Success:请求成功";
	break;
}
}

//创建WebRequest对象
var request=HttpWebRequest.Create("http://www.yourwebsite.com");
//设置请求的方式为Post
request.Method="POST";
//发起获取发送数据流的请求
request.BeginGetRequestStream(ResponseStreamCallbackPost,request);
//发起获取发送数据流的请求的响应回调方法
private async void ResponseStreamCallbackPost(IAsyncResult result){
	HttpWebRequest httpWebRequest=(httpWebRequest)result.AsyncState;
	...接下来通过发送数据流来发送数据
}

//发起获取发送数据流的请求的响应回调方法
private async void ResponseStreamuCallbackPost(IAsyncResult result){
	HttpWebRequest httpWebRequest=(HttpWebRequest)result.AsyncState;
	using(Stream stream=httpWebRequest.EndGetRequestStream(result)){
	//需要把待发送的数据通过byte[]数据格式发送出去
	//把字符串的信息转换为byte[]
	byte[] data=Encoding.UTF8.GetBytes(postString);
	stream.Write(data,0,data.length);
}
	...接下来获取请求的响应
}

httpWebRequest.BeginGetResponse(ResponseCallbackPost,httpWebRequest);
//请求回调方法
private async void ResponseCallbackPost(IAasyncResult result){
	HttpWebRequest httpWebRequest=(HttpWebRequest)result.AsyncState;
	WebResponse webResponse=httpWebRequest.EndGetResponse(result);
	//获取请求返回的内容
using(Stream stream=webResponse.GetResponseStream()){
	using(StreamReader reader=new StreamReader(stream)){
	//请求返回的字符串内容
	string content=reader.ReadToEnd();
}
}
}

//信号量对象
private AutoResetEvent autoResetEvent;
//网络请求对象
private HttpWebRequest request;
//超时控制的方法,3秒钟没有网络返回将取消网络请求
await Task.Factory.StartNew(networkRequest);
//等待3秒钟
autoResetEvent.WaitOne(3000);
if(request!=null){
	//取消网络请求
	request.Abort();
}

Range:(unit=first byte pos)-[last byte pos]

var request=HttpWebRequest.Create(url);
request.Method="GET";
request.Headers["Range"]="bytes-0-100";
request.BeginGetResponse(ResponseCallbackTimeTest,request);

<Page
    x:Class="App1.RssPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:App1"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

    <Grid>
        <StackPanel>
            <TextBox Header="请输入合法的RSS阅读源的地址:" x:Name="rssURL" Text="http://www.cnblogs.com/rss"/>
            <Button Content="加载RSS" Click="Button_Click" Width="370"/>
            <ListView x:Name="listbox" SelectionChanged="listbox_SelectionChanged" Height="350"
                      >
                <ListView.ItemTemplate>
                    <DataTemplate>
                        <Grid>
                            <Grid.RowDefinitions>
                                <RowDefinition Height="Auto"/>
                                <RowDefinition Height="Auto"/>
                                <RowDefinition Height="60"/>
                            </Grid.RowDefinitions>
                            <TextBlock Grid.Row="0" Text="{Binding Title}" FontSize="25" TextWrapping="Wrap"/>
                            <TextBlock Grid.Row="1" Text="{Binding PublishedDate}" FontSize="20"/>
                            <TextBlock Grid.Row="2" TextWrapping="Wrap" Text="{Binding PlainSummary}"
                                       FontSize="18" Opacity="0.5"/>
                        </Grid>
                    </DataTemplate>
                </ListView.ItemTemplate>
            </ListView>
        </StackPanel>
        
    </Grid>
</Page>
using App1.Models;
using App1.Services;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Popups;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

// https://go.microsoft.com/fwlink/?LinkId=234238 上介绍了“空白页”项模板

namespace App1
{
    /// <summary>
    /// 可用于自身或导航至 Frame 内部的空白页。
    /// </summary>
    public sealed partial class RssPage : Page
    {
        public RssPage()
        {
            this.InitializeComponent();
        }
        /// <summary>
        /// 加载RSS列表
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void Button_Click(object sender, RoutedEventArgs e)
        {
            if (rssURL.Text!=null)
            {
                //调用封装好的RSS请求方法加载RSS列表
                RssService.GetRssItems(rssURL.Text, async (items) =>
                {
                    //请求正常完成,把RSS文章的内容绑定到列表控件
                    await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        listbox.ItemsSource = items;
                    });
                },
                async (exception) =>
                {
                    //请求出现异常,把异常信息显示出来
                    await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
                    {
                        await new MessageDialog(exception).ShowAsync();
                    });
                },null
                );
            }
            else
            {
                await new MessageDialog("请输入RSS地址").ShowAsync();
            }
        }

        //通过列表选项选中事件来跳转到查看文章详情的页面
        private void listbox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            //列表控件的选中项
            if (listbox.SelectedItem == null)
                return;
            var template=(RssItem)listbox.SelectedItem;
            //跳转到详情页面,并且把RssItem对象作为参数传递过去
            Frame.Navigate(typeof(DetailPage), template);
            listbox.SelectedItem = null;
        }
    }
}
<Page
    x:Class="App1.DetailPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:App1"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <StackPanel x:Name="TitlePanel" Margin="12,0,0,28">
            <TextBlock Text="Rss阅读器" FontSize="20"/>
            <TextBlock Text="{Binding Title}" FontSize="25" TextWrapping="Wrap"/>
        </StackPanel>
        <Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
            <StackPanel>
                <TextBlock Text="{Binding PublishedDate}" FontSize="15" Opacity="0.5"/>
                <TextBlock Text="{Binding Url}" FontSize="15" Opacity="0.5"/>
                <ScrollViewer Height="500">
                    <TextBlock Text="{Binding PlainSummary}" FontSize="20" TextWrapping="Wrap"/>
                </ScrollViewer>
            </StackPanel>
        </Grid>
    </Grid>
</Page>
using App1.Models;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

// https://go.microsoft.com/fwlink/?LinkId=234238 上介绍了“空白页”项模板

namespace App1
{
    /// <summary>
    /// 可用于自身或导航至 Frame 内部的空白页。
    /// </summary>
    public sealed partial class DetailPage : Page
    {
        public DetailPage()
        {
            this.InitializeComponent();
        }
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            RssItem item=e.Parameter as RssItem;
            if (item!=null)
            {
                //把文章对象绑定到当前的页面的上下文来进行显示
                this.DataContext= item;
            }
        }
    }
}

Uri uri=new Uri("http://yourwebsite.com");
HttpClient httpClient=new HttpClient();
//获取网络的返回的字符串数据
string result=await httpClient.GetStringAsync(uri);

HttpResponseMessage response=await httpClient.GetAsync(uri);
string responseBody=await response.Content.ReadAsStringAsync();

using(Stream responseStream=(await response.Content.ReadAsInputStreamAsync()).AsStreamForRead()){
	int read=0;
	byte[] responseBytes=new Byte[1000];
	do{
	//如果read等于0表示Stream的数据以及读取完毕
	read=await responseStream.ReadAsync(responseBytes,0,responseBytes.Length);
}while(read!=0);
}

private CancellationTokenSource cts=new CancellationTokenSource();
try{
//使用CancellationTokenSource对象来控制异步任务的取消操作
HttpResponseMessage response=await httpClient.GetAsync(new Uri(resourceAddress)).AsTask(cts.Token);
responseBody=await response.Content.ReadAsStringAsync().AsTask(cts.Token);
cts.Token.ThrowIfCancellationRequested();
}catch(TaskCanceledException)
responseBody="请求被取消";	
}
//调用Cancel方法取消网络请求
if(cts.Token.CanBeCanceled){
	cts.Cancel();
}
14.22.Post请求发送字符串和数据流数据
使用HttpClient类发起Post请求的编程方式也很简洁,可以调用方法PostAsync(Uri uri,IHttpContent content)来直接向目标的地址Post数据,在该方法里面有两个参数,uri就是网络的目标地址,content是指向目标地址Post的数据对象,在Post数据之前,首先把数据初始化成一个IHttpContent对象,实现了IHttpContent接口的类有HttpStringContent类,HttpStream类和HttpBufferContent类,这三个类分别代表了字符串类型,数据流类型和二进制类型,数据流类型和二进制类型可以互相转换.调用PostAsync方法之后会返回一个HttpResponseMessage对象,通过这个HTTP的相应消息对象就可以获取Post请求之后的返回结果信息.Post请求发送字符串和数据流数据
``` bash
1.Post请求发送字符串数据
HttpStringContent httpStringContent=new HttpStringContent("hello Windows 10");
HttpResponseMessage response=await httpClient.PostAsync(uri,httpStringContent).AsTask(cts.Token);
string responseBody=await response.Content.ReadAsStringAsync().AsTask(cts.Token);
2.Post请求发送数据流数据
HttpStreamContent streamContent=new HttpStreamContent(stream.AsInputStrem());
httpResponseMessage response=await httpClient.PostAsync(uri,streamContent).AsTask(cts.Token);
string responseBody=await response.Content.ReadAsStringAsync().AsTask(cts.Token);

//创建HttpRequestMessage对象
HttpStreamContent streamContent=new HttpStreamContent(stream.AsInputStream());
HttpRequestMessage request=new HttpRequestMessage(HttpMethod.Post,new Uri(resourceAddress));
request.Content=streamContent;
//发送数据
HttpResponseMessage response=await httpClient.SendRequestAsync(request).AsTask(cts.Token);
string responseBody=await response.Content.ReadAsStringAsync().AsTask(cts.Token);

//创建一个HttpBaseProtocolFilter对象
HttpBaseProtocolFilter filter=new HttpBaseProtocolFilter();
//通过HttpBaseProtocolFilter对象获取使用HttpClient进行过网络请求的地址的Cookie信息
HttpCookieCollection cookieCollection=filter.CookieManager.GetCookies(new Uri(resourceAddress));
//遍历整个Cookie集合的Cookie信息
foreach(HttpCookie cookie in cookieCollection){}

//创建一个HttpCookie对象,"id"标识是Cookie的名称,"localhost"是主机名,"/"是表示服务器的虚拟路径
HttpCookie cookie=new HttpCookie("id","yourwebsite.com","/");
//设置Cookie的值
cookie.Value="123456";
//设置Cookie存活的时间,如果设置为null表示只是在一个会话里面生效
cookie.Expries=new DateTimeOffset(DateTime.Now,new TimeSpan(0,1,8));
//在过滤器里面设置Cookie
HttpBaseProtocolFilter filter=new HttpBaseProtocolFilter();
bool replaced=filter.CookieManager.SetCookie(cookie,false);
...接下来可以向"yourwebsite.com"远程主机发起请求

//创建IProgress<HttpProgress>对象
IProgress<HttpProgress> progress=new Progress<HttpProgress>(ProgressHandler);
//在异步任务中加入进度监控
HttpResponseMessage response=await httpClient.PostAsync(new Uri(resourceAddress),streamContent).AsTask(cts.Token,progress);
//进度监控的回调方法
private void ProgressHandler(HttpProgress progress){
	//这里可以通过progress参数获取进度的相关信息
}

public class plugInFilter:IHttpFilter{
	private IHttpFilter innerFilter;
	public PlugFilter(IHttpFilter innerFilter){
	if(innerFilter==null){
	throw new ArgumentException("innerFilter cannot be null");
	}
	this.innerFilter=innerFilter;
}
//在SendRequestAsync方法里面添加自定义的HTTP头
public IAsyncOperationWithProgress<HttpResponseMessage,HttpProgress>SendRequestAsync(HttpRequestMessage request){
	return AsyncInfo.Run<HttpResponseMessage,HttpProgress>(async(cancellationToken,progress)=>{
	//添加请求头
	request.Headers.Add("Custom-header","CustomRequestValue");
	HttpResonseMessage response=await innerFilter.SendRequestAsync(request).AsTask(cancellationToken,progress);
	cancellationToken.ThrowIfCancellationRequested();
	//添加响应头
response.Headers.Add("Custom-header","CustomResponseValue");
	return response;
});
}
public void Disponse(){
	innerFilter.Disponse();
	GC.SuppressFinalize(this);
}
}

//先创建一个HttpBaseProtocolFilter对象,这是因为HttpClient默认的最底层的筛选器
var basefilter=new HttpBaseProtocolFilter();
//创建PlugInFilter筛选器对象,链接到HttpBaseProtocolFilter对象上
var myfilter=new PlugInFilter(basefilter);
//使用自定义的筛选器创建HttpClient对象
HttpClient httpClient=new HttpClient(myfilter);
...下面使用httpClient对象来发起网络请求都会自动带上自定义筛选器所添加的HTTP头.

<Page
    x:Class="App1.WebPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:App1"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <Grid Margin="12,0,12,0">
            <StackPanel>
                <Button Content="Get String" Click="Button_Click" Width="370"/>
                <Button Content="Get Stream" Click="Button_Click_1" Width="370"/>
                <Button Content="Post String" Click="Button_Click_2" Width="370"/>
                <Button Content="Post Stream" Click="Button_Click_3" Width="370"/>
                <Button Content="请求进度监控" Click="Button_Click_4" Width="370"/>
                <Button Content="Cookie设置" Click="Button_Click_5" Width="370"/>
                <Button Content="Cookie获取" Click="Button_Click_6" Width="370"/>
            </StackPanel>
        </Grid>
        <!--操作的进度,网络信息的展示面板,一开始隐藏,发起网络操作时显示出来,完成后再隐藏-->
        <Grid Grid.RowSpan="2" x:Name="waiting" Visibility="Collapsed">
            <Grid Background="Black" Opacity="0.8">
            </Grid>
            <StackPanel Background="Black" HorizontalAlignment="Center" VerticalAlignment="Center"
                        Grid.RowSpan="2">
                <TextBlock x:Name="information" Text="正在请求数据... ..." FontSize="30" TextWrapping="Wrap"/>
                <Button Content="取消操作" x:Name="cancel" Click="cancel_Click" Width="370"/>
            </StackPanel>
        </Grid>
    </Grid>
</Page>
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;

using System.Runtime.InteropServices.WindowsRuntime;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.Security.Cryptography;
using Windows.Storage.Streams;
using Windows.UI.Popups;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;
using Windows.Web.Http;
using Windows.Web.Http.Filters;







// https://go.microsoft.com/fwlink/?LinkId=234238 上介绍了“空白页”项模板

namespace App1
{
    /// <summary>
    /// 可用于自身或导航至 Frame 内部的空白页。
    /// </summary>
    public sealed partial class WebPage : Page
    {
        public WebPage()
        {
            this.InitializeComponent();
            //初始化HTTP请求对象
            httpClient = new HttpClient();
            //初始化异步任务取消对象
            cts = new CancellationTokenSource();
        }
        //服务器地址
        private string server = "http://localhost:8081/default.aspx";
        //HTTP请求对象
        private HttpClient httpClient;
        //异步任务取消对象
        private CancellationTokenSource cts;
        private async void HttpRequestAsync(Func<Task<string>> httpRequestFuncAsync) {
            string responseBody;
            waiting.Visibility = Visibility.Visible;
            try
            {
                responseBody = await httpRequestFuncAsync();
                cts.Token.ThrowIfCancellationRequested();
            }
            catch (TaskCanceledException)
            {
                responseBody = "请求被取消";

            }
            catch (Exception ex)
            {
                responseBody = "异常消息" + ex.Message;
            }
            finally {
                waiting.Visibility = Visibility.Collapsed;
            }
            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
            {
                await new MessageDialog(responseBody).ShowAsync();
            });
        }
        //Get请求获取string类型数据
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            HttpRequestAsync(async () =>
            {
                string resourceAddress = server + "?cacheable=1";
                HttpResponseMessage response = await httpClient.GetAsync(new Uri(resourceAddress));
                string responseBody = await response.Content.ReadAsStringAsync().AsTask(cts.Token);
                return responseBody;
            });
        }
        //get请求获取Stream类型数据
        private void Button_Click_1(object sender, RoutedEventArgs e)
        {
            HttpRequestAsync(async () => {
                string resourceAddress = server + "?extraData=2000";
                StringBuilder responseBody = new StringBuilder();
                HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get,new Uri(resourceAddress));
                HttpResponseMessage response = await httpClient.SendRequestAsync(request, HttpCompletionOption.ResponseHeadersRead).AsTask(cts.Token);
                using (Stream responseStream=(await response.Content.ReadAsInputStreamAsync()).AsStreamForRead())
                {
                    int read = 0;
                    byte[] responseBytes = new byte[1000];
                    do
                    {
                        read = await responseStream.ReadAsync(responseBytes,0,responseBytes.Length);
                        responseBody.AppendFormat("Bytes read from stream:{0}",read);
                        responseBody.AppendLine();
                        //把byte[]转换为IBuffer类型,IBuffer接口是Win10标准的二进制数据接口
                        IBuffer responseBuffer=CryptographicBuffer.CreateFromByteArray(responseBytes);
                        responseBuffer.Length = (uint)read;
                        //转换为Hex字符串,ASCII文本这些记录由对应机器语言码和/或常量数据的十六进制编码数字组成
                        responseBody.AppendFormat(CryptographicBuffer.EncodeToHexString(responseBuffer));
                        responseBody.AppendLine();
                    } while (read!=0);
                }
                return responseBody.ToString();
            });
        }
        /// <summary>
        /// Post请求发送String类型数据
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Button_Click_2(object sender, RoutedEventArgs e)
        {
            HttpRequestAsync(async () =>
            {
                string resourceAdderss = server;
                string responseBody;
                HttpResponseMessage response = await httpClient.PostAsync(new Uri(resourceAdderss), new HttpStringContent("hello Windows Phone")).AsTask(cts.Token);
                responseBody= await response.Content.ReadAsStringAsync().AsTask(cts.Token);
                return responseBody;
            });
        }
        /// <summary>
        /// Post 请求发送Stream类型数据
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Button_Click_3(object sender, RoutedEventArgs e)
        {
            HttpRequestAsync(async () =>
            {
                string resourceAddress = server;
                string responseBody;
                const int contentLegnth = 1000;
                //使用Stream数据初始化一个HttpStreamContent对象
                Stream stream = GenerateSampleStream(contentLegnth);
                HttpStreamContent streamContent = new HttpStreamContent(stream.AsInputStream());
                //初始化一个Post类型的HttpReqeustMessage对象
                HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, new Uri(resourceAddress));
                request.Content = streamContent;
                //发送Post请求
                HttpResponseMessage response=await httpClient.SendRequestAsync(request).AsTask(cts.Token);
                //获取请求的结果
                responseBody=await response.Content.ReadAsStringAsync().AsTask(cts.Token);
                return responseBody;
            });
        }
        /// <summary>
        /// 获取测试的数据流对象
        /// </summary>
        /// <param name="contentLegnth"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        private Stream GenerateSampleStream(int size)
        {
            byte[] subData= new byte[size];
            for (int i = 0; i < subData.Length; i++)
            {
                //ASCII编码40表示是字符“（”
                subData[i] = 40;
            }
            return new MemoryStream(subData);
        }
        /// <summary>
        /// 监控Post请求的进度情况
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Button_Click_4(object sender, RoutedEventArgs e)
        {
            HttpRequestAsync(async () => { 
                string resourceAddress = server;
                string responseBody;
                const uint streamLength = 1000000;
                HttpStreamContent streamContent = new HttpStreamContent(new SlowInputStream(streamLength));
                streamContent.Headers.ContentLength = streamLength;
                //创建进度对象
                IProgress<HttpProgress> progress= new Progress<HttpProgress>(ProgressHandler);
                HttpResponseMessage response=await httpClient.PostAsync(new Uri(resourceAddress),streamContent).AsTask(cts.Token);
                responseBody = "完成";
                return responseBody;
            });
        }

        private void ProgressHandler(HttpProgress progress)
        {
            string infoString = "";
            infoString = progress.Stage.ToString();
            //需要发送的数据
            ulong totalBytesToSend = 0;
            if (progress.TotalBytesToSend.HasValue)
            {
                totalBytesToSend = progress.TotalBytesToSend.Value;
                infoString += "发送数据:" + totalBytesToSend.ToString(CultureInfo.InvariantCulture);
            }
            //已接收的数据
            ulong totalBytesToReceive = 0;
            if (progress.TotalBytesToReceive.HasValue) { 
                totalBytesToReceive= progress.TotalBytesToReceive.Value;
                infoString += "接收数据:" + totalBytesToReceive.ToString(CultureInfo.InvariantCulture);
            }
            double requestProgress = 0;
            //前面50%是发送进度,后面50%是接收进度
            if (progress.Stage==HttpProgressStage.SendingContent && totalBytesToSend>0)
            {
                requestProgress = progress.BytesSent * 50 / totalBytesToSend;
                infoString += "发送进度";
            }
            else if (progress.Stage==HttpProgressStage.ReceivingContent)
            {
                requestProgress += 50;
                if (totalBytesToReceive>0)
                {
                    requestProgress += progress.BytesReceived * 50 / totalBytesToReceive;
                }
                infoString += "接收进度:";
            }
            else
            {
                return;
            }
            infoString += requestProgress;
            information.Text= infoString;

        }
        /// <summary>
        /// 设置网络请求的Cookie
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Button_Click_5(object sender, RoutedEventArgs e)
        {
            HttpRequestAsync(async () => {
                string resourceAddress = server;
                string responseBody;
                //创建一个HttpCookie对象,"id"表示是Cookie的名称,"localhost"是主机名,"/"是表示服务器的虚拟路径
                HttpCookie cookie = new HttpCookie("id","localhost","/");
                cookie.Value = "123456";
                //设置为null表示只是在一个会话里面生效
                cookie.Expires = null;
                HttpBaseProtocolFilter filter= new HttpBaseProtocolFilter();
                bool replaced = filter.CookieManager.SetCookie(cookie,false);
                HttpResponseMessage response = await httpClient.PostAsync(new Uri(resourceAddress),new HttpStringContent("hello Windows Phone")).AsTask(cts.Token);
                responseBody=await response.Content.ReadAsStringAsync().AsTask(cts.Token);
                return responseBody;
            });
        }
        /// <summary>
        /// 获取网络请求的Cookie
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Button_Click_6(object sender, RoutedEventArgs e)
        {
            HttpRequestAsync(async () =>
            {
                string resourceAddress = server+"?setCookies=1";
                string responseBody;
                //发送网络请求
                HttpResponseMessage response=await httpClient.GetAsync(new Uri(resourceAddress)).AsTask(cts.Token);
                responseBody=await response.Content.ReadAsStringAsync().AsTask(cts.Token);
                cts.Token.ThrowIfCancellationRequested();
                //获取基础协议筛选器
                HttpBaseProtocolFilter filter= new HttpBaseProtocolFilter();
                //获取网络请求下载到的Cookie数据
                HttpCookieCollection cookieCollection = filter.CookieManager.GetCookies(new Uri(resourceAddress));
                //遍历Cookie数据的内容
                responseBody = cookieCollection.Count + "cookies:";
                foreach (HttpCookie cookie in cookieCollection)
                {
                    responseBody += "Name:" + cookie.Name + "";
                    responseBody += "Domain:" + cookie.Domain + "";
                    responseBody += "Path:" + cookie.Path + "";
                    responseBody += "Value:" + cookie.Value + "";
                    responseBody += "Expries:" + cookie.Expires + "";
                    responseBody += "Secure:" + cookie.Secure + "";
                }
                return responseBody;
            });
        }
        /// <summary>
        /// 取消网络请求
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cancel_Click(object sender, RoutedEventArgs e)
        {
            cts.Cancel();
            cts.Dispose();
            cts=new CancellationTokenSource();
        }
    }
}

<?xml version="1.0" encoding="UTF-8">
<string xmlns="http://WebXml.com.cn/"></string>

<Page
    x:Class="App1.MobileCodePage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:App1"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

    <Grid>
        <StackPanel>
            <TextBlock x:Name="des" Text="请输入你需要查询的手机号码"/>
            <TextBox x:Name="No" Text=""/>
            <Button Content="查询" Name="search" Click="search_Click"/>
            <TextBlock x:Name="information" Text=""/>
        </StackPanel>
    </Grid>
</Page>
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

// https://go.microsoft.com/fwlink/?LinkId=234238 上介绍了“空白页”项模板

namespace App1
{
    /// <summary>
    /// 可用于自身或导航至 Frame 内部的空白页。
    /// </summary>
    public sealed partial class MobileCodePage : Page
    {
        public MobileCodePage()
        {
            this.InitializeComponent();
        }

        private async void search_Click(object sender, RoutedEventArgs e)
        {
            //实例化一个webservice代理的对象
            MobileCodeService.MobileCodeWSSoapClient proxy=new MobileCodeService.MobileCodeWSSoapClient();
            //调用webservice的方法获取电话号码的归属地
            information.Text = await proxy.getMobileCodeInfoAsync(No.Text,"");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;

namespace WcfService1
{
    // 注意: 使用“重构”菜单上的“重命名”命令，可以同时更改代码和配置文件中的接口名“IService1”。
    [ServiceContract]
    public interface IService1
    {

        [OperationContract]
        string GetData(int value);

        [OperationContract]
        CompositeType GetDataUsingDataContract(CompositeType composite);

        // TODO: 在此添加您的服务操作
    }


    // 使用下面示例中说明的数据约定将复合类型添加到服务操作。
    [DataContract]
    public class CompositeType
    {
        bool boolValue = true;
        string stringValue = "Hello ";

        [DataMember]
        public bool BoolValue
        {
            get { return boolValue; }
            set { boolValue = value; }
        }

        [DataMember]
        public string StringValue
        {
            get { return stringValue; }
            set { stringValue = value; }
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;

namespace WcfService1
{
    // 注意: 使用“重构”菜单上的“重命名”命令，可以同时更改代码、svc 和配置文件中的类名“Service1”。
    // 注意: 为了启动 WCF 测试客户端以测试此服务，请在解决方案资源管理器中选择 Service1.svc 或 Service1.svc.cs，然后开始调试。
    public class Service1 : IService1
    {
        public string GetData(int value)
        {
            return string.Format("You entered: {0}", value);
        }

        public CompositeType GetDataUsingDataContract(CompositeType composite)
        {
            if (composite == null)
            {
                throw new ArgumentNullException("composite");
            }
            if (composite.BoolValue)
            {
                composite.StringValue += "Suffix";
            }
            return composite;
        }
    }
}
创建好的项目默认文件目录如上所示.在Service1.svc中添加方法:
public string HelloWCF(){
	return "Hello WCF";
}
在IService1.cs中添加接口:
[OperationContract]
string HelloWCF();

<TextBlock x:Name="tb1" Text="" FontSize="25"/>
 ///WCF Service
          WcfService.Service1Client proxy=new WcfService.Service1Client();
           tb1.Text = await proxy.HelloWCFAsync();

<uap:VisualElements DisplayName="PushNotificationDemo"
Square150x150Logo="Assets/Logo.png"
... ...
ToastCapable="true"
/uap:VisualElements>

<toast>
	<visual>
		<binding template="ToastText02">
			<text id="1">headlineText</text>
			<text id="2">bodyText</text>		
</binding>
	</visual>
</toast>

<tile>
<visual version="3">
<binding template="TileWide310x150IconWithBadgeAndText">
<image id="1" src=""/>
<text id="1"/>
<text id="2"/>
<text id="3"/>
</binding>
</visual>
</tile>

<badge value=""3"/>

grant_type=client_credentials&client_id=...&client_secrt=......&scope=...

POST /acceddtoken.srf HTTP/1.1
Content-Type:application/x-www-form-urlencoded
Host:https://login.live.com
Content-Length:211

HTTP/1.1 200 OK
Cache-Control:no-store
Content-Length:422
Content-Type:application/json
{
	"access_token":"",
	"token_type":"bearer"
}

[DataContract]
public class OAuthToken{
[DataMember(Name="access_token")]
public string AccessToken{get;set;}
[DataMember(Name="token_type")]
public string TokenType{get;set;}
}
using App1.Models;
using System;
using System.IO;
using System.Net;
using System.Runtime.Serialization.Json;
using System.Text;

namespace App1.Behaviors
{
    public class OAuthTokenHelper
    {

        public OAuthToken GetAccessToken(string secret, string sid) {
            var urlEncodedSecret = UrlEncode(secret);
            var urlEncodedSid = UrlEncode(sid);
            //拼接请求的参数
            var body = String.Format("grant_type=client_credentials&client_id={0}&client_secret={1}&scope=notify.windows.com",urlEncodedSid,urlEncodedSecret);
            string response;
            //发起网络请求获取access-token
            using (WebClient client=new WebClient())
            {
                client.Headers.Add("Content-Type","application/x-www-form-urlencoded");
                response = client.UploadString("https://login.live.com/accesstoken.srf",body);
            }
            return GetOAuthTokenFromJson(response);
        }


        /// <summary>
        /// json字符串转换为对象的方法
        /// </summary>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        private OAuthToken GetOAuthTokenFromJson(string jsonString)
        {
            using (var ms=new MemoryStream(Encoding.Unicode.GetBytes(jsonString)))
            {
                var ser = new DataContractJsonSerializer(typeof(OAuthToken));
                var oAuthToken=(OAuthToken)ser.ReadObject(ms);
                return oAuthToken;
            }
        }
        /// <summary>
        /// Url参数序列化的方法
        /// </summary>
        /// <param name="secret"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        private object UrlEncode(string str)
        {
           StringBuilder sb=new StringBuilder();
            byte[] byStr= Encoding.UTF8.GetBytes(str);
            for (int i = 0; i < byStr.Length; i++)
            {
                sb.Append(@"%" + Convert.ToString(byStr[i],16));
            }
            return sb.ToString();
        }
    }
}
<Page
    x:Class="App1.NotificationPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:App1"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="*"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <StackPanel Grid.Row="0" Orientation="Horizontal">
            <TextBlock Text="通知地址" Margin="0,0,30,0"/>
            <TextBox x:Name="NotiAddress" Text="" Width="300"/>
        </StackPanel>
        <StackPanel Grid.Row="1" Orientation="Horizontal">
            <TextBlock Text="通知内容" Margin="0,0,30,0"/>
            <TextBox x:Name="NotiContent" Text="" Width="300"/>
        </StackPanel>
        <StackPanel Grid.Row="2" Orientation="Horizontal">
            <TextBlock Text="通知状态" Margin="0,0,30,0"/>
            <RadioButton x:Name="radioButton1" IsChecked="True" Content="Raw通知"/>
            <RadioButton x:Name="radioButton2" Content="Tile通知"/>
            <RadioButton x:Name="radioButton3" Content="Toast通知"/>
            <RadioButton x:Name="radioButton4" Content="badge通知"/>
        </StackPanel>
        <StackPanel Grid.Row="3" Orientation="Horizontal" HorizontalAlignment="Center">
            <Button Content="发送通知" Click="Button_Click" Width="120"/>
        </StackPanel>
        <StackPanel Grid.Row="4">
            <TextBlock Text="当前的状态" Margin="150,0,20,0"/>
            <TextBlock x:Name="tb2" Text=""/>
        </StackPanel>
    </Grid>
</Page>
using App1.Behaviors;
using App1.Models;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Runtime.InteropServices.WindowsRuntime;
using System.Text;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

// https://go.microsoft.com/fwlink/?LinkId=234238 上介绍了“空白页”项模板

namespace App1
{
    /// <summary>
    /// 可用于自身或导航至 Frame 内部的空白页。
    /// </summary>
    public sealed partial class NotificationPage : Page
    {
        public NotificationPage()
        {
            this.InitializeComponent();
        }
        /// <summary>
        /// 发送通知
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            sendNotificationType(NotiContent.Text,NotiAddress.Text);
        }
        /// <summary>
        /// 发送推送通知
        /// </summary>
        /// <param name="text1"></param>
        /// <param name="text2"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void sendNotificationType(string message, string notifyUrl)
        {
            //程序包安全标识符(SID)
            string sid = "ms-app://s-1-15-2-4017463433-3104818020-3212661602-2100054673-1509338986-1481803562-2878777805";
            //客户端密钥
            string secret = "dmKrqkwpNF1Bd1L0RDTW1AWkxotlwsqu";//"bs08Acs1RG7jB7pkGVMh8EmGKCG3pH+3";
            OAuthTokenHelper oauth = new OAuthTokenHelper();
            //获取访问的令牌
            OAuthToken token = oauth.GetAccessToken(secret,sid);
            try
            {
                //创建Http对象
                HttpWebRequest myReqeuest = (HttpWebRequest)WebRequest.Create(notifyUrl);
                //toast,tile,badge为text/xml;raw为application/octet-stream
                myReqeuest.ContentType = "text/xml";
                //设置access-token;
                myReqeuest.Headers.Add("Authorization",String.Format("Bearer {0}",token.AccessToken));
                string message2 = "test";
                if ((bool)radioButton1.IsChecked)
                {
                    message2 = message;
                    //推送raw消息
                    myReqeuest.Headers.Add("X-WNS-Type", "wns/raw");
                    //注意raw消息为application/octet-stream
                    myReqeuest.ContentType = "application/octet-stream";
                }
                else if ((bool)radioButton2.IsChecked)
                {
                    message2 = NotifyTile(message);
                    //推送tile消息
                    myReqeuest.Headers.Add("X-WNS-Type", "wns/tile");
                }
                else if ((bool)radioButton3.IsChecked) {
                    message2 = NotifyToast(message);
                    //推送toast消息
                    myReqeuest.Headers.Add("X-WNS-Type","wns/toast");
                }
                else if ((bool)radioButton4.IsChecked)
                {
                    message2 = NotifyBadge(message);
                    //推送badge消息
                    myReqeuest.Headers.Add("X-WNS-Type","wns/badge");
                }
                else
                {
                    //默认的消息
                    myReqeuest.Headers.Add("X-WNS-Type","wns/raw");
                    myReqeuest.ContentType = "application/octet-stream";
                }
                byte[] buffer = Encoding.UTF8.GetBytes(message2);
                myReqeuest.ContentLength = buffer.Length;
                myReqeuest.Method = "POST";
                using (Stream stream=myReqeuest.GetRequestStream())
                {
                    stream.Write(buffer,0,buffer.Length);
                }
                using (HttpWebResponse webResponse=(HttpWebResponse)myReqeuest.GetResponse())
                {
                    /*响应代码说明
                    200 OK,WNS已经接收到通知
                    400 错误的请求
                    401 未授权,token可能无效
                    403 已禁止,mainfest中的identity可能不对
                    404 未找到
                    405 方法不允许
                    406 无法接受
                    410 不存在,信道不存在或过期
                    413 请求实体太大,限制为5000字节
                    500 内部服务器错误
                    503 服务不可用
                    */
                    tb2.Text = webResponse.StatusCode.ToString();
                }
                

            }
            catch (Exception ex)
            {

                tb2.Text = "异常" + ex.Message;
            }
        }
        /// <summary>
        /// 封装Badge消息格式
        /// </summary>
        /// <param name="message"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        private string NotifyBadge(string badge)
        {
            string badgemessage = (@"<badge value="""+badge+@"""/>");
            return badgemessage;
        }
        /// <summary>
        /// 封装Tile消息格式
        /// </summary>
        /// <param name="message"></param>
        /// <returns></returns>
        private string NotifyTile(string message)
        {
            string tilemessage = 
                @"<tile>
                    <visual>
                        <binding template=""TileWideText03"">
                            <text id=""1"">"+message+@"</text>
                        </binding>
                    </visual>
                  </tile>";
            return tilemessage;
        }
        /// <summary>
        /// 封装Toast消息格式
        /// </summary>
        /// <param name="message"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        private string NotifyToast(string message)
        {
            string toastmessage = 
        @"<toast launch=""" + Guid.NewGuid().ToString() + @""">
            <visuallang=""en-US"">
                <binding template=""ToastText01"">
                    <text id=""1"">" + message + @"</text>
                </binding>
            <visual>
          </toast>";
            return toastmessage;
        }
    }
}

<Identity Name="229Geek-Space.PushNotificationDemoeeee" Publisher="CN=748B11E2-8CD3-41F4-9670-D945180F31FC" Version="1.0.0.0"/>
<StackPanel>
	<Button x:Name="bt_open" Content="注册推送通知" Click="bt_open_Click">
	</Button>
	<TextBlock x:Name="info" TextWrapping="Wrap"></TextBlock>
</StackPanel>
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.Networking.PushNotifications;
using Windows.UI.Notifications;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

// https://go.microsoft.com/fwlink/?LinkId=234238 上介绍了“空白页”项模板

namespace App1
{
    /// <summary>
    /// 可用于自身或导航至 Frame 内部的空白页。
    /// </summary>
    public sealed partial class ReceiveNotificationPage : Page
    {
        public ReceiveNotificationPage()
        {
            this.InitializeComponent();
        }
        /// <summary>
        /// 打开推送通知的频道
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void bt_open_Click(object sender, RoutedEventArgs e)
        {
            //创建一个频道
            PushNotificationChannel channel=await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
            //获取频道的地址,实际上是需要把频道的地址发送到云端服务来存储起来
            string uri=channel.Uri;
            //在该测试例子里面我们把地址复制到Windows窗体程序进行发送通知.
            Debug.WriteLine(uri);
            //接收到通知后触发的事件
            channel.PushNotificationReceived += Channel_PushNotificationReceived;
        }
        /// <summary>
        /// 通知接收事件,如果有推送通知,当前应用程序正在运行则会触发该事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        /// <exception cref="NotImplementedException"></exception>
        private async void Channel_PushNotificationReceived(PushNotificationChannel sender, PushNotificationReceivedEventArgs args)
        {
            switch (args.NotificationType)
            {
                case PushNotificationType.Toast://toast通知
                    ToastNotificationManager.CreateToastNotifier().Show(args.ToastNotification);
                    break;
                case PushNotificationType.Tile://tile通知
                    TileUpdateManager.CreateTileUpdaterForApplication().Update(args.TileNotification);
                    break;
                case PushNotificationType.Badge://badge通知
                    BadgeUpdateManager.CreateBadgeUpdaterForApplication().Update(args.BadgeNotification);
                    break;
                case PushNotificationType.Raw://raw通知
                    string msg = args.RawNotification.Content;
                    await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => info.Text = msg);
                    break;
                case PushNotificationType.TileFlyout:
                    break;
                default:
                    break;
            }
        }
    }
}

public async void Connect() {
            //创建一个StreamSocket对象
            StreamSocket clientSocket = new StreamSocket();
            try
            {
                //创建一个主机名字
                HostName serverHost = new HostName(serverHostName);
                //开始链接
                await clientSocket.ConnectAsync(serverHost,serverPort);
                //链接成功
            }
            catch (Exception ex)
            {
                //获取错误的类型 SocketError.GetStatus(exception.HResult)
                //错误消息 exception.Message
                //如果关闭Socket则释放资源
                clientSocket.Dispose();
                clientSocket = null;
            }
        }

/// <summary>
       /// 发送消息
       /// </summary>
       public async void Send() {
           try
           {
               //发送消息
               string sendData = "Test Message str";
               //创建一个DataWriter对象
               DataWriter writer = new DataWriter(clientSocket.OutputStream);
               //获取UTF-8字符串的长度
               Int32len = writer.MeasureString(sendData);
               //存储数据到输出流里面
               await writer.StoreAsync();
               //发送成功释放资源
               writer.DetachStream();
               writer.Dispose();
           }
           catch (Exception ex)
           {
               //获取错误的类型SocketError.GetStatus(exception.HResult)
               //错误消息exception.Message
               //如果关闭Socket则释放资源
               clientSocket.Dispose();
               clientSocket = null;
               
           }
           
       }
       public async void Receive() {
           try
           {
               //接收数据
               DataReader reader = new DataReader(clientSocket.InputStream);
               //设置接收数据的模式
               reader.InputStreamOptions = InputStreamOptions.Partial;
               await reader.LoadAsync(reader.UnconsumedBufferLength);
               //接收成功
           }
           catch (Exception excepiton)
           {

              //... ...
           }
       }

/// <summary>
       /// 监听的连接事件处理
       /// </summary>
       /// <param name="sender"></param>
       /// <param name="args"></param>
       /// <exception cref="NotImplementedException"></exception>
       private async void Listener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
       {
           DataReader reader = new DataReader(args.Socket.InputStream);
           try
           {
               //循环接收数据
               while (true)
               {
                   //读取监听到的消息
                   uint stringLength = reader.ReadUInt32();
                   uint actualStringLength = await reader.LoadAsync(stringLength);
                   //通过reader去读取监听到的消息内容 如reader.ReadString(actualStringLength)

               }
           }
           catch (Exception ex)
           {
               //异常处理
           }
       }

<Page
    x:Class="App1.TcpPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:App1"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

    <Grid>
        <StackPanel>
            <Button Content="开始监听" Margin="12" x:Name="btStartListener" Click="btStartListener_Click"/>
            <Button Content="连接socket" Margin="12" x:Name="btConnectSocket" Click="btConnectSocket_Click"/>
            <TextBox Text="hello" x:Name="tbMsg"/>
            <Button Content="发送消息" Margin="12" x:Name="btSendMsg" Click="btSendMsg_Click"/>
            <Button Content="关闭" Margin="12" x:Name="btClose" Click="btClose_Click"/>
            <ScrollViewer>
                <StackPanel x:Name="lbMsg">
                    <TextBlock Text="收到的消息:" FontSize="20"/>
                </StackPanel>
            </ScrollViewer>
        </StackPanel>
    </Grid>
</Page>
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.Networking;
using Windows.Networking.Sockets;
using Windows.Storage.Streams;
using Windows.UI.Popups;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

// https://go.microsoft.com/fwlink/?LinkId=234238 上介绍了“空白页”项模板

namespace App1
{
    /// <summary>
    /// 可用于自身或导航至 Frame 内部的空白页。
    /// </summary>
    public sealed partial class TcpPage : Page
    {
        public TcpPage()
        {
            this.InitializeComponent();
        }
        //监听器
        StreamSocketListener listener;
        //Socket数据流对象
        StreamSocket socket;
        //输出流的写入数据对象
        DataWriter writer;

        /// <summary>
        /// 监听
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void btStartListener_Click(object sender, RoutedEventArgs e)
        {
            if (listener!=null)
            {
                await new MessageDialog("监听已经启动了").ShowAsync();
                return;
            }
            listener= new StreamSocketListener();
            listener.ConnectionReceived += Listener_ConnectionReceived;
            //开始监听操作
            try
            {
                await listener.BindServiceNameAsync("22112");
                await new MessageDialog("正在监听中").ShowAsync();
            }
            catch (Exception ex)
            {
                listener = null;
                //未知错误
                if (SocketError.GetStatus(ex.HResult)==SocketErrorStatus.Unknown)
                {
                    throw;
                }
            }
        }
        /// <summary>
        /// 监听成功后的连接事件处理
        /// </summary>
        /// <param name="sender">连接的监听者</param>
        /// <param name="args">连接的监听到的数据参数</param>
        private async void Listener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            DataReader reader = new DataReader(args.Socket.InputStream);
            try
            {
                //循环接收数据
                while (true)
                {
                    //读取数据前面的4个字节,代表的是接收到的数据的长度
                    uint sizeFieldCount = await reader.LoadAsync(sizeof(uint));
                    if (sizeFieldCount!=sizeof(uint))
                    {
                        //在socket被关闭之前才可以读取全部的数据
                        return;
                    }
                    //读取字符串
                    uint stringLength=reader.ReadUInt32();
                    uint actualStringLength=await reader.LoadAsync(stringLength);
                    if (stringLength!=actualStringLength) {
                        //在socket被关闭之前才可以读取全部数据
                        return;

                    }
                    string msg = reader.ReadString(actualStringLength);
                    //通知到界面监听到的消息
                    await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        TextBlock tb = new TextBlock { Text = msg, FontSize = 20 };
                        lbMsg.Children.Add(tb);
                    });
                }
            }
            catch (Exception ex)
            {
                //未知异常
                if (SocketError.GetStatus(ex.HResult)==SocketErrorStatus.Unknown)
                {
                    throw;
                }
               
            }
        }
        //连接Socket
        private async void btConnectSocket_Click(object sender, RoutedEventArgs e)
        {
            if (socket!=null)
            {
                await new MessageDialog("已经连接了Socket").ShowAsync();
                return;
            }
            HostName hostName= null;
            string message = "";
            try
            {
                hostName = new HostName("localhost");
            }
            catch (ArgumentException)
            {
                message = "主机名不可用";
            }
            if (message!="")
            {
                await new MessageDialog(message).ShowAsync();
                return;
            }
            socket = new StreamSocket();
            try
            {
                //连接到socket服务器
                await socket.ConnectAsync(hostName,"22112");
                await new MessageDialog("连接成功").ShowAsync();
            }
            catch (Exception ex)
            {
                //未知异常
                if (SocketError.GetStatus(ex.HResult)==SocketErrorStatus.Unknown)
                {
                    throw;
                }
                
            }
        }
        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void btSendMsg_Click(object sender, RoutedEventArgs e)
        {
            if (listener==null)
            {
                await new MessageDialog("监听未启动").ShowAsync();
                return;
            }
            if (writer==null)
            {
                writer = new DataWriter(socket.OutputStream);
            }
            //先写入数据的长度,长度的类型为UInt32,然后再写入数据
            string stringToSend = tbMsg.Text;
            writer.WriteUInt32(writer.MeasureString(stringToSend));
            writer.WriteString(stringToSend);
            //把数据发送到网络
            try
            {
                await writer.StoreAsync();
                await new MessageDialog("发送成功").ShowAsync() ;
            }
            catch (Exception ex)
            {
                if (SocketError.GetStatus(ex.HResult)==SocketErrorStatus.Unknown)
                {
                    throw;
                }
            }
        }
        /// <summary>
        /// 关闭连接,清空资源
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btClose_Click(object sender, RoutedEventArgs e)
        {
            if (writer!=null)
            {
                writer.DetachStream();
                writer.Dispose();
                writer= null;
            }
            if (socket!=null)
            {
                socket.Dispose();
                socket= null; 
            }
            if (listener!=null)
            {
                listener.Dispose();
                listener= null;
            }
        }
    }
}

public async void GetUDPMessage() {
           //主机名
           HostName hostName = new HostName("localhost");
           DatagramSocket datagramSocket= new DatagramSocket();
           //订阅接收消息的事件
           datagramSocket.MessageReceived += DatagramSocket_MessageReceived;
           //获取输出流
           IOutputStream outputStream = await datagramSocket.GetOutputStreamAsync(hostName,"22112");
           //创建DataWriter对象发送消息
           DataWriter writer= new DataWriter(outputStream);
           writer.WriteString("test");
           await writer.StoreAsync();
          
         
       }
//接受消息的事件处理程序
       private void DatagramSocket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
       {
          //获取DataReader对象,读取消息内容
          DataReader dataReader=args.GetDataReader();
           uint length = dataReader.UnconsumedBufferLength;
           string Content = dataReader.ReadString(length);
       }

public async void ConnectSend() { 
           ///创建DatagramSocket
           DatagramSocket datagramSocket= new DatagramSocket();
           datagramSocket.MessageReceived += DatagramSocket_MessageReceived;
           //连接服务器
           await datagramSocket.ConnectAsync(new HostName("localhost"),"22112");
           //发送消息
           DataWriter writer = new DataWriter(datagramSocket.OutputStream);
           writer.WriteString("test");
           await writer.StoreAsync();

       }