Develop Reference

Conversion problem from Image to base64 using C#

I am facing strange problem while converting Image to base64, some specific image which is on png format is not getting the base64 string when I copy paste those string on url so it is not displaying any image, but when I use Online Image to base64 website so it gave me true base64 string which is also open on browser.
var imgSrc = String.Format("data:image/jpeg;base64,{0}", ProperteaseAPI.Helpers.Common.ImgToBase64(img.ItemFileName));
html += "<img style ='width:50px; height: 50px; margin: 5px; src='" + imgSrc + "' />";'
public static string ImgToBase64(string path)
{
try
{
var context = System.Web.HttpContext.Current;
string baseUrl = ConfigurationManager.AppSettings["BaseURL"];
string PDF_Path = context.Server.MapPath("/");
var FullPath = PDF_Path + path;
using (Image image = Image.FromFile(FullPath))
{
using (MemoryStream m = new MemoryStream())
{
image.Save(m, image.RawFormat);
byte[] imageBytes = m.ToArray();
// Convert byte[] to Base64 String
string base64String = Convert.ToBase64String(imageBytes);
return base64String;
}
}
}
catch (Exception ex)
{
throw;
}
}

ASP.NET Web API C# Answer HttpRequest with Image via Json [duplicate]

How do you convert an image from a path on the user's computer to a base64 string in C#?
For example, I have the path to the image (in the format C:/image/1.gif) and would like to have a data URI like data:image/gif;base64,/9j/4AAQSkZJRgABAgEAYABgAAD.. representing the 1.gif image returned.

Try this
using (Image image = Image.FromFile(Path))
{
using (MemoryStream m = new MemoryStream())
{
image.Save(m, image.RawFormat);
byte[] imageBytes = m.ToArray();
// Convert byte[] to Base64 String
string base64String = Convert.ToBase64String(imageBytes);
return base64String;
}
}

