C# IBuffer.ToArray方法代码示例

		/// <summary>
		/// Encodes a buffer to a base64 string.
		/// </summary>
		/// <param name="buffer">Input buffer.</param>
		/// <returns>Base64-encoded output string.</returns>
		public static string EncodeToBase64String( IBuffer buffer )
		{
			if (buffer == null)
				throw new ArgumentNullException("buffer");

			return Convert.ToBase64String(buffer.ToArray());
		}

		/// <summary>
		/// Signs digital content. For more information, see MACs, Hashes, and Signatures.
		/// </summary>
		/// <param name="key">Key used for signing.</param>
		/// <param name="data">Data to be signed.</param>
		/// <returns>Signed data.</returns>
		public static IBuffer Sign( CryptographicKey key, IBuffer data )
		{
			if (key.Hash != null)
			{
				var signature = key.Hash.ComputeHash(data.ToArray());
				return new WindowsRuntimeBuffer(signature);
			}

			throw new NotImplementedException();
		}

 public static async Task SaveToPicturesLibraryAsync(IBuffer bufImage, string fileName, CancellationToken cancellationToken = default(CancellationToken))
 {
     var folder = await KnownFolders.PicturesLibrary.CreateFolderAsync("ImageVerificationExtras", CreationCollisionOption.OpenIfExists).AsTask(cancellationToken).ConfigureAwait(false);
     var file = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting).AsTask(cancellationToken).ConfigureAwait(false);
     using (var stream = await file.OpenStreamForWriteAsync().ConfigureAwait(false))
     {
         var data = bufImage.ToArray();
         await stream.WriteAsync(data, 0, data.Length, cancellationToken).ConfigureAwait(false);
         await stream.FlushAsync(cancellationToken).ConfigureAwait(false);
     }
 }

        public Salsa20RandomGenerator(IBuffer key)
        {
            if (key == null)
                throw new ArgumentNullException("key");

            key = HashAlgorithmProvider
                .OpenAlgorithm(HashAlgorithmNames.Sha256)
                .HashData(key);

            var iv = new byte[]
            {
                0xE8, 0x30, 0x09, 0x4B,
                0x97, 0x20, 0x5D, 0x2A
            };

            _cipher = new Salsa20Cipher(key.ToArray(), iv);
        }

        string GetDataLabelString(IBuffer data, uint scanDataType)
        {
            string result = null;
            // Only certain data types contain encoded text.
            //   To keep this simple, we'll just decode a few of them.
            if (data == null)
            {
                result = "No data";
            }
            else
            {
                switch (BarcodeSymbologies.GetName(scanDataType))
                {
                    case "Upca":
                    case "UpcaAdd2":
                    case "UpcaAdd5":
                    case "Upce":
                    case "UpceAdd2":
                    case "UpceAdd5":
                    case "Ean8":
                    case "Ean13":
                        // The UPC, EAN8, EAN13, and 2 of 5 families encode the digits 0..9
                        // which are then sent to the app in a UTF8 string (like "01234")
                        // This is not an exhaustive list of symbologies that can be converted to a string
                    case "Qr":
                        // Need to distinguish the scan data among Numeric, Alphanumeric, Binary/Byte, and Kanji/Kana.
                        // But as current barcode scanner could not distinguish the data is in Binary/Byte format or in rest 3 formats.
                        // So to read the decoded data as string.
                        result = string.Format("{0}", System.Text.Encoding.UTF8.GetString(data.ToArray()));
                        break;
                    default:
                        // Some other unsupport symbologies and just leave it as binary data
                        result = string.Format("Decoded data unavailable. Raw label data: {0}", GetDataString(data));
                        break;
                }
            }

            return result;
        }

        public async Task SetAsync(string key, IBuffer buffer, DateTime expires)
        {
            if (key == null)
            {
                throw new ArgumentNullException("The parameter key must not be null.");
            }

            if (buffer == null)
            {
                throw new ArgumentNullException("The parameter buffer must not be null.");
            }

            if (fileDb.IsOpen)
            {
                var bytes = buffer.ToArray();
                var ok = await Task.Run(() => AddOrUpdateRecord(key, bytes, expires));

                if (!ok && (await RepairDatabase()))
                {
                    await Task.Run(() => AddOrUpdateRecord(key, bytes, expires));
                }
            }
        }

 public async Task<string> CreateStringFromBuffer(IBuffer buffer)
 {
     var bytes = buffer.ToArray();
     return await Task.FromResult(Encoding.UTF8.GetString(bytes, 0, bytes.Length));
 }

		internal async Task<WriteResponse> WriteAsyncInternal(byte handle, IBuffer data)
		{
			await brick.SendCommandAsyncInternal(RequestTelegram.Write(handle, data.ToArray()));
			return ResponseTelegram.Write(brick.LastResponse);
		}

        private async void SaveImage(IBuffer pixelBuffer)
        {
            //Rendu du composant Xaml, ici le graphique 'Syncfusion.Chart', sous forme d'image en mémoire.
            RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap();
            //await renderTargetBitmap.RenderAsync(doughnutMadelin, (int)myDoughnutActualWidth, (int)myDoughnut.ActualHeight);
            // var pixelBuffer = await renderTargetBitmap.GetPixelsAsync();

            var localFolder = Windows.Storage.KnownFolders.PicturesLibrary;
            string filepicname = homewebview.DocumentTitle;
          //  var localFolder = Windows.ApplicationModel.Package.Current.InstalledLocation;
            var saveFile = await localFolder.CreateFileAsync(filepicname+".png", Windows.Storage.CreationCollisionOption.OpenIfExists);

            // Encodage de l'image en mémoire dans le fichier désigné sur le disque
            using (var fileStream = await saveFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
            {
                var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, fileStream);

                encoder.SetPixelData(
                    BitmapPixelFormat.Rgba8,
                    BitmapAlphaMode.Premultiplied,
                    (uint)homewebview.ActualWidth,
                    (uint)homewebview.ActualHeight,
                    DisplayInformation.GetForCurrentView().LogicalDpi,
                    DisplayInformation.GetForCurrentView().LogicalDpi,
                    pixelBuffer.ToArray());

                await encoder.FlushAsync();
            }
            MessageDialog one = new MessageDialog("截图保存到图片库");
            await one.ShowAsync();
        }

		internal async Task MessageWriteAsyncInternal(int inboxNumber, IBuffer message)
		{
			await brick.SendCommandAsyncInternal(RequestTelegram.MessageWrite(inboxNumber, message.ToArray()));
		}

		internal async Task LowSpeedWriteAsyncInternal(SensorPort sensorPort, IBuffer data, byte responseLength)
		{
			await brick.SendCommandAsyncInternal(RequestTelegram.LowSpeedWrite(sensorPort, data.ToArray(), responseLength));
		}

        private async void _colorImage_ImageOpened(object sender, RoutedEventArgs e)
        {
            if (_rtb != null) _rtb = null;
            _rtb = new RenderTargetBitmap();

            await _rtb.RenderAsync(_colorImage);
            _pixelBuffer = await _rtb.GetPixelsAsync();
            _pixelBufferData = _pixelBuffer.ToArray();
        }

        /// <summary>
        /// Gets the database schema version.
        /// </summary>
        /// <param name="buffer">The version bytes buffer</param>
        /// <returns>The database schema version.</returns>
        private static Version GetVersion(IBuffer buffer)
        {
            if (buffer == null)
                throw new ArgumentNullException("buffer");

            var bytes = buffer.ToArray(0, 4);
            var minor = BitConverter.ToUInt16(bytes, 0);
            var major = BitConverter.ToUInt16(bytes, 2);

            return new Version(major, minor);
        }

        /// <summary>
        /// Parse the headers fields.
        /// </summary>
        /// <param name="input">The input stream.</param>
        /// <param name="buffer">The header bytes reader.</param>
        /// <returns>The file headers.</returns>
        private static async Task<FileHeaders> GetHeaders(
            IInputStream input, IBuffer buffer)
        {
            var result = new FileHeaders();

            while (true)
            {
                buffer = await input.ReadAsync(buffer, 3);
                var field = (HeaderFields)buffer.GetByte(0);
                var size = BitConverter.ToUInt16(buffer.ToArray(1, 2), 0);

                if (size > 0)
                    buffer = await input.ReadAsync(buffer, size);

                switch (field)
                {
                    case HeaderFields.EndOfHeader:
                        return result;

                    case HeaderFields.CompressionFlags:
                        result.UseGZip = buffer.GetByte(0) == 1;
                        break;

                    case HeaderFields.EncryptionIV:
                        result.EncryptionIV = buffer
                            .ToArray().AsBuffer();
                        break;

                    case HeaderFields.MasterSeed:
                        result.MasterSeed = buffer
                            .ToArray().AsBuffer();
                        break;

                    case HeaderFields.StreamStartBytes:
                        result.StartBytes = buffer
                            .ToArray().AsBuffer();
                        break;

                    case HeaderFields.TransformSeed:
                        result.TransformSeed = buffer
                            .ToArray().AsBuffer();
                        break;

                    case HeaderFields.TransformRounds:
                        result.TransformRounds = BitConverter.ToUInt64(
                            buffer.ToArray(), 0);
                        break;

                    case HeaderFields.ProtectedStreamKey:
                        result.ProtectedStreamKey = buffer
                            .ToArray().AsBuffer();
                        break;

                    case HeaderFields.InnerRandomStreamID:
                        result.RandomAlgorithm = (CrsAlgorithm)
                            BitConverter.ToUInt32(buffer.ToArray(), 0);
                        break;
                }
            }
        }