深入浅出Windows应用程序开发(二)

ApplicationDataContainer localSettings=Windows.Storage.ApplicationData.Current.LocalSettings;

localSettings.Values["testSetting"]="Hello Windows10";

bool isoKeyExist=localSettings.Values.ContainKey("testSetting");

String value=localSettings.Values["testSetting"].ToString();

localSettings.Values.Remove("testSetting")

<PivotItem Header="ApplicationDataContainerSettings">
                <StackPanel>
                    <!--输入应用设置的键-->
                    <StackPanel Orientation="Horizontal">
                        <TextBlock x:Name="textBlock2" Text="Key:" Width="150"/>
                        <TextBox x:Name="txtKey" Text="" Width="200"/>
                    </StackPanel>
                    <!--输入应用设置的值-->
                    <StackPanel Orientation="Horizontal" Margin="0 20 0 0">
                        <TextBlock Text="Value:" Width="150"/>
                        <TextBox x:Name="txtValue" Text="" Width="200"/>
                    </StackPanel>
                    <Button Content="保存" x:Name="btnSave" Click="btnSave_Click"/>
                    <Button Content="删除" x:Name="btnDelete"
                            Click="btnDelete_Click"/>
                    <Button Content="清空所有" x:Name="deleteall"
                            Click="deleteall_Click"/>
                    <!--显示容器内所有的键的列表,点击选中可以在上面的输入框里面查看和修改它对应的值-->
                    <TextBlock Text="Keys列表:"/>
                    <ListBox Height="168" x:Name="lstKeys" SelectionChanged="lstKeys_SelectionChanged"/>
                    
                </StackPanel>
              
                
            </PivotItem>

 ///获取当前应用程序的本地设置根容器
            _appSettings = ApplicationData.Current.LocalSettings;
            //把容器的键列表绑定到list控件
            BindKeyList();
 /// <summary>
        /// 将当前程序中所有的key值绑定到List上
        /// </summary>
        private void BindKeyList()
        {
            //先清空List控件的绑定值
            lstKeys.Items.Clear();
            //获取当前应用程序的所有Key
            foreach (var item in _appSettings.Values.Keys)
            {
                //添加到List控件上
                lstKeys.Items.Add(item);
            }
            txtKey.Text = "";
            txtValue.Text = "";
        }

        //声明容器实例
        private ApplicationDataContainer _appSettings;
 /// <summary>
        /// 保存应用设置的值
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void btnSave_Click(object sender, RoutedEventArgs e)
        {
            //检查key输入框不为空
            if (!string.IsNullOrEmpty(txtKey.Text))
            {
                _appSettings.Values[txtKey.Text] = txtValue.Text;
                BindKeyList();
            }
            else
            {
                await new MessageDialog("请输入key值").ShowAsync();
            }
        }
        /// <summary>
        /// 删除在List中选中的应用设置
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnDelete_Click(object sender, RoutedEventArgs e)
        {
            //如果选中了List中的某项
            if (lstKeys.SelectedIndex > -1)
            {
                //移除这个键的独立存储设置
                _appSettings.Values.Remove(lstKeys.SelectedItem.ToString());
                BindKeyList();
            }
        }
        /// <summary>
        /// 清空容器所有的设置
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void deleteall_Click(object sender, RoutedEventArgs e)
        {
            _appSettings.Values.Clear();
            BindKeyList();
        }
        //List控件选中项的事件,将选中的键和值显示在上面的文本框中.
        private void lstKeys_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (e.AddedItems.Count > 0)
            {
                //获取在List中选择的Key
                string key = e.AddedItems[0].ToString();
                //检查设置是否存在这个key
                if (_appSettings.Values.ContainsKey(key)) {
                    txtKey.Text = key;
                    //获取key的值并显示在文本框上
                    txtValue.Text = _appSettings.Values[key].ToString();
                }
            }
        }

ApplicationDataContainer container=localSettings.CreateContainer("exampleContainer",ApplicationDataCreateDisposition.Always);

localSettings.DeleteContainer("exampleContainer");

<PivotItem Header="ApplicationDataContainer">
               <StackPanel>
                   <Button Content="创建Container" Click="CreateContainer_Click" Margin="2"/>
                   <Button Content="添加信息" Click="WriteSetting_Click" Margin="2"/>
                   <Button Content="删除信息" Click="DeleteSetting_Click" Margin="2"/>
                   <Button Content="删除Container" Click="DeleteContainer_Click" Margin="2"/>
                   <TextBlock x:Name="OutputTextBlock" TextWrapping="Wrap"/>
               </StackPanel>
           </PivotItem>

 ///获取根容器
           localSettings=ApplicationData.Current.LocalSettings;
           //输出容器相关信息
           DisplayOutput();
/// <summary>
       /// 展示创建的容器和应用设置的信息
       /// </summary>
       private void DisplayOutput()
       {
          //判断容器是否存在
          bool hasContainer=localSettings.Containers.ContainsKey(containerName);
           //判断容器里面的键值是否存在
           bool hasSetting = hasContainer ? localSettings.Containers[containerName].Values.ContainsKey(settingName) : false;
           string output = string.Format(
               $"Container Exists:{(hasContainer?true:false)}\n Setting Exists:{(hasSetting?true:false)}");
           OutputTextBlock.Text = output;
       }

/// <summary>
       /// 创建一个容器
       /// </summary>
       /// <param name="sender"></param>
       /// <param name="e"></param>
       private void CreateContainer_Click(object sender, RoutedEventArgs e)
       {
           //如果容器不存在则新建
           ApplicationDataContainer container = localSettings.CreateContainer(containerName, ApplicationDataCreateDisposition.Always);
           DisplayOutput();
       }
       //在新建的容器上添加应用设置信息
       private void WriteSetting_Click(object sender, RoutedEventArgs e)
       {
           if (localSettings.Containers.ContainsKey(containerName))
           {
               localSettings.Containers[containerName].Values[settingName] = "Hello World";
           }
           DisplayOutput();

       }
       /// <summary>
       /// 删除容器上的应用设置信息
       /// </summary>
       /// <param name="sender"></param>
       /// <param name="e"></param>
       private void DeleteSetting_Click(object sender, RoutedEventArgs e)
       {
           if (localSettings.Containers.ContainsKey(containerName))
           {
               localSettings.Containers[containerName].Values.Remove(settingName);
           }
           DisplayOutput();
       }
       /// <summary>
       /// 删除所创建的容器
       /// </summary>
       /// <param name="sender"></param>
       /// <param name="e"></param>
       private void DeleteContainer_Click(object sender, RoutedEventArgs e)
       {
           localSettings.DeleteContainer(containerName);
           DisplayOutput();
       }

ApplicationDataCompositeValue composite=new ApplicationDataCompositeValue();
composite["intVal"]=1;
composite["strVal"]="string";

 <PivotItem Header="ApplicationDataCompositeValue">
                <StackPanel>
                    <Button Content="创建" Click="WriteCompositeSetting_Click"/>
                    <Button Content="删除" Click="DeleteCompositeSetting_Click"/>
                    <TextBlock x:Name="OutputTextBlock1" TextWrapping="Wrap"/>
                </StackPanel>
            </PivotItem>

 ///ApplicationDataCompositiveValue
            roamingSettings=ApplicationData.Current.LocalSettings;
            //展示信息
            DisplayOutputAdcv();

