How To Upload And Save Image Or File Using Asp.Net WebApi? – Server Side (Part 1)

In this post, i am going to explain how to upload and save image or file using Asp.Net WebApi.
Key Notes regarding the code:
1. HttpResponseMessage: A HttpResponseMessage enables us to work with the HTTP convention. In straightforward words a HttpResponseMessage is a method for restoring a message/information from your activity.
2. EXIF Orientation: It changes the orientation of the picture and image captured by mobile phone. To handle this problem, refer to the below snipets.

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Web;
using System.Web.Http;

 namespace WebApplication1.Controllers
{
    public class FileController : ApiController
    {
        public enum MessageType
        {
            Image = 0,
            File = 1
        }

         /// <summary>
        /// Purpose: Upload file or image
        /// </summary>
        [HttpPost]
        public HttpResponseMessage UploadFileOrImage()
        {
            if (!Request.Content.IsMimeMultipartContent())
                throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);

             try
            {
                var httpRequest = HttpContext.Current.Request;

                 int attachmentType;
                int.TryParse(httpRequest.Form["AttachmentType"], out attachmentType);
                var fileName = httpRequest.Form["FileName"];

                 string attachedPath = string.Empty;

                 // Check if any file(s) have been uploaded
                if (httpRequest.Files.Count > 0)
                {
                    // Get file content as byte array
                    MemoryStream ms = new MemoryStream();
                    httpRequest.Files[0].InputStream.CopyTo(ms);
                    byte[] fileContent = ms.ToArray();

                     if (fileContent != null)
                    {
                        if (attachmentType == (int)MessageType.Image)
                        {
                            attachedPath = SaveImage(fileContent, "Uploads/Image/", true,
                                "Uploads/ImageThumb/", 90, 90);
                        }
                        else //Save File
                        {
                            var file = httpRequest.Files[0];
                            attachedPath = SaveFile(file, System.Web.Hosting.HostingEnvironment.MapPath("/Uploads/File/"));
                        }
                    }
                }

                 var attachmentPath = "http://lazycipher.com/Uploads/ImageThumb/" + attachedPath;
                return Request.CreateResponse(HttpStatusCode.Created, attachmentPath);
            }
            catch (Exception ex)
            {
                return Request.CreateResponse(HttpStatusCode.InternalServerError, ex.InnerException);
            }
        }

         #region Save Image

         /// <summary>
        /// Purpose: To Save Image
        /// </summary>
        /// <param name="File">Image Name</param>
        /// <param name="ImageSaveLocationPath"></param>
        /// <param name="ThumbnailCreate"></param>
        /// <param name="ImageThumbLocationPath"></param>
        /// <param name="thumbImageWidth"></param>
        /// <param name="thumbImageHeight"></param>
        /// <returns></returns>
        public static string SaveImage(byte[] File, string ImageSaveLocationPath, bool ThumbnailCreate = false,
            string ImageThumbLocationPath = "", int thumbImageWidth = 0, int thumbImageHeight = 0)
        {
            try
            {
                var sitePhysicalPath = AppDomain.CurrentDomain.BaseDirectory;

                 string imageName = DateTime.Now.Ticks + ".jpg"; //Image Name
                string fileExtention = Path.GetExtension(imageName); // File Extension
                string ImagePhysicalPath = sitePhysicalPath + ImageSaveLocationPath + imageName; // Original Image Physical Path
                string OrginalImagePathLocation = ImageSaveLocationPath;

                 byte[] bt = File;
                MemoryStream ms = new MemoryStream(bt);

                 SaveOriginalImage(ms, ImagePhysicalPath);

                 #region Save Thumbnails

                 if (ThumbnailCreate)
                {
                    Bitmap ThumbImage = CreateThumbnail(sitePhysicalPath + OrginalImagePathLocation + imageName, thumbImageWidth, thumbImageHeight);
                    ImageThumbLocationPath += imageName.Substring(0, imageName.LastIndexOf('.')) + fileExtention;
                    ThumbImage.Save(sitePhysicalPath + ImageThumbLocationPath);
                }

                 #endregion

                 return imageName;
            }
            catch (Exception)
            {
                return string.Empty;
            }
        }

