Open ImageFiles,GetResizedPng,ToBase64,FromBase64 and asyncs

ImageTools

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Threading.Tasks;

namespace ImageBase64CoderDecoder
{
    public static class ImageTools
    {
        public static Image GetImage(string filename)
        {
            return Image.FromFile(filename);
        }

        public static Image GetResizedPng(Image img, int size)
        {
            var imgSize = GetThumbnailSize(img, size);
            var resized = img.GetThumbnailImage(imgSize.Width, imgSize.Height, null, IntPtr.Zero);
            var ms = new MemoryStream();
            resized.Save(ms, ImageFormat.Png);
            resized = Image.FromStream(ms);
            return resized;
        }


        public static Task<Image> GetResizedPngAsync(Image img, int size)
        {
            return Task.Run(() =>
            {
                var imgSize = GetThumbnailSize(img, size);
                var resized = img.GetThumbnailImage(imgSize.Width, imgSize.Height, null, IntPtr.Zero);
                var ms = new MemoryStream();
                resized.Save(ms, ImageFormat.Png);
                resized = Image.FromStream(ms);
                return resized;
            });
        }

        public static long ImageSizeInKBytes(Image img, ImageFormat imgFormat)
        {
            var ms = new MemoryStream();
            img.Save(ms, imgFormat);
            return ms.Length / 1024;
        }

        public static Image Base64ToImage(string base64String)
        {
            // Convert Base64 String to byte[]
            byte[] imageBytes = Convert.FromBase64String(base64String);
            var ms = new MemoryStream(imageBytes, 0,
              imageBytes.Length);

            // Convert byte[] to Image
            ms.Write(imageBytes, 0, imageBytes.Length);
            Image image = Image.FromStream(ms, true);
            return image;
        }

        public static Task<Image> Base64ToImageAsync(string base64String)
        {
            return Task.Run(() =>
            {
                // Convert Base64 String to byte[]
                byte[] imageBytes = Convert.FromBase64String(base64String);
                var ms = new MemoryStream(imageBytes, 0,
                    imageBytes.Length);

                // Convert byte[] to Image
                ms.Write(imageBytes, 0, imageBytes.Length);
                Image image = Image.FromStream(ms, true);
                return image;
            });
        }

        public static string ImageToBase64(Image image, System.Drawing.Imaging.ImageFormat format)
        {
            using (var ms = new MemoryStream())
            {
                // Convert Image to byte[]
                image.Save(ms, format);
                byte[] imageBytes = ms.ToArray();

                // Convert byte[] to Base64 String
                string base64String = Convert.ToBase64String(imageBytes);
                return base64String;
            }
        }
        public static Task<string> ImageToBase64Async(Image image, System.Drawing.Imaging.ImageFormat format)
        {
            return Task.Run(() =>
            {
                using (var ms = new MemoryStream())
                {
                    // Convert Image to byte[]
                    image.Save(ms, format);
                    byte[] imageBytes = ms.ToArray();

                    // Convert byte[] to Base64 String
                    string base64String = Convert.ToBase64String(imageBytes);
                    return base64String;
                }
            });
        }

        static Size GetThumbnailSize(Image original, int maxSize)
        {
            // Maximum size of any dimension.
            int maxPixels = maxSize;

            // Width and height.
            int originalWidth = original.Width;
            int originalHeight = original.Height;

            // Compute best factor to scale entire image based on larger dimension.
            double factor;
            if (originalWidth > originalHeight)
            {
                factor = (double)maxPixels / originalWidth;
            }
            else
            {
                factor = (double)maxPixels / originalHeight;
            }

            // Return thumbnail size.
            return new Size((int)(originalWidth * factor), (int)(originalHeight * factor));
        }
    }
}