/// <summary>
        /// 展示复合设置的信息
        /// </summary>
        private void DisplayOutputAdcv()
        {
            ApplicationDataCompositeValue composite = (ApplicationDataCompositeValue)roamingSettings.Values[settingNameA];
            string output;
            if (composite==null)
            {
                output = "复合设置信息为空";
            }
            else
            {
                output =$"复合设置:{settingNameB}={composite[settingNameB]},{settingNameC}={composite[settingNameC]}";
            }
            OutputTextBlock1.Text = output;
        }

 ApplicationDataContainer roamingSettings = null;
        //复合设置的名称
        const string settingNameA = "exampleCompositeSetting";
        //复合设置里面的键One
        const string settingNameB = "one";
        //复合设置里面的键two
        const string settingNameC = "two";
        /// <summary>
        /// 写入复合设置信息
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void WriteCompositeSetting_Click(object sender, RoutedEventArgs e)
        {
            ApplicationDataCompositeValue composite=new ApplicationDataCompositeValue();
            composite[settingNameB] = 1;
            composite[settingNameC] = "world";
            roamingSettings.Values[settingNameA]=composite;
            DisplayOutputAdcv();
        }
        /// <summary>
        /// 删除复合设置信息
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void DeleteCompositeSetting_Click(object sender, RoutedEventArgs e)
        {
            roamingSettings.Values.Remove(settingNameA);
            DisplayOutputAdcv();
        }

/// <summary>
        /// 创建文件夹和文件
        /// </summary>
        private async void GetLocalFolder()
        {
            //获取本地文件夹根目录
            StorageFolder local = Windows.Storage.ApplicationData.Current.LocalFolder;
            //创建文件夹,如果文件夹存在则打开它
            var dataFolder =await local.CreateFolderAsync("DataFolder",CreationCollisionOption.OpenIfExists);
            //创建一个命名为DataFile.txt的文件,如果文件存在则替换掉
            var file = await dataFolder.CreateFileAsync("DataFile.txt",CreationCollisionOption.ReplaceExisting);

        }

/// <summary>
        /// 2.文件的读写
        /// </summary>
        private async void ReadWrite(StorageFile file) {
            //读取文件的文本信息,使用FileIO类实现
            string fileContent = await FileIO.ReadTextAsync(file);
            //读取文件的文本信息,使用StreamReader类实现
            using (StreamReader streamReader = new StreamReader(file.Path))
            {
                fileContent = streamReader.ReadToEnd();

            }
            //写入文件的文本信息,使用FileIO类实现
            await FileIO.WriteTextAsync(file, "Windows 10");
            //写入文件的文本信息,使用StreamWriter类实现.
            using (StreamWriter swNew=new StreamWriter(file.Path))
            {
                swNew.WriteLine("Windows 10");
            }

        }

 //使用OpenStreamForWriteAsync方法来实现写入文件信息
           byte[] fileBytes=Encoding.UTF8.GetBytes("Windows 10".ToCharArray());
           using (var s=await file.OpenStreamForWriteAsync())
           {
               s.Write(fileBytes,0,fileBytes.Length);
           }
          ///文件删除,复制,重命名和移动操作
           //await file.DeleteAsync();
           var newfile =await storageFolder.CreateFileAsync("sample - Copy.txt", CreationCollisionOption.ReplaceExisting);
           //复制文件
           StorageFile fileCopy = await file.CopyAsync(storageFolder,"sample - Copy.txt",NameCollisionOption.ReplaceExisting);
           //重命名文件
           await file.RenameAsync("sampleRe.txt");
           var newStorageFolder = await storageFolder.CreateFolderAsync("newDataFolder", CreationCollisionOption.OpenIfExists);
           //移动文件
           await file.MoveAsync(newStorageFolder,"newDataFile");
//文件名
       private string fileName = "testfile.txt";
       //保存按钮事件处理程序
       private async void bt_save_Click(object sender, RoutedEventArgs e)
       {
           if (infoStorage.Text!="")
           {
               //写入文件信息
               await WriteFile(fileName,infoStorage.Text);
               await new MessageDialog("保存成功").ShowAsync();
           }
           else
           {
               await new MessageDialog("内容不能为空").ShowAsync();
           }
       }
       /// <summary>
       /// 写入本地文件夹根目录的文件
       /// </summary>
       /// <param name="fileName"></param>
       /// <param name="text"></param>
       /// <returns></returns>
       /// <exception cref="NotImplementedException"></exception>
       private async Task WriteFile(string fileName, string text)
       {
           //获取本地文件夹根目录文件夹
           IStorageFolder applicationFolder=ApplicationData.Current.LocalFolder;
           //在文件夹里面创建文件,如果文件存在则替换掉.
           IStorageFile storageFile = await applicationFolder.CreateFileAsync(fileName,CreationCollisionOption.OpenIfExists);
           //使用FileIO类把字符串信息写入文件
           await FileIO.WriteTextAsync(storageFile, text);
       }
       /// <summary>
       /// 删除文件
       /// </summary>
       /// <param name="sender"></param>
       /// <param name="e"></param>
       private async void bt_delete_Click(object sender, RoutedEventArgs e)
       {
           string text;
           try
           {
               IStorageFolder applicationFolder = ApplicationData.Current.LocalFolder;
               //获取文件
               IStorageFile storageFile=await applicationFolder.GetFileAsync(fileName);
               //删除当前的文件
               await storageFile.DeleteAsync();
               text = "删除成功";
           }
           catch (Exception ex)
           {

               text = "文件删除错误:" + ex.Message;
           }
           await new MessageDialog(text).ShowAsync();
       }
       /// <summary>
       /// 读取文件
       /// </summary>
       /// <param name="sender"></param>
       /// <param name="e"></param>
       private async void bt_read_Click(object sender, RoutedEventArgs e)
       {
           //读取文件的文本信息
           string content = await ReadFile(fileName);
           await new MessageDialog(content).ShowAsync();
       }
       /// <summary>
       /// 读取本地文件夹根目录的文件
       /// </summary>
       /// <param name="fileName"></param>
       /// <returns></returns>
       /// <exception cref="NotImplementedException"></exception>
       private async Task<string> ReadFile(string fileName)
       {
           string text;
           try
           {
               //获取本地文件夹根目录文件夹
               IStorageFolder applicaitonFolder=ApplicationData.Current.LocalFolder;
               //根据文件名获取文件夹里面的文件
               IStorageFile storageFile=await applicaitonFolder.GetFileAsync(fileName);
               //打开文件获取文件的数据流
               IRandomAccessStream accessStream=await storageFile.OpenReadAsync();
               //使用StreamReader读取文件的内容,需要将IRandomAccessStream对象转换为Stream对象来初始化StreamReader对象.
               using (StreamReader streamReader=new StreamReader(accessStream.AsStreamForRead((int)accessStream.Size)))
               {
                   text = streamReader.ReadToEnd();
               }
           }
           catch (Exception e)
           {
               text = "文件读取错误:" + e.Message;
             
           }
           return text;
       }

using(InMemoryRandomAccessStream memoryStream=new InMemoryRandomAccessStream()){
	using(DataWriter dataWriter=new DataWriter(memoryStream)){
	//文件相关的信息,可以根据文件的规则来进行写入
	dataWriter.WriterInt32(size);
	dataWriter.WriteString(userContent);
	buffer=dataWriter.DetachBuffer();
}
}
await FileIO.WriteBufferAsync(file,buffer);

IBuffer buffer=await FileIO.ReadBufferAsync(file);
using(DataReader dataReader=DataReader.FromBuffer(buffer)){
	//读取文件相关的信息,读取的规则要与文件的规则一致.
	Int32 stringSize=dataReader.ReadInt32();
	string fileContent=dataReader.ReadString((uint)stringSize);
}

