Сохранить изображение с помощью FileSavePicker

Согласно документации:

Когда вызов этого метода завершается успешно, он возвращает объект storageFile, созданный для представления сохраненного файла. Имя файла, расширение и местоположение этого storageFile совпадают с указанными пользователем, но файл не имеет содержимого. Чтобы сохранить содержимое файла, ваше приложение должно записать содержимое в этот файл storageFile.

Итак, вы получаете файл хранилища, и вам нужно записать в него.

Сохранение BitmapImage невозможно, поэтому вам нужно начать с загрузки изображения в WriteableBitmap. Если вы просто копируете исходный файл, вы можете просто загрузить его в поток и сохранить обратно в новый файл хранилища. Если вы хотите пойти по маршруту WriteableBitmap — вот набор методов расширения, которые вы могли бы использовать для загрузки/сохранения изображения, если бы использовали C#:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using System.Text;
using System.Threading.Tasks;
using Windows.ApplicationModel;
using Windows.Graphics.Imaging;
using Windows.Storage;
using Windows.Storage.Streams;
using Windows.UI.Xaml.Media.Imaging;

namespace Xyzzer.WinRT.Extensions
{
    public static class WriteableBitmapSaveExtensions
    {
        public static async Task<WriteableBitmap> Load(string relativePath)
        {
            return await new WriteableBitmap(1, 1).Load(relativePath);
        }

        public static async Task<WriteableBitmap> Load(this WriteableBitmap writeableBitmap, string relativePath)
        {
            var storageFile = await Package.Current.InstalledLocation.GetFileAsync(relativePath.Replace('/', '\\'));
            return await writeableBitmap.Load(storageFile);
        }

        public static async Task<WriteableBitmap> Load(this WriteableBitmap writeableBitmap, StorageFile storageFile)
        {
            var stream = await storageFile.OpenReadAsync();
            var wb = new WriteableBitmap(1, 1);
            wb.SetSource(stream);
            return wb;
        }

        public static async Task SaveToFile(this WriteableBitmap writeableBitmap)
        {
            await writeableBitmap.SaveToFile(
                KnownFolders.PicturesLibrary,
                string.Format(
                    "{0}_{1}.png",
                    DateTime.Now.ToString("yyyyMMdd_HHmmss_fff"),
                    Guid.NewGuid()));
        }

        public static async Task SaveToFile(this WriteableBitmap writeableBitmap, StorageFolder storageFolder)
        {
            await writeableBitmap.SaveToFile(
                storageFolder,
                string.Format(
                    "{0}_{1}.png",
                    DateTime.Now.ToString("yyyyMMdd_HHmmss_fff"),
                    Guid.NewGuid()));
        }

        public static async Task SaveToFile(this WriteableBitmap writeableBitmap, StorageFolder storageFolder, string fileName)
        {
            StorageFile outputFile = await storageFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);

            Guid encoderId;

            var ext = Path.GetExtension(fileName);

            if (new[] { ".bmp", ".dib" }.Contains(ext))
            {
                encoderId = BitmapEncoder.BmpEncoderId;
            }
            else if (new[] { ".tiff", ".tif" }.Contains(ext))
            {
                encoderId = BitmapEncoder.TiffEncoderId;
            }
            else if (new[] { ".gif" }.Contains(ext))
            {
                encoderId = BitmapEncoder.TiffEncoderId;
            }
            else if (new[] { ".jpg", ".jpeg", ".jpe", ".jfif", ".jif" }.Contains(ext))
            {
                encoderId = BitmapEncoder.TiffEncoderId;
            }
            else if (new[] { ".hdp", ".jxr", ".wdp" }.Contains(ext))
            {
                encoderId = BitmapEncoder.JpegXREncoderId;
            }
            else //if (new [] {".png"}.Contains(ext))
            {
                encoderId = BitmapEncoder.PngEncoderId;
            }

            await writeableBitmap.SaveToFile(outputFile, encoderId);
        }

        public static async Task SaveToFile(this WriteableBitmap writeableBitmap, StorageFile outputFile, Guid encoderId)
        {
            try
            {
                Stream stream = writeableBitmap.PixelBuffer.AsStream();
                byte[] pixels = new byte[(uint)stream.Length];
                await stream.ReadAsync(pixels, 0, pixels.Length);

                int offset;

                for (int row = 0; row < (uint)writeableBitmap.PixelHeight; row++)
                {
                    for (int col = 0; col < (uint)writeableBitmap.PixelWidth; col++)
                    {
                        offset = (row * (int)writeableBitmap.PixelWidth * 4) + (col * 4);
                        byte B = pixels[offset];
                        byte G = pixels[offset + 1];
                        byte R = pixels[offset + 2];
                        byte A = pixels[offset + 3];

                        // convert to RGBA format for BitmapEncoder
                        pixels[offset] = R; // Red
                        pixels[offset + 1] = G; // Green
                        pixels[offset + 2] = B; // Blue
                        pixels[offset + 3] = A; // Alpha
                    }
                }

                IRandomAccessStream writeStream = await outputFile.OpenAsync(FileAccessMode.ReadWrite);
                BitmapEncoder encoder = await BitmapEncoder.CreateAsync(encoderId, writeStream);
                encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Premultiplied, (uint)writeableBitmap.PixelWidth, (uint)writeableBitmap.PixelHeight, 96, 96, pixels);
                await encoder.FlushAsync();
                await writeStream.GetOutputStreamAt(0).FlushAsync();
            }
            catch (Exception ex)
            {
                string s = ex.ToString();
            }
        }
    }
}