         /// <summary>
        /// Purpose: Save original image
        /// </summary>
        /// <param name="ms"></param>
        /// <param name="ImagePhysicalPath"></param>
        private static void SaveOriginalImage(MemoryStream ms, string ImagePhysicalPath)
        {
            Image img = Image.FromStream(ms);
            img.Save(ImagePhysicalPath, ImageFormat.Jpeg);
        }
        /// <summary>
        /// Purpose: To save image as thumbnail
        /// </summary>
        /// <param name="lcFilename"></param>
        /// <param name="lnWidth"></param>
        /// <param name="lnHeight"></param>
        /// <returns></returns>
        private static Bitmap CreateThumbnail(string lcFilename, int lnWidth, int lnHeight)
        {
            Bitmap bmpOut = null;
            try
            {
                Bitmap loBMP = new Bitmap(lcFilename);
                ImageFormat loFormat = loBMP.RawFormat;

                 decimal lnRatio;
                int lnNewWidth = 0;
                int lnNewHeight = 0;

                 //*** If the image is smaller than a thumbnail just return it
                if (loBMP.Width < lnWidth && loBMP.Height < lnHeight) return loBMP; if (loBMP.Width > loBMP.Height)
                {
                    lnRatio = (decimal)lnWidth / loBMP.Width;
                    lnNewWidth = lnWidth;
                    decimal lnTemp = loBMP.Height * lnRatio;
                    lnNewHeight = (int)lnTemp;
                }
                else
                {
                    lnRatio = (decimal)lnHeight / loBMP.Height;
                    lnNewHeight = lnHeight;
                    decimal lnTemp = loBMP.Width * lnRatio;
                    lnNewWidth = (int)lnTemp;
                }

                 #region Handle EXIF problem (i.e. When image clicked from camera, it automatically gets rotated)

                 if (Array.IndexOf(loBMP.PropertyIdList, 274) > -1)
                {
                    var orientation = (int)loBMP.GetPropertyItem(274).Value[0];
                    switch (orientation)
                    {
                        case 1:
                            // No rotation required.
                            break;
                        case 2:
                            loBMP.RotateFlip(RotateFlipType.RotateNoneFlipX);
                            break;
                        case 3:
                            loBMP.RotateFlip(RotateFlipType.Rotate180FlipNone);
                            break;
                        case 4:
                            loBMP.RotateFlip(RotateFlipType.Rotate180FlipX);
                            break;
                        case 5:
                            loBMP.RotateFlip(RotateFlipType.Rotate90FlipX);
                            break;
                        case 6:
                            loBMP.RotateFlip(RotateFlipType.Rotate90FlipNone);
                            break;
                        case 7:
                            loBMP.RotateFlip(RotateFlipType.Rotate270FlipX);
                            break;
                        case 8:
                            loBMP.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            break;
                    }
                    // This EXIF data is now invalid and should be removed.
                    loBMP.RemovePropertyItem(274);
                }

                 #endregion

                 bmpOut = new Bitmap(lnNewWidth, lnNewHeight);

                 Graphics g = Graphics.FromImage(bmpOut);
                g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                g.FillRectangle(Brushes.White, 0, 0, lnNewWidth, lnNewHeight);
                g.DrawImage(loBMP, 0, 0, lnNewWidth, lnNewHeight);

                 loBMP.Dispose();
            }
            catch
            {
                return null;
            }

             return bmpOut;
        }

         /// <summary>
        /// Purpose: Save file i.e. docs, xlsx etc
        /// </summary>
        /// <param name="file"></param>
        /// <param name="physicalPath"></param>
        /// <returns></returns>
        public static string SaveFile(HttpPostedFile file, string physicalPath)
        {
            if (file != null && file.ContentLength > 0)
            {
                var fileName = Path.GetFileName(file.FileName);
                var path = Path.Combine(physicalPath, fileName);
                file.SaveAs(path);

                 return fileName;
            }

             return string.Empty;
        }

         #endregion
    }
}
If you have any problems or feedback or any idea leave a comment…
Part 2 of this post is coming soon, in which i will explain how to upload data from client side to server.

Comments

Post a Comment

Popular posts from this blog

How To Detect Listview Scroll State (Idle/Running) In Xamarin.Forms?

In xamarin.forms, their is no event available to check listview scroll state. So, in that case, we have to customize the Listview control in xamarin.forms. Following is the sample code to detect scroll state of listview: Portable Library:  In a portable library project, add class “CustomListview.cs”  public class CustomListview : ListView {     public CustomListview() { }     public CustomListview(ListViewCachingStrategy cachingStrategy) : base(cachingStrategy) { }     public event EventHandler<ScrollStateChangedEventArgs> ScrollStateChanged;     public static void OnScrollStateChanged(object sender, ScrollStateChangedEventArgs e)     {         var customListview = (CustomListview)sender;         customListview.ScrollStateChanged?.Invoke(customListview, e);     }     public event EventHandler<ItemTappedIOSEventArgs> ItemTa...
Read more

Generic Web Api Client Request (GET/POST)

Here i am going to explain, how to create generic web api client request, 1. It will helps you to manage all HTTP request from single class. 2. It will helps you to reduce your number of duplicate code as well. (No more repeat code for HTTP client). Use NuGet Package Manager to install the Web API Client Libraries package. From the Tools menu, select NuGet Package Manager > Package Manager Console. In the Package Manager Console (PMC), type the following command: Install-Package Microsoft.AspNet.WebApi.Client Following is the sample code for Generic HTTP request: using System; using System.Net.Http; using System.Net.Http.Headers; using System.Text; using System.Threading.Tasks; namespace ApiRequestSample {     public class GenericHttpRequest     {         protected static string HeaderName { get { return "AuthenticationToken"; } }         protected static string HeaderValue { get...
Read more

How To Upload File/Image Using Multipart/Form-Data From Client Side To Server? – Client Side (Part 2)

In this post, i am going to explain how to send mutipart/form-data from client side. A HTTP multipart request helps to send files/images and data over to a HTTP server. It is a very common approach used by browsers and any other HTTP clients to upload files to the server. using System; using System.Linq; using System.Net.Http; using Xamarin.Forms; namespace ClientApi {     public partial class MainPage : ContentPage     {         public MainPage()         {             InitializeComponent();         }         /// <summary>         /// Purpose: Post multipart data i.e. image or file         /// </summary>         protected async void SaveAttachment(byte[] attachment, string fileName, string attachmentType, string orgFileName)         {   ...
Read more