using(StorageStreamTransaction transaction=await file.OpenTransactedWriteAsync()){
	using(DataWriter dataWriter=new DataWriter(transaction.Stream)){
	//文件相关的信息,可以根据文件的规则进行写入
	dataWriter.WriteInt32(size);
	dataWriter.WriteString(userContent);
	... ...
	transaction.Stream.Size=await dataWriter.StoreAsync();
	//保存Stream数据
	await transaction.CommitAsync();
}
}

using(IRandomAccessStream readStream=await file.OpenAsync(FileAccessMode.Read)){
	//读取文件相关的信息,读取的规则要与文件的规则一致
	await dataReader.LoadAsync(sizeof(Int32));
	Int32 stringSize=dataReader.ReadInt32();
	await dataReader.LoadAsync((UInt32)stringSize);
	string fileContent=dataReader.ReadString((uint)stringSize);
	... ...	
}

<PivotItem Header="StreamBuffer">
                <StackPanel>
                    <Button x:Name="bt_crreate" Content="创建一个测试文件" Margin="2" Click="bt_crreate_Click"/>
                    <Button x:Name="bt_writebuffer" Content="写入buffer" Margin="2" Click="bt_writebuffer_Click"/>
                    <Button x:Name="bt_readbuffer" Content="读取buffer" Margin="2" Click="bt_readbuffer_Click"/>
                    <Button x:Name="bt_writestream" Content="写入stream" Margin="2" Click="bt_writestream_Click"/>
                    <Button x:Name="bt_readstream" Content="读取stream" Margin="2" Click="bt_readstream_Click"/>
                    <TextBlock x:Name="StreambufferTextBlock" TextWrapping="Wrap" FontSize="20"/>
                </StackPanel>
            </PivotItem>

   /// <summary>
        /// 创建的测试文件对象
        /// </summary>
        private StorageFile sampleFile;
        /// <summary>
        /// 文件名
        /// </summary>
        private string filename = "sampleFile.dat";
        /// <summary>
        /// 创建一个文件事件处理程序
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void bt_crreate_Click(object sender, RoutedEventArgs e)
        {
            StorageFolder storageFolder= ApplicationData.Current.LocalFolder;
            sampleFile=await storageFolder.CreateFileAsync(filename,CreationCollisionOption.ReplaceExisting);
            StreambufferTextBlock.Text = $"文件{sampleFile.Name}已经创建好.";

        }
        /// <summary>
        /// 写入IBuffer按钮事件处理程序
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void bt_writebuffer_Click(object sender, RoutedEventArgs e)
        {
            StorageFile file = sampleFile;
            if (file!=null)
            {
                try
                {
                    string userContent = "测试的文本消息";
                    IBuffer buffer;
                    //使用一个内存的可访问的数据流创建一个DataWriter对象,写入String 再转换为IBuffer对象.
                    using (InMemoryRandomAccessStream memoryStream=new InMemoryRandomAccessStream())
                    {
                        //把String信息转换为IBuffer对象.
                        using (DataWriter dataWriter=new DataWriter(memoryStream))
                        {
                            //先写入字符串的长度信息
                            dataWriter.WriteInt32(Encoding.UTF8.GetByteCount(userContent));
                            //写入字符串信息
                            dataWriter.WriteString(userContent);
                            buffer=dataWriter.DetachBuffer();
                        }
                    }
                    await FileIO.WriteBufferAsync(file,buffer);
                    StreambufferTextBlock.Text = $"长度为:{buffer.Length} bytes的文本信息写入到了文件{file.Name}:{Environment.NewLine+Environment.NewLine+userContent}";
                }
                catch (Exception ex)
                {
                    StreambufferTextBlock.Text =$"异常:{ex.Message}";
                }
            }
            else
            {
                StreambufferTextBlock.Text = "请先创建文件";
            }
        }


        /// <summary>
        /// 读取IBuffer按钮事件处理程序
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void bt_readbuffer_Click(object sender, RoutedEventArgs e)
        {
            StorageFile file= sampleFile;
            if (file != null)
            {
                try
                {
                    IBuffer buffer = await FileIO.ReadBufferAsync(file);
                    using (DataReader dataReader = DataReader.FromBuffer(buffer))
                    {
                        //先读取字符串的长度信息
                        Int32 stringSize = dataReader.ReadInt32();         //读取字符串信息
                        string fileContent = dataReader.ReadString((uint)stringSize);
                        StreambufferTextBlock.Text = $"长度为:{buffer.Length} bytes的文本信息从文件{file.Name}读取出来,其中字符串的长度为{stringSize}bytes:{Environment.NewLine + fileContent}";
                    }
                }
                catch (Exception ex)
                {

                    StreambufferTextBlock.Text = "异常:" + ex.Message;
                }
            }
            else {
                StreambufferTextBlock.Text = "请先创建文件";
            }
        }
        //写入Stream按钮事件处理程序.
        private async void bt_writestream_Click(object sender, RoutedEventArgs e)
        {
            StorageFile file= sampleFile;
            if (file!=null)
            {
                try
                {
                    string userContent = "测试的文本信息";
                    //使用StorageStreamTransaction对象来创建DataWriter对象写入数据
                    using (StorageStreamTransaction transaction=await file.OpenTransactedWriteAsync())
                    {
                        using (DataWriter dataWriter=new DataWriter(transaction.Stream))
                        {
                            //先写入信息的长度
                            dataWriter.WriteInt32(Encoding.UTF8.GetByteCount(userContent));
                            //写入字符串信息
                            dataWriter.WriteString(userContent);
                            //提交dataWriter的数据同时重设Stream的大小
                            transaction.Stream.Size=await dataWriter.StoreAsync();
                            //保存Stream数据
                            await transaction.CommitAsync();
                            StreambufferTextBlock.Text = $"使用stream把信息写入了文件{file.Name}:{Environment.NewLine+userContent}";
                        }
                    }
                }
                catch (Exception ex)
                {

                    StreambufferTextBlock.Text = $"异常:" + ex.Message;
                }
            }
            else
            {
                StreambufferTextBlock.Text = "请先创建文件";
            }
        }
        /// <summary>
        /// 读取Stream按钮事件处理程序
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void bt_readstream_Click(object sender, RoutedEventArgs e)
        {
            StorageFile file=sampleFile;
            if (file!=null)
            {
                try
                {
                    //使用文件流创建DataReader对象
                    using (IRandomAccessStream readStream=await file.OpenAsync(FileAccessMode.Read))
                    {
                        using (DataReader dataReader=new DataReader(readStream))
                        {
                            UInt64 size = readStream.Size;
                            if (size<=UInt32.MaxValue)
                            {
                                //先读取字符串的长度信息
                                await dataReader.LoadAsync(sizeof(Int32));
                                Int32 stringSize=dataReader.ReadInt32();
                                //读取字符串的内容信息
                                await dataReader.LoadAsync((UInt32)stringSize);
                                string fileContent = dataReader.ReadString((UInt32)stringSize);
                                StreambufferTextBlock.Text =$"使用stream把信息从文件{file.Name}读取出来,其中字符串的长度为:{stringSize}bytes:{Environment.NewLine+fileContent}";
                            }
                            else
                            {
                                StreambufferTextBlock.Text = $"文件{file.Name}太大,不能再单个数据块中读取";
                            }
                        }
                    }
                }
                catch (Exception ex)
                {

                    StreambufferTextBlock.Text = $"异常:{ex.Message}";
                }

            }
            else
            {
                StreambufferTextBlock.Text = "请先创建文件";
            }
        }

var file=await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appdata:///local/AppConfigSettings.xml"));

