C# IStorageFile.OpenReadAsync方法代码示例

        private static async Task<Uri> GenerateThumbnail(IStorageFile file)
        {
            using (var fileStream = await file.OpenReadAsync())
            {
                // decode the file using the built-in image decoder
                var decoder = await BitmapDecoder.CreateAsync(fileStream);

                // create the output file for the thumbnail
                var thumbFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(
                    string.Format("thumbnail{0}", file.FileType),
                    CreationCollisionOption.GenerateUniqueName);

                // create a stream for the output file
                using (var outputStream = await thumbFile.OpenAsync(FileAccessMode.ReadWrite))
                {
                    // create an encoder from the existing decoder and set the scaled height
                    // and width 
                    var encoder = await BitmapEncoder.CreateForTranscodingAsync(
                        outputStream,
                        decoder);
                    encoder.BitmapTransform.ScaledHeight = 100;
                    encoder.BitmapTransform.ScaledWidth = 100;
                    await encoder.FlushAsync();
                }

                // create the URL
                var storageUrl = string.Format(URI_LOCAL, thumbFile.Name);

                // return it
                return new Uri(storageUrl, UriKind.Absolute);
            }
        }

        private async static Task<byte[]> ReadStorageFileToByteBuffer(IStorageFile storageFile)
        {
            IRandomAccessStream accessStream = await storageFile.OpenReadAsync();
            byte[] content = null;

            using (Stream stream = accessStream.AsStreamForRead((int)accessStream.Size))
            {
                content = new byte[stream.Length];
                await stream.ReadAsync(content, 0, (int)stream.Length);
            }

            return content;
        }

 private static async Task CopyFileIntoIsoStore(IStorageFile sourceFile)
 {
     using (var s = await sourceFile.OpenReadAsync())
     using (var dr = new DataReader(s))
     using (var isoStore = IsolatedStorageFile.GetUserStoreForApplication())
     using (var targetFile = isoStore.CreateFile(sourceFile.Name))
     {
         var data = new byte[s.Size];
         await dr.LoadAsync((uint)s.Size);
         dr.ReadBytes(data);
         targetFile.Write(data, 0, data.Length);
     }
 }

    internal async static Task<string> ReadTextAsync(IStorageFile storageFile)
    {
      string text;

      IRandomAccessStream accessStream = await storageFile.OpenReadAsync();

      using (Stream stream = accessStream.AsStreamForRead((int)accessStream.Size))
      {
        byte[] content = new byte[stream.Length];
        await stream.ReadAsync(content, 0, (int)stream.Length);

        text = Encoding.UTF8.GetString(content, 0, content.Length);
      }

      return text;
    }

        internal static async Task ResizeAndSaveAs(IStorageFile source, IStorageFile destination, 
            int targetDimension)
        {
            // open the file...
            using(var sourceStream = await source.OpenReadAsync())
            {
                // step one, get a decoder...
                var decoder = await BitmapDecoder.CreateAsync(sourceStream);

                // step two, create somewhere to put it...
                using(var destinationStream = await destination.OpenAsync(FileAccessMode.ReadWrite))
                {
                    // step three, create an encoder...
                    var encoder = await BitmapEncoder.CreateForTranscodingAsync(destinationStream, decoder);

                    // how big is it?
                    uint width = decoder.PixelWidth;
                    uint height = decoder.PixelHeight;
                    decimal ratio = (decimal)width / (decimal)height;

                    // orientation?
                    bool portrait = width < height;

                    // step four, configure it...
                    if (portrait)
                    {
                        encoder.BitmapTransform.ScaledHeight = (uint)targetDimension;
                        encoder.BitmapTransform.ScaledWidth = (uint)((decimal)targetDimension * ratio);
                    }
                    else
                    {
                        encoder.BitmapTransform.ScaledWidth = (uint)targetDimension;
                        encoder.BitmapTransform.ScaledHeight = (uint)((decimal)targetDimension / ratio);
                    }

                    // step five, write it...
                    await encoder.FlushAsync();
                }
            }
        }

        private static async Task<ZipArchiveEntry> DoCreateEntryFromFile(ZipArchive destination, IStorageFile sourceFile, string entryName, CompressionLevel? compressionLevel)
        {
            if (destination == null)
                throw new ArgumentNullException("destination");
            if (sourceFile == null)
                throw new ArgumentNullException("sourceFile");
            if (entryName == null)
                throw new ArgumentNullException("entryName");
            using (Stream stream = (await sourceFile.OpenReadAsync()).AsStream())
            {
                ZipArchiveEntry zipArchiveEntry = compressionLevel.HasValue ? destination.CreateEntry(entryName, compressionLevel.Value) : destination.CreateEntry(entryName);

                var props = await sourceFile.GetBasicPropertiesAsync();

                DateTime dateTime = props.DateModified.UtcDateTime;
                if (dateTime.Year < 1980 || dateTime.Year > 2107)
                    dateTime = new DateTime(1980, 1, 1, 0, 0, 0);
                zipArchiveEntry.LastWriteTime = (DateTimeOffset)dateTime;
                using (Stream destination1 = zipArchiveEntry.Open())
                {
                    await stream.CopyToAsync(destination1);
                }
                return zipArchiveEntry;
            }
        }

		//http://www.techcoil.com/blog/sending-a-file-and-some-form-data-via-http-post-in-c/
		public static async Task<WebResult> POST(string url, IStorageFile file, Dictionary<string, string> additionalContent, string token = null)
		{
			string boundaryString = "----DiscordUWP8Boundary" + new Random().Next(0, 999);

			HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
			request.Method = "POST";
			request.ContentType = "multipart/form-data; boundary=" + boundaryString;

			request.Headers["Connection"] = "Keep-Alive";
			if (token != null) request.Headers["Authorization"] = token;

			MemoryStream postDataStream = new MemoryStream();
			StreamWriter postDataWriter = new StreamWriter(postDataStream);

			foreach(KeyValuePair<string, string> content in additionalContent)
			{
				postDataWriter.Write("\r\n--" + boundaryString + "\r\n");
				postDataWriter.Write("Content-Disposition: form-data; name=\"{0}\"\r\n\r\n{1}", content.Key, content.Value);
			}

			postDataWriter.Write("\r\n--" + boundaryString + "\r\n");
			postDataWriter.Write("Content-Disposition: form-data;" + "name=\"{0}\";" + "filename=\"{1}\"" + "\r\nContent-Type: {2}\r\n\r\n", "file", Path.GetFileName(file.Path), Path.GetExtension(file.Path));
			postDataWriter.Flush();

			// Read the file

			var stream = await file.OpenReadAsync();

			byte[] buffer = new byte[1024];

			using (var ss = stream.AsStreamForRead(1024))
			{
				int bytesRead = 0;
				while ((bytesRead = await ss.ReadAsync(buffer, 0, buffer.Length)) != 0)
				{
					postDataStream.Write(buffer, 0, bytesRead);
				}
			}

			postDataWriter.Write("\r\n--" + boundaryString + "--\r\n");
			postDataWriter.Flush();

			// Dump the post data from the memory stream to the request stream
			using (Stream s = await request.GetRequestStreamAsync())
			{
				postDataStream.WriteTo(s);
			}

			postDataWriter.Dispose();
			postDataStream.Dispose();

			try
			{
				using (HttpWebResponse response = (HttpWebResponse)await request.GetResponseAsync())
				{
					using (StreamReader reader = new StreamReader(CheckForCompression(response), Encoding.UTF8))
					{
						return new WebResult { Data = reader.ReadToEnd(), Status = response.StatusCode };
					}
				}
			}
			catch (WebException e)
			{
				using (HttpWebResponse response = (HttpWebResponse)e.Response)
				{
					using (StreamReader reader = new StreamReader(CheckForCompression(response), Encoding.UTF8))
					{
						return new WebResult { Data = reader.ReadToEnd(), Status = response.StatusCode };
					}
				}
			}
		}

        public async Task AddKeyFile(IStorageFile file)
        {
            KeyfileName = file.Name;
            using (var input = await file.OpenReadAsync())
                await _password.AddKeyFile(input);

            NotifyOfPropertyChange(() => CanOpenDatabase);
            NotifyOfPropertyChange(() => CanClearKeyfile);
            NotifyOfPropertyChange(() => KeyfileGroupVisibility);
        }