Get the byte array (byte[]) representation of the image, then use Convert.ToBase64String(), st. like this:
byte[] imageArray = System.IO.File.ReadAllBytes(#"image file path");
string base64ImageRepresentation = Convert.ToBase64String(imageArray);
To convert a base64 image back to a System.Drawing.Image:
var img = Image.FromStream(new MemoryStream(Convert.FromBase64String(base64String)));

Since most of us like oneliners:
Convert.ToBase64String(File.ReadAllBytes(imageFilepath));
If you need it as Base64 byte array:
Encoding.ASCII.GetBytes(Convert.ToBase64String(File.ReadAllBytes(imageFilepath)));

This is the class I wrote for this purpose:
public class Base64Image
{
public static Base64Image Parse(string base64Content)
{
if (string.IsNullOrEmpty(base64Content))
{
throw new ArgumentNullException(nameof(base64Content));
}
int indexOfSemiColon = base64Content.IndexOf(";", StringComparison.OrdinalIgnoreCase);
string dataLabel = base64Content.Substring(0, indexOfSemiColon);
string contentType = dataLabel.Split(':').Last();
var startIndex = base64Content.IndexOf("base64,", StringComparison.OrdinalIgnoreCase) + 7;
var fileContents = base64Content.Substring(startIndex);
var bytes = Convert.FromBase64String(fileContents);
return new Base64Image
{
ContentType = contentType,
FileContents = bytes
};
}
public string ContentType { get; set; }
public byte[] FileContents { get; set; }
public override string ToString()
{
return $"data:{ContentType};base64,{Convert.ToBase64String(FileContents)}";
}
}
var base64Img = new Base64Image {
FileContents = File.ReadAllBytes("Path to image"),
ContentType="image/png"
};
string base64EncodedImg = base64Img.ToString();

You can easily pass the path of the image to retrieve the base64 string
public static string ImageToBase64(string _imagePath)
{
string _base64String = null;
using (System.Drawing.Image _image = System.Drawing.Image.FromFile(_imagePath))
{
using (MemoryStream _mStream = new MemoryStream())
{
_image.Save(_mStream, _image.RawFormat);
byte[] _imageBytes = _mStream.ToArray();
_base64String = Convert.ToBase64String(_imageBytes);
return "data:image/jpg;base64," + _base64String;
}
}
}
Hope this will help.

You can use Server.Map path to give relative path and then you can either create image using base64 conversion or you can just add base64 string to image src.
byte[] imageArray = System.IO.File.ReadAllBytes(Server.MapPath("~/Images/Upload_Image.png"));
string base64ImageRepresentation = Convert.ToBase64String(imageArray);

This code works well with me on DotNet Core 6
using (Image image = Image.FromFile(path))
{
using (MemoryStream m = new MemoryStream())
{
image.Save(m, ImageFormat.Jpeg);
byte[] imageBytes = m.ToArray();
// Convert byte[] to Base64 String
string base64String = Convert.ToBase64String(imageBytes);
// In my case I didn't find the part "data:image/png;base64,", so I added.
return $"data:image/png;base64,{base64String}";
}
}

That way it's simpler, where you pass the image and then pass the format.
private static string ImageToBase64(Image image)
{
var imageStream = new MemoryStream();
try
{
image.Save(imageStream, System.Drawing.Imaging.ImageFormat.Bmp);
imageStream.Position = 0;
var imageBytes = imageStream.ToArray();
var ImageBase64 = Convert.ToBase64String(imageBytes);
return ImageBase64;
}
catch (Exception ex)
{
return "Error converting image to base64!";
}
finally
{
imageStream.Dispose;
}
}

Based on top voted answer, updated for C# 8. Following can be used out of the box. Added explicit System.Drawing before Image as one might be using that class from other namespace defaultly.
public static string ImagePathToBase64(string path)
{
using System.Drawing.Image image = System.Drawing.Image.FromFile(path);
using MemoryStream m = new MemoryStream();
image.Save(m, image.RawFormat);
byte[] imageBytes = m.ToArray();
tring base64String = Convert.ToBase64String(imageBytes);
return base64String;
}

The following piece of code works for me:
string image_path="physical path of your image";
byte[] byes_array = System.IO.File.ReadAllBytes(Server.MapPath(image_path));
string base64String = Convert.ToBase64String(byes_array);

The reverse of this for the googlers arriving here (there is no SO quesion/answer to that)
public static byte[] BytesFromBase64ImageString(string imageData)
{
var trunc = imageData.Split(',')[1];
var padded = trunc.PadRight(trunc.Length + (4 - trunc.Length % 4) % 4, '=');
return Convert.FromBase64String(padded);
}

Something like that
Function imgTo64(ByVal thePath As String) As String
Dim img As System.Drawing.Image = System.Drawing.Image.FromFile(thePath)
Dim m As IO.MemoryStream = New IO.MemoryStream()
img.Save(m, img.RawFormat)
Dim imageBytes As Byte() = m.ToArray
img.Dispose()
Dim str64 = Convert.ToBase64String(imageBytes)
Return str64
End Function

Saving an image from bytes

I am trying to create an API which will save an image at a given location .
Below is my Code for that
Image image = Image.FromFile(#"C:\Users\abc\Desktop\img-logo.jpg");
byte[] bytes = (byte[])(new ImageConverter()).ConvertTo(image, typeof(byte[]));
string str = Convert.ToBase64String(bytes);
Save_Application_Image("12004", str);
and the method in API
public void Save_Application_Image(string staffCode , string bytearray)
{
try
{
byte[] bytes = Convert.FromBase64String(bytearray);
file_path = "~/uploads/" + file_name;
FileStream file = File.Create(HttpContext.Current.Server.MapPath(file_path));
file.Write(bytes, 0, bytes.Length);
file.Close();
}
catch(Exception ex)
{
logger.LogError(ex);
}
finally
{
}
}
This api has to be called from Android Application so I will receive two string parameter.
It is saving the file perfectly but file is not readable. No preview for image file.
What is the right approach for this ?

I'm unsure of how the ImageConverter works, but I've used this before to convert Images to byte[]:
Image image = Image.FromFile(#"C:\Users\abc\Desktop\img-logo.jpg");
using (var stream = new MemoryStream())
{
image.Save(stream);
string savedImage = Convert.ToBase64String(stream.ToArray());
Save_Application_Image("12004", str);
}

Xamarin forms signature pad Get image

Im using the following code to get the signature from the signature pad, But any value doesn't come.
try {
var signature = padView.GetImage (Acr.XamForms.SignaturePad.ImageFormatType.Png);
using (BinaryReader br = new BinaryReader (signature)) {
var result = br.ReadBytes ((int)signature.Length);
}
} catch (Exception ex) {
// Helper_ErrorHandling.SendErrorToServer (ex);
}
Am I ding it wrong, Also how do i convert this to a base64 string
?

I'm not too familiar with the Xamarin Forms Signature Pad, but if you're looking for a way to convert a Stream to as base64 string, try this:
[...]
string base64String;
using (var memoryStream = new MemoryStream())
{
signature.CopyTo( memoryStream );
var byteArray = memoryStream.ToArray();
base64String = Convert.ToBase64String( byteArray );
}
EDIT: you can most of the time skip the copy, if you check if signature is already a MemoryStream...
[...]
string base64String;
var signatureMemoryStream = signature as MemoryStream;
if (signatureMemoryStream == null)
{
signatureMemoryStream = new MemoryStream();
signature.CopyTo( signatureMemoryStream );
}
var byteArray = signatureMemoryStream.ToArray();
base64String = Convert.ToBase64String( byteArray );

Using the most current PCL compliant Xamarin package :
acr-xamarin-forms
This method works like a charm!
private string ConvertSignatureToBase64()
{
try
{
byte[] data;
if(Device.OS == TargetPlatform.iOS)
{
var img = SignaturePad.GetImage(Acr.XamForms.SignaturePad.ImageFormatType.Jpg);
var signatureMemoryStream = new MemoryStream();
img.CopyTo(signatureMemoryStream);
data = signatureMemoryStream.ToArray();
}
else
{
var img = SignaturePad.GetImage(Acr.XamForms.SignaturePad.ImageFormatType.Jpg);
var signatureMemoryStream = (MemoryStream)img;
data = signatureMemoryStream.ToArray();
}
return Convert.ToBase64String(data);
}
catch(Exception ex)
{
return ex.ToString();
}
}

Error in converting base64 string to image (description inside)

I've a task to convert a base64 string to image in asp.net c#, I'm using the following code,
private static bool SaveImage(string path, string link, string name)
{
bool result = true;
if (link.StartsWith("data:image/jpeg;base64,"))
{
try
{
string intImg = path + "/" + name + ".jpg";
System.Drawing.Image bmpFromString = Base64StringToBitmap(link.Replace("data:image/jpeg;base64,",""));
bmpFromString.Save(intImg, ImageFormat.Jpeg);
result = true;
}
catch (Exception)
{
result = false;
}
}
return result;
}
public static System.Drawing.Image Base64StringToBitmap(string base64String)
{
System.Drawing.Image bmpReturn = null;
//string converted = base64String.Replace('-', '+');
//converted = converted.Replace('_', '/');
byte[] byteBuffer = Convert.FromBase64String(base64String);
using (MemoryStream memoryStream = new MemoryStream(byteBuffer))
{
//finalImage = System.Drawing.Image.FromStream(ms);
memoryStream.Position = 0;
bmpReturn = System.Drawing.Image.FromStream(memoryStream);
memoryStream.Close();
byteBuffer = null;
}
return bmpReturn;
}
this is the base64 string
data:image/jpeg;base64,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
The error message is,
Error Message The input is not a valid Base-64 string as it contains a non-base 64 character, more than two padding characters, or an illegal character among the padding characters. "
I can't understand what is wrong with this method, would somebody correct me if i'm wrong.

The base64 string you have is not the correct length. Base64 strings should be in blocks of four characters, but you have 4657 characters, or 1164.25 blocks.
Conclusion: You've mistakenly doubled the last 8 in your string. Removing this, you get an image of three people on a yellow background, with a small gray border on the bottom.

You can use:
user.Image.Replace(#"data:image/jpeg;base64,", "");