<PivotItem Header="GetFolderByUri">
               <StackPanel>
                   <TextBox Header="文件信息:" x:Name="UriInfo" TextWrapping="Wrap"/>
                   <Button x:Name="bt_saveuri" Content="创建文件" Click="bt_save_Click_1"/>
                   <Button x:Name="bt_readuri" Content="通过URI读取文件" Margin="2" Click="bt_read_Click_1"/>
                   
               </StackPanel>
           </PivotItem>
//文件名
       private string UrifileName = "testfile.txt";
       
       

       /// <summary>
       /// 读取文件
       /// </summary>
       /// <param name="sender"></param>
       /// <param name="e"></param>
       private async void bt_read_Click_1(object sender, RoutedEventArgs e)
       {
           //读取文件的文本信息
           string text;
           try
           {
               //通过URI获取本地文件
               var storageFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appdata:///local/"+UrifileName));
               //打开文件获取文件的数据流
               IRandomAccessStream accessStream = await storageFile.OpenReadAsync();
               //使用StreamReader读取文件的内容,需要将IRandomAccessStream对象转换为Stream对象来初始化StreamReader对象.
               using (StreamReader streamReader=new StreamReader(accessStream.AsStreamForRead((int)accessStream.Size)))
               {
                   text = streamReader.ReadToEnd();
               }
           }
           catch (Exception ex)
           {
               text = $"文件读取错误:"+ex.Message;
               
           }
           await new MessageDialog(text).ShowAsync();
       }
       //创建文件
       private async void bt_save_Click_1(object sender, RoutedEventArgs e)
       {
           if (UriInfo.Text != "") { 
               //获取本地文件夹根目录文件夹
               IStorageFolder applicationFolder=ApplicationData.Current.LocalFolder;
               //在文件夹里面创建文件,如果文件存在则替换掉
               IStorageFile storageFile = await applicationFolder.CreateFileAsync(UrifileName,CreationCollisionOption.OpenIfExists);
               //使用FileIO类把字符串信息写入文件
               await FileIO.WriteTextAsync(storageFile, UriInfo.Text);
               await new MessageDialog($"保存成功,文件的路径:{storageFile.Path}").ShowAsync();
           }
           else
           {
               await new MessageDialog("内容不能为空").ShowAsync();

           }
       }

/// <summary>
       /// 对实体类进行序列化的方法
       /// </summary>
       /// <param name="item"></param>
       /// <returns></returns>
       public string ToJsonData(object item) { 
           DataContractJsonSerializer serializer=new DataContractJsonSerializer(item.GetType());
           string result = string.Empty;
           using (MemoryStream ms=new MemoryStream())
           {
               serializer.WriteObject(ms,item);
               ms.Position = 0;
               using (StreamReader reader=new StreamReader(ms))
               {
                   result = reader.ReadToEnd();
               }
           }
           return result;
       }
       /// <summary>
       /// 把Json字符串反序列化成实体类对象
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="jsonString"></param>
       /// <returns></returns>
       public T DataContractJsonDeSerializer<T>(string jsonString) { 
       var ds=new DataContractJsonSerializer(typeof(T));
           var ms=new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
           T obj=(T)ds.ReadObject(ms);
           ms.Dispose();
           return obj;
       }

JsonObject jsonObject=new JsonObject();
JsonObject.SetNamedValue("city",JsonValue.CreateStringValue("Beijing"));
JsonObject.SetNamedValue("street",JsonValue.CreateStringValue("Chaoyang Road"));
jsonObject.setNamedValue("postcode",JsonValue,CreateNumberValue(10025));

<PivotItem Header="JsonObject">
                <StackPanel>
                    <TextBlock Text="Write your message" FontSize="20"/>
                    <TextBox x:Name="userName" Header="Name:"/>
                    <TextBox x:Name="userAge" Header="Age:" InputScope="Number"/>
                    <TextBlock Text="Your study school:" FontSize="20"/>
                    <CheckBox Content="Haerbing School" x:Name="school1"/>
                    <CheckBox Content="LanXiang School" x:Name="school2"/>
                    <StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
                        <Button Content="保存" x:Name="save" Click="save_Click"/>
                        <Button Content="获取保存的信息" x:Name="get" Click="get_Click"/>
                        
                    </StackPanel>
                    <TextBlock x:Name="JsonObjectInfo" TextWrapping="Wrap" FontSize="20"/>
                </StackPanel>
            </PivotItem>
 /// <summary>
        /// 对实体类进行序列化的方法
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public string ToJsonData(object item) { 
            DataContractJsonSerializer serializer=new DataContractJsonSerializer(item.GetType());
            string result = string.Empty;
            using (MemoryStream ms=new MemoryStream())
            {
                serializer.WriteObject(ms,item);
                ms.Position = 0;
                using (StreamReader reader=new StreamReader(ms))
                {
                    result = reader.ReadToEnd();
                }
            }
            return result;
        }
        /// <summary>
        /// 把Json字符串反序列化成实体类对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        public T DataContractJsonDeSerializer<T>(string jsonString) { 
        var ds=new DataContractJsonSerializer(typeof(T));
            var ms=new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
            T obj=(T)ds.ReadObject(ms);
            ms.Dispose();
            return obj;
        }

        private const string UserDataKey = "UserDataKey";
        private async void save_Click(object sender, RoutedEventArgs e)
        {
            if (userName.Text=="" || userAge.Text=="")
            {
                await new MessageDialog("请输入完整的信息").ShowAsync();
                return;
            }
            ObservableCollection<School> education = new ObservableCollection<School>();
            if (school1.IsChecked == true) {
                education.Add(new School { Id="id001",Name=school1.Content.ToString()});
               

            }
            if (school2.IsChecked == true)
            {
                education.Add(new School { Id = "id002", Name = school2.Content.ToString() });
            }

            User user = new User { Education=education,Id=Guid.NewGuid().ToString(),Name=userName.Text,Age=Int32.Parse(userAge.Text),Verified=false};
            //使用DataContractJsonDeSerializer的实现方式
            //string json=ToJsonData(user);
            //使用JsonObject的实现方式
            string json = user.Stringify();
            JsonObjectInfo.Text = json;
            _appSettings.Values[UserDataKey] = json;
            await new MessageDialog("保存成功").ShowAsync();
        }
        // 把应用设置存储的Json数据转换为实体类对象.
        private async void get_Click(object sender, RoutedEventArgs e)
        {
            if (!_appSettings.Values.ContainsKey(UserDataKey)) {
                await new MessageDialog("未保存信息").ShowAsync();
                return;
            }
            string json = _appSettings.Values[UserDataKey].ToString();
            //使用DataContractJsonDeSerializer的实现方式
            //User user = DataContractJsonDeSerializer<User>(json);
            //使用JsonObject的实现方式
            User user = new User(json);
            string userInfo = "";
            userInfo = $"Id:{user.Id} Name:{user.Name} Age:{user.Age}";
            foreach (var item in user.Education)
            {
                userInfo += $"Education:Id:{item.Id} Name:{item.Name}";
            }
            await new MessageDialog(userInfo).ShowAsync();
        }

<?xml version="1.0" enconding="UTF-8">
<test>
Hello Windows 10
</test>

<Person xmlns:i="http://www.w3.org/2001/XMLSchema - instance" xmlns="http://schemas.datacontract.org/2004/07/DataContractSerializerDeno"><Age>41</Age>
<Name>terry</Name>
</Person>

/// <summary>
       /// 把实体类对象序列化成xml格式存储到文件里面
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="data"></param>
       /// <param name="fileName"></param>
       /// <returns></returns>
       public async Task SaveAsync<T>(T data, string fileName) {
           StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(fileName,CreationCollisionOption.ReplaceExisting);
           //获取文件的数据流来进行操作.
           using (IRandomAccessStream raStream=await file.OpenAsync(FileAccessMode.ReadWrite))
           {
               using (IOutputStream outputStream=raStream.GetOutputStreamAt(0))
               {
                   //创建序列化对象写入数据
                   DataContractSerializer serializer = new DataContractSerializer(typeof(T));
                   serializer.WriteObject(outputStream.AsStreamForWrite(),data);
                   await outputStream.FlushAsync();
               }
           }
       }
       /// <summary>
       /// 反序列化XML文件
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="filename"></param>
       /// <returns></returns>
       public async Task<T> ReadAsync<T>(string filename) {
           //获取实体类类型实例化一个对象
           T sessionState_ = default(T);
           StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync(filename);
           if (file == null) return sessionState_;
           using (IInputStream inStream=await file.OpenSequentialReadAsync())
           {
               //反序列化XML数据
               DataContractSerializer serializer = new DataContractSerializer(typeof(T));
               sessionState_ = (T)serializer.ReadObject(inStream.AsStreamForRead());
           }
           return sessionState_;
       }
       /// <summary>
       /// 
       /// </summary>
       public void SaveAsXml() {
           //创建一个XmlDocument对象代表着是一个Xml的文档对象.
           XmlDocument dom = new XmlDocument();
           //创建和添加一条XML的评论
           XmlComment dec = dom.CreateComment("THis is Students Message.");
           dom.AppendChild(dec);

           //添加一个students的元素为Xml文档的根元素
           XmlElement x = dom.CreateElement("studetns");
           dom.AppendChild(x);
           //创建一个Student元素后面再添加到students元素的节点上
           XmlElement x1 = dom.CreateElement("Student");
           //在Student元素里再添加id和name两个元素节点,在节点内还添加了文本内容
           XmlElement x11 = dom.CreateElement("id");
           x11.InnerText = "id001";
           x1.AppendChild(x11);
           XmlElement x12 = dom.CreateElement("name");
           x12.InnerText = "张三";
           x1.AppendChild(x12);
           x.AppendChild(x1);

       }

 <PivotItem Header="Xml">
                <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
                    <Grid x:Name="ContentPanelShop" Margin="12,0,12,0">
                        <!--展示购物清单的列表-->
                        <ListBox FontSize="48" x:Name="Files">
                        </ListBox>
                    </Grid>
                </Grid>
            </PivotItem>
        </Pivot>
 <AppBarButton Label="新增" Icon="Add" Click="AppBarButton_Click_1"/>
 //加载页面触发Loaded事件
            Loaded += BlankPage_Loaded;
  private async void BlankPage_Loaded(object sender, RoutedEventArgs e)
        {
            Files.Items.Clear();
            //获取应用程序的本地存储文件
            StorageFolder storage = await ApplicationData.Current.LocalFolder.CreateFolderAsync("ShoppingList",CreationCollisionOption.OpenIfExists);
            var files = await storage.GetFilesAsync();
            {
                //获取购物清单文件夹里面存储的文件
                foreach (StorageFile file in files) {
                    //动态构建一个Grid
                    Grid a = new Grid();
                    //定义第一列
                    ColumnDefinition col = new ColumnDefinition();
                    col.Width = GridLength.Auto;
                    a.ColumnDefinitions.Add(col);

                    //定义第二列
                    ColumnDefinition col2 = new ColumnDefinition();
                    col2.Width = GridLength.Auto;
                    a.ColumnDefinitions.Add(col2);
                    //添加一个TextBlock现实文件名到第一列
                    TextBlock txbx = new TextBlock();
                    txbx.Text = file.DisplayName;
                    Grid.SetColumn(txbx,0);
                    //添加一个HyperlinkButton链接到购物详细清单页面,这是第二列
                    HyperlinkButton btn = new HyperlinkButton();
                    btn.Content = "查看详细";
                    btn.Name = file.DisplayName;
                    btn.Click += (s,ea)=> {
                        Frame.Navigate(typeof(DisplayPage), file);
                    };
                    Grid.SetColumn(btn,1);
                    a.Children.Add(txbx);
                    a.Children.Add(btn);
                    Files.Items.Add(a);
                }
            }
        }
/// <summary>
        /// 
        /// </summary>
        public void SaveAsXml() {
            //创建一个XmlDocument对象代表着是一个Xml的文档对象.
            XmlDocument dom = new XmlDocument();
            //创建和添加一条XML的评论
            XmlComment dec = dom.CreateComment("THis is Students Message.");
            dom.AppendChild(dec);

            //添加一个students的元素为Xml文档的根元素
            XmlElement x = dom.CreateElement("studetns");
            dom.AppendChild(x);
            //创建一个Student元素后面再添加到students元素的节点上
            XmlElement x1 = dom.CreateElement("Student");
            //在Student元素里再添加id和name两个元素节点,在节点内还添加了文本内容
            XmlElement x11 = dom.CreateElement("id");
            x11.InnerText = "id001";
            x1.AppendChild(x11);
            XmlElement x12 = dom.CreateElement("name");
            x12.InnerText = "张三";
            x1.AppendChild(x12);
            x.AppendChild(x1);

        }

        private void AppBarButton_Click_1(object sender, RoutedEventArgs e)
        {
            Frame.Navigate(typeof(AddItem));
        }
AddItem.xaml .cs
<Page
    x:Class="App1.AddItem"
    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 x:Name="ContentPanel" Margin="12,0,12,0">
            <Grid.RowDefinitions>
                <RowDefinition Height="*"/>
                <RowDefinition Height="*"/>
                <RowDefinition Height="*"/>
                <RowDefinition Height="*"/>
            </Grid.RowDefinitions>
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="100*"/>
                <ColumnDefinition Width="346*"/>
            </Grid.ColumnDefinitions>
            <TextBlock Grid.Column="0" Grid.Row="0" Text="名称:"
                       HorizontalAlignment="Center" VerticalAlignment="Center"/>
            <TextBox Name="nameTxt" Grid.Column="1" Grid.Row="0" MaxHeight="40"/>
            <TextBlock Grid.Column="0" Grid.Row="1" Text="价格:" HorizontalAlignment="Center" VerticalAlignment="Center"/>
            <TextBox x:Name="priceTxt" Grid.Column="1" Grid.Row="1" MaxHeight="40"/>
            <TextBlock Grid.Row="2" Grid.Column="0" Text="数量:"
                       HorizontalAlignment="Center" VerticalAlignment="Center"/>
            <TextBox Name="quanTxt" Grid.Column="1" Grid.Row="2" MaxHeight="40"/>
            <Button x:Name="BtnSave" Content="保存" HorizontalAlignment="Stretch" Grid.Row="3" Grid.ColumnSpan="2" VerticalAlignment="Top" Click="BtnSave_Click"/>
            
        </Grid>
    </Grid>
</Page>
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Data.Xml.Dom;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.Storage;
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 AddItem : Page
    {
        public AddItem()
        {
            this.InitializeComponent();
        }

        private async void BtnSave_Click(object sender, RoutedEventArgs e)
        {
            //获取购物清单的文件夹对象
            StorageFolder storage = await ApplicationData.Current.LocalFolder.GetFolderAsync("ShoppingList");
            //创建一个Xml的对象,示例格式如<Apple pric="23" quantity="3"/>
            XmlDocument _doc= new XmlDocument();
            //使用商品的名称来创建一个xml元素作为根节点
            XmlElement _item=_doc.CreateElement(nameTxt.Text);
            //使用属性来作为信息的标识符,用属性的值来存储相关的信息
            _item.SetAttribute("price", priceTxt.Text);
            _item.SetAttribute("quantity",quanTxt.Text);
            _doc.AppendChild(_item);
            //创建一个应用文件
            StorageFile file = await storage.CreateFileAsync(nameTxt.Text+".xml",CreationCollisionOption.ReplaceExisting);
            //把XML的信息保存到文件中去
            await _doc.SaveToFileAsync(file);
            //调回清单主页
            Frame.GoBack();
        }
    }
}
DisplayPage.xaml .cs
<Page
    x:Class="App1.DisplayPage"
    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 x:Name="ContentPanel" Margin="12,0,12,0">
        <Grid.RowDefinitions>
            <RowDefinition Height="*"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="*"/>
            <ColumnDefinition Width="*"/>
        </Grid.ColumnDefinitions>
      
            <TextBlock Grid.Column="0" Grid.Row="0" Text="名称:"
                       HorizontalAlignment="Center" VerticalAlignment="Center"/>
            <TextBlock x:Name="nameTxt" Grid.Column="1" Grid.Row="0" FontSize="30"/>

            <TextBlock Grid.Row="1" Text="价格:" HorizontalAlignment="Center" VerticalAlignment="Center"/>
            <TextBlock x:Name="priceTxt" Grid.Column="1" Grid.Row="1" FontSize="30"/>

            <TextBlock Grid.Column="0" Grid.Row="2" Text="数量:"
                       HorizontalAlignment="Center" VerticalAlignment="Center"/>
            <TextBlock Name="quanTxt" Grid.Column="1" Grid.Row="2" FontSize="30"/>
            <TextBlock Name="PageTitle" Grid.Row="3"/>
        </Grid>
  
</Page>
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Data.Xml.Dom;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.Storage;
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 DisplayPage : Page
    {
        public DisplayPage()
        {
            this.InitializeComponent();
        }

        protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
           //获取上一个清单列表传递过来的参数,该参数是一个StorageFile对象.
           StorageFile file=e.Parameter as StorageFile;
            if (file == null) return;
            //获取文件的名字
            string itemName = file.DisplayName;
            PageTitle.Text = itemName;
            //把应用文件作为一个xml文档加载进来
            XmlDocument doc=await XmlDocument.LoadFromFileAsync(file);
            //获取xml文档的信息
            priceTxt.Text = doc.DocumentElement.Attributes.GetNamedItem("price").NodeValue.ToString();
            quanTxt.Text = doc.DocumentElement.Attributes.GetNamedItem("quantity").NodeValue.ToString();
            nameTxt.Text = itemName;

        }
    }
}

 <PivotItem Header="ApplicationModelPackage">
                <ScrollViewer>
                    <StackPanel>
                        <Button Content="获取安装包的根目录" x:Name="btnGetFile" Click="btnGetFile_Click" Margin="2"/>
                        <TextBlock Text="文件夹列表:"/>
                        <ListBox x:Name="lbFolder"/>
                        <Button Content="打开选中的文件夹" x:Name="open" Click="open_Click" Margin="2"/>

                        <TextBlock Text="文件列表:"/>
                        <ListBox x:Name="lbFile">
                        </ListBox>
                        <Button Content="在选中文件夹下创建测试文件" x:Name="create" Click="create_Click" Margin="2"/>
                        <Button Content="删除选中的文件" x:Name="delete" Click="delete_Click" Margin="2"/>
                        
                    </StackPanel>
                </ScrollViewer>
            </PivotItem>
/// <summary>
        /// 打开应用程序的根目录
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void btnGetFile_Click(object sender, RoutedEventArgs e)
        {
            //清理文件夹列表
            lbFolder.Items.Clear();
            //获取根目录
            StorageFolder localFolder =Windows.ApplicationModel.Package. Current.InstalledLocation;
            //添加遍历根目录的文件夹到文件夹列表
            foreach (var folder in await localFolder.GetFoldersAsync())
            {
                ListBoxItem item = new ListBoxItem();
                item.Content = "应用程序目录:" + folder.Name;
                item.DataContext = folder;
                lbFolder.Items.Add(item);
            }
            //清理文件列表
            lbFile.Items.Clear();
            //添加遍历根目录的文件到文件列表
            foreach (var file in await localFolder.GetFilesAsync())
            {
                ListBoxItem item3 = new ListBoxItem();
                item3.Content = "文件:" + file.Name;
                item3.DataContext = file;
                lbFile.Items.Add(item3);
            }
        }
        /// <summary>
        /// 打开选中的文件夹
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void open_Click(object sender, RoutedEventArgs e)
        {
            if (lbFolder.SelectedIndex == -1) {
                await new MessageDialog("请选择一个文件夹").ShowAsync();

            }
            else
            {
                ListBoxItem item = lbFolder.SelectedItem as ListBoxItem;
                //获取选中的文件夹
                StorageFolder folder = item.DataContext as StorageFolder;
                //清理文件夹列表
                lbFolder.Items.Clear();
                //添加遍历到的文件夹到文件夹列表
                foreach (var folder2 in await folder.GetFoldersAsync())
                {
                    ListBoxItem item2 = new ListBoxItem();
                    item2.Content = "文件夹:" + folder2.Name;
                    item2.DataContext = folder;
                    lbFolder.Items.Add(item2);
                }
                //清理文件列表
                lbFile.Items.Clear();
                //添加遍历到的文件到文件列表
                foreach (var file in await folder.GetFilesAsync())
                {
                    ListBoxItem item3 = new ListBoxItem();
                    item3.Content = "文件:" + file.Name;
                    item3.DataContext = file;
                    lbFile.Items.Add(item3);
                }

            }
        }
        /// <summary>
        /// 在选中的文件中新建一个文件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void create_Click(object sender, RoutedEventArgs e)
        {
            if (lbFolder.SelectedIndex == -1)
            {
                await new MessageDialog("请选择一个文件夹").ShowAsync();

            }
            else {
                ListBoxItem item = lbFolder.SelectedItem as ListBoxItem;
                //获取选中的文件夹
                StorageFolder folder=item.DataContext as StorageFolder;
                //在文件夹中创建一个文件
                StorageFile file = await folder.CreateFileAsync(DateTime.Now.Millisecond.ToString()+".txt");
                //添加到文件列表中
                ListBoxItem item3 = new ListBoxItem();
                item3.Content = "文件:" + file.Name;
                item3.DataContext= file;
                lbFile.Items.Add(item3);
                await new MessageDialog("创建文件成功").ShowAsync();
            }
        }

        /// <summary>
        /// 删除选中的文件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void delete_Click(object sender, RoutedEventArgs e)
        {
            if (lbFile.SelectedIndex == -1) {
                await new MessageDialog("请选择一个文件夹").ShowAsync();
            }
            else
            {
                ListBoxItem item=lbFile.SelectedItem as ListBoxItem;
                //获取选中的文件
                StorageFile file=item.DataContext as StorageFile; 
                //删除文件
                await file.DeleteAsync();
                lbFile.Items.Remove(item);
                await new MessageDialog("删除成功").ShowAsync();
            }
        }

var file=await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///PackageTest/test.xml"));

<PivotItem Header="AppUri">
               <StackPanel>
                   <TextBlock Text="安装包的图片展示:"/>
                   <Image x:Name="packageImage" Height="200"/>
                   <TextBlock Text="应用存储的图片展示:"/>
                   <Image x:Name="appImage" Height="200"/>
               </StackPanel>
           </PivotItem>
protected override async void OnNavigatedTo(NavigationEventArgs e)
       {
           ApplicationData appData = ApplicationData.Current;
           //将程序包内的文件保存到应用存储中的TemporaryFolder
           StorageFile imgFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/LockScreenLogo.scale-200.png"));
           await imgFile.CopyAsync(appData.TemporaryFolder,imgFile.Name,NameCollisionOption.ReplaceExisting);
           //引用应用存储内的图片文件并显示
           appImage.Source = new BitmapImage(new Uri("ms-appdata:///temp/LockScreenLogo.scale-200.png"));
           //引用程序包内的图片文件并显示
           packageImage.Source = new BitmapImage(new Uri("ms-appx:///Assets/LockScreenLogo.scale-200.png"));

       }

<Line X1="0" Y1="0" X2="100" Y2="100" Stroke="Black" StrokeThickness="10"/>

<Polyline Points="10,110 60,10 110,110" Stroke="Red" StrokeThickness="4"/>
<Polygon Points="10,110 60,10,110,110" Stroke="Red" StrokeThickness="4"/>

<PivotItem Header="Line">
                <Canvas x:Name="ContentPanelCanvas" Background="Transparent">
                
                </Canvas>
            </PivotItem>

 //注册画图的指针移动事件,用来捕获手指在设备屏幕上的点
            this.ContentPanelCanvas.PointerMoved += ContentPanelCanvas_PointerMoved;
            //注册指针按下事件,用来记录第一个触摸点
            this.ContentPanelCanvas.PointerPressed += ContentPanelCanvas_PointerPressed;
    /// <summary>
        /// 指针按下事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void ContentPanelCanvas_PointerPressed(object sender, PointerRoutedEventArgs e)
        {
            currentPoint = e.GetCurrentPoint(ContentPanelCanvas).Position;
            oldPoint= currentPoint;

        }

        private void ContentPanelCanvas_PointerMoved(object sender, PointerRoutedEventArgs e)
        {
            ///获取相对于画布控件的点坐标
            currentPoint=e.GetCurrentPoint(ContentPanelCanvas).Position;
            //根据上一个画图的点和当前的画图的点新建一条线段
            Line line = new Line() { X1=currentPoint.X,Y1=currentPoint.Y,X2=oldPoint.X,Y2=oldPoint.Y};
            //设置线段的相关属性
            line.Stroke = new SolidColorBrush(Colors.Red);
            line.StrokeThickness = 5;
            line.StrokeLineJoin = PenLineJoin.Round;
            line.StrokeStartLineCap= PenLineCap.Round;
            line.StrokeEndLineCap= PenLineCap.Round;
            //把线段添加到画布面板上
            this.ContentPanelCanvas.Children.Add(line);
            //把当前的画图的点作为上一个画图的点
            oldPoint= currentPoint;


        }

<Path Fill="Gold" Stroke="Black" StrokeThickness="1">
	<Path.Data>
		<RectangleGeometry Rect="0,0,100,100"/>
	</Path.Data>
</Path>
<Path Data="M0,L100,0 L100,100 L0,100 z" Fill="Gold" Height="100" Strenth="Fill" Width="100"/>

<PivotItem Header="Geometry">
               <StackPanel>
                   <!--直线-->
                   <Path Stroke="Red" StrokeThickness="2">
                       <Path.Data>
                           <LineGeometry StartPoint="0,0" EndPoint="400,20"/>
                       </Path.Data>
                   </Path>
                   <!--矩形路径-->
                   <Path Fill="Red">
                       <Path.Data>
                           <RectangleGeometry Rect="20,20,400,50"/>
                       </Path.Data>
                   </Path>
                   <!--椭圆路径-->
                   <Path Fill="Red">
                       <Path.Data>
                           <!--<GeometryGroup组合>-->
                           <GeometryGroup FillRule="EvenOdd">
                               <RectangleGeometry Rect="80,50,200,100"/>
                               <EllipseGeometry Center="300,100" RadiusX="80" RadiusY="60">
                                   
                               </EllipseGeometry>
                           </GeometryGroup>
                       </Path.Data>
                   </Path>

                   <Path Fill="Red" StrokeThickness="3">
                       <Path.Data>
                           <!--<GeometryGroup组合>-->
                           <GeometryGroup FillRule="Nonzero">
                               <RectangleGeometry Rect="80,50,200,100"/>
                               <EllipseGeometry Center="300,100" RadiusX="80" RadiusY="60"/>
                           </GeometryGroup>
                       </Path.Data>
                   </Path>
               </StackPanel>
           </PivotItem>
       </Pivot>

<Path Stroke="Red" StrokeThickness="5">
                    <Path.Data>
                        <PathGeometry>
                            <PathFigure StartPoint="10,20">
                                <PathFigure.Segments>
                                    <LineSegment Point="100,130"/>
                                </PathFigure.Segments>
                            </PathFigure>
                        </PathGeometry>
                    </Path.Data>
                </Path>

<PolyLineSegment Points="50,100,50,150"/>

<Path Stroke="Red" StrokeThickness="5">
                    <Path.Data>
                        <PathGeometry>
                            <PathGeometry.Figures>
                                <PathFigure StartPoint="10,50">
                                    <PathFigure.Segments>
                                        <ArcSegment Size="50,50" RotationAngle="45" IsLargeArc="True" SweepDirection="Clockwise" Point="200,100">
                                            
                                        </ArcSegment>
                                    </PathFigure.Segments>
                                </PathFigure>
                            </PathGeometry.Figures>
                        </PathGeometry>
                    </Path.Data>
                </Path>

<Path Stroke="Red" StrokeThickness="3" Data="M 100,200 C 100,25 400,350 400,175 H 280"/>

  <Grid x:Name="HexagonContentPanel" Margin="12,0,12,0">
                   <controls:Hexagon Height="300" Width="300" Stroke="Yellow" StrokeThickness="8" Fill="Red"/>
               </Grid>

public class Hexagon : Path
   {
       private double lastWidth = 0;
       private double lastHeight = 0;
       private PathFigure figure;
       public Hexagon()
       {
           CreateDataPath(0,0);
       }

       private void CreateDataPath(double width,double height)
       {
           //把高度和宽度先减去边的宽度
           height -= this.StrokeThickness;
           width-= this.StrokeThickness;
           //用来跳出布局的循环,因为只创建一次
           if (lastWidth == width && lastHeight == height)
               return;
           lastWidth= width;
           lastHeight= height;
           PathGeometry geometry= new PathGeometry();
           figure= new PathFigure();
           //取左上角的点为第一个点
           figure.StartPoint=new Windows.Foundation.Point(0.25*width,0);
           //算出每个顶点的坐标然后创建线段连接起来
           AddPoint(0.75*width,0);
           AddPoint(width,0.5*height);
           AddPoint(0.75*width,height);
           AddPoint(0.25*width,height);
           AddPoint(0,0.5*height);
           figure.IsClosed= true;
           geometry.Figures.Add(figure);
           this.Data = geometry;
       }

       private void AddPoint(double x, double y)
       {
          LineSegment segment= new LineSegment();
           segment.Point=new Point(x+0.5*StrokeThickness,y+0.5*StrokeThickness);
           figure.Segments.Add(segment);
       }
       protected override Size MeasureOverride(Size availableSize)
       {
           return availableSize;
       }

       protected override Size ArrangeOverride(Size finalSize)
       {
           //初始化图形
           CreateDataPath(finalSize.Width,finalSize.Height);
           return finalSize;
       }


   }

<Rectangle width="100" height="100" Fill="#FFFF0000"/>

<Path Canvas.Left="15" Canvas.Top="50" Stroke="Black" Data="M 0,0 A 15,5 180 1 1 200,0 L 200,100 L 300,100 L 300,200 A 15,5 180 1 1 100,200 L 100,100 L 0,100 Z">
	<Path.Fill>
		<LinearGradientBrush StartPoint="0,0" EndPoint="1,0">
			<GradientStop Offset="0" Color="DarkBlue"/>
			<GradientStop Offset="1" Color="LightBlue"/>
		</LinearGradientBrush>
	</Path.Fill>
</Path>

<Ellipse Height="180" Width="180" Margin="50,0,0,0">
	<Ellipse.Fill>
		<ImageBrush ImageSource="Assets/ApplicationIcon.png" Stretch="Fill"/>
	</Ellipse.Fill>
</Ellipse>

<Image Source="myImage.jpg" Width="200" Height="150">
	<Image.Clip>
		<RectangleGeometry Rect="0,0,50,50"/>
	</Image.Clip>
</Image>

  <Grid x:Name="ClipContentPanel" Margin="12,0,12,0">
                    <Canvas Background="White" Margin="20" controls:Clip.ToBounds="True">
                        <Ellipse Fill="Red" Canvas.Top="-10" Canvas.Left="-10" Width="200" Height="200"/>
                    </Canvas>
                </Grid>

public class Clip 
    {


        public static bool GetToBounds(DependencyObject obj)
        {
            return (bool)obj.GetValue(ToBoundsProperty);
        }

        public static void SetToBounds(DependencyObject obj, bool value)
        {
            obj.SetValue(ToBoundsProperty, value);
        }

        // Using a DependencyProperty as the backing store for ToBounds.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ToBoundsProperty =
            DependencyProperty.RegisterAttached("ToBounds", typeof(bool), typeof(Clip), new PropertyMetadata(false,OnToBoundsPropertyChanged));
        /// <summary>
        /// 定义属性改变事件
        /// </summary>
        /// <param name="d"></param>
        /// <param name="e"></param>
        /// <exception cref="NotImplementedException"></exception>
        private static void OnToBoundsPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            FrameworkElement fe = d as FrameworkElement;
            if (fe != null)
            {
                //裁剪图形
                ClipToBounds(fe);
                //当对象加载或者大小改变时都需要重新处理边界
                fe.Loaded += Fe_Loaded;
                fe.SizeChanged += Fe_SizeChanged;
            }
        }

        private static void Fe_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            ClipToBounds(sender as FrameworkElement);
        }

        private static void Fe_Loaded(object sender, RoutedEventArgs e)
        {
            ClipToBounds(sender as FrameworkElement);
        }

        private static void ClipToBounds(FrameworkElement fe)
        {
            //如果ToBounds设置为true则进行裁剪
            if (GetToBounds(fe))
            {
                //使用布局面板的实际高度和宽度来创建一个RectangleGeometry赋值给Clip属性
                fe.Clip = new Windows.UI.Xaml.Media.RectangleGeometry()
                {
                    Rect = new Windows.Foundation.Rect(0, 0, fe.ActualWidth, fe.ActualHeight)
                };
            }
            else
            {
                fe.Clip = null;
            }
        }
    }

<Image Source="myPicture.png"/>
Image myImage=new Image();
myImage.Source=new BitmapImage(new Uri("ms-appx:///myPicture.jpg",UriKind.Absolute));

<PivotItem Header="RenderTargetBitmap">
               <!--注册PointerReleased事件用于捕获屏幕的单击操作,并在时间处理程序中生成图片.-->
               <Grid x:Name="root" Background="{ThemeResource ApplicationPageBackgroundThemeBrush}" PointerReleased="root_PointerReleased">
                   <Grid.RowDefinitions>
                       <RowDefinition Height="Auto"/>
                       <RowDefinition Height="*"/>
                   </Grid.RowDefinitions>
                   <StackPanel x:Name="TitlePanel" Margin="12,35,0,28">
                       <TextBlock Text="我的应用程序" FontSize="20"/>
                       <TextBlock Text="点击截屏" FontSize="60"/>
                   </StackPanel>
                   <Grid x:Name="RenderTargetBitmapContentPanel" Grid.Row="1" Margin="12,0,12,0">
                   <!--该图片控件用于展示截图图片效果-->
                       <Image x:Name="img"/>
                   </Grid>
               </Grid>
           </PivotItem>
/// <summary>
       /// 指针释放的事件处理程序
       /// </summary>
       /// <param name="sender"></param>
       /// <param name="e"></param>
       private async void root_PointerReleased(object sender, PointerRoutedEventArgs e)
       {
           //创建一个RenderTargetBitmap对象,对界面中的Grid控件root生成图片
           RenderTargetBitmap bitmap = new RenderTargetBitmap();
           await bitmap.RenderAsync(root);
           //把图片展现出来
           img.Source=bitmap;
       }

var bitmap=new RenderTargetBitmap();
await bitmap.RenderAsync(elementToRender);
IBuffer pixelBuffer=await bitmap.GetPixelsAsync();
byte[] pixels=pixelBuffer.ToArray();

SetPixelData(BitmapPixelFormat pixelFormat,BitmapAlphaMode alphaMode,uint width,uint height,double dpiX,double dpiY,byte[] pixels)

           <PivotItem Header="SaveBitmapEncoder">
               <Grid x:Name="root1" Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
                   <Grid x:Name="BitmapEncoderContentPanel" Margin="12,0,12,0">
                       <StackPanel>
                           <Button x:Name="bt_save1" Content="存储生成的图片" Click="bt_save_Click_2"/>
                           <Button x:Name="bt_show"
                                   Content="展示存储的图片"
                                   Click="bt_show_Click"/>
                           <ScrollViewer BorderBrush="Red" BorderThickness="2" Height="350">
                               <Image x:Name="img1"/>
                               
                           </ScrollViewer>
                       </StackPanel>
                   </Grid>
               </Grid>
           </PivotItem>
/// <summary>
       /// 按钮事件生成图片并保存到程序的存储里
       /// </summary>
       /// <param name="sender"></param>
       /// <param name="e"></param>
       private async void bt_save_Click_2(object sender, RoutedEventArgs e)
       {
           //生成RenderTargetBitmap对象.
           RenderTargetBitmap bitmapbitmap = new RenderTargetBitmap();
           await bitmapbitmap.RenderAsync(root1);
           //获取图像的二进制数据
           var pixelBuffer=await bitmapbitmap.GetPixelsAsync();
           //创建程序文件存储
           IStorageFolder applicationFolder=ApplicationData.Current.LocalFolder;
           IStorageFile saveFile = await applicationFolder.CreateFileAsync("snapshot.png",CreationCollisionOption.OpenIfExists);
           //把图片的二进制数据写入文件存储
           using (var fileStream=await saveFile.OpenAsync(FileAccessMode.ReadWrite))
           {
               var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId,fileStream);
               encoder.SetPixelData(
                   BitmapPixelFormat.Bgra8,
                   BitmapAlphaMode.Ignore,
                   (uint)bitmapbitmap.PixelWidth,
                   (uint)bitmapbitmap.PixelHeight,
                   DisplayInformation.GetForCurrentView().LogicalDpi,
                   DisplayInformation.GetForCurrentView().LogicalDpi,
                   pixelBuffer.ToArray());
               await encoder.FlushAsync();
           }
       }
       /// <summary>
       /// 展示程序存储图片的按钮事件
       /// </summary>
       /// <param name="sender"></param>
       /// <param name="e"></param>
       private void bt_show_Click(object sender, RoutedEventArgs e)
       {
           // “ms-appdata:///local”表示是程序存储的根目录
           BitmapImage bitmapImage=new BitmapImage(new Uri("ms-appdata:///local/snapshot.png",UriKind.Absolute));
           img1.Source= bitmapImage;
       }