I am trying to convert a Base64String to an image which needs to be saved locally.
At the moment, my code is able to save the image but when I open the saved image, it says "Invalid Image".
Code:
try
{
using (var imageFile = new StreamWriter(filePath))
{
imageFile.Write(resizeImage.Content);
imageFile.Close();
}
}
The Content is a string object which contains the Base64 String.
First, convert the base 64 string to an Image, then use the Image.Save method.
To convert from base 64 string to Image:
public Image Base64ToImage(string base64String)
{
// Convert base 64 string to byte[]
byte[] imageBytes = Convert.FromBase64String(base64String);
// Convert byte[] to Image
using (var ms = new MemoryStream(imageBytes, 0, imageBytes.Length))
{
Image image = Image.FromStream(ms, true);
return image;
}
}
To convert from Image to base 64 string:
public string ImageToBase64(Image image,System.Drawing.Imaging.ImageFormat format)
{
using (MemoryStream ms = new MemoryStream())
{
// Convert Image to byte[]
image.Save(ms, format);
byte[] imageBytes = ms.ToArray();
// Convert byte[] to base 64 string
string base64String = Convert.ToBase64String(imageBytes);
return base64String;
}
}
Finally, you can easily to call Image.Save(filePath); to save the image.
So with the code you have provided.
var bytes = Convert.FromBase64String(resizeImage.Content);
using (var imageFile = new FileStream(filePath, FileMode.Create))
{
imageFile.Write(bytes ,0, bytes.Length);
imageFile.Flush();
}
public Image Base64ToImage(string base64String)
{
// Convert Base64 String to byte[]
byte[] imageBytes = Convert.FromBase64String(base64String);
MemoryStream 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;
}
Front :
<Image Name="camImage"/>
Back:
public async void Base64ToImage(string base64String)
{
// read stream
var bytes = Convert.FromBase64String(base64String);
var image = bytes.AsBuffer().AsStream().AsRandomAccessStream();
// decode image
var decoder = await BitmapDecoder.CreateAsync(image);
image.Seek(0);
// create bitmap
var output = new WriteableBitmap((int)decoder.PixelHeight, (int)decoder.PixelWidth);
await output.SetSourceAsync(image);
camImage.Source = output;
}
Related
When i try to convert a base64string to an Image in C#, I'm getting output as "System.Drawing.Bitmap" instead of the actual Image:
public Image DownFile(string base64String)//string file
{
//Convert Base64 String to byte[]
byte[] imageBytes = Convert.FromBase64String(base64String);
MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length);
//Convert byte[] to Image
ms.Write(imageBytes, 0, imageBytes.Length);
Image image = Image.FromStream(ms, true);
image.Save("E:/Project Utilitie Connection/FileDownloadTask/Images", System.Drawing.Imaging.ImageFormat.Jpeg);
return image;
}
try a using statement for the MemoryStream, like so:
byte[] bytes = Convert.FromBase64String(base64String);
Image image;
using (MemoryStream ms = new MemoryStream(bytes))
{
image = Image.FromStream(ms);
}
return image;
The framework is converting the Image object to string which is why you are seeing System.Drawig.Bitmap
Create a response, giving it the bytes from the converted base64 string and then setting the content type for response so the client will know how to render the content.
public class ValuesController : ApiController {
[HttpGet]
public IHttpActionResult DownFile(string base64String) {
if (!string.IsNullOrWhiteSpace(base64String)) {
byte[] imageBytes = Convert.FromBase64String(base64String);
var response = Request.CreateResponse(HttpStatusCode.OK);
response.Content = new ByteArrayContent(imageBytes);
response.Content.Headers.ContentType = new MediaTypeHeaderValue("image/jpg");
return ResponseMessage(response);
}
return BadRequest();
}
}
This is a very simplified example to demonstrate how it can be done. Take some time to review and understand what was done so that it can be implemented into your particular scenario.
I am trying to get images stored in resource file and then trying to convert it to base64 string. however it generate garbage string below is my code:
String imgBase64=Base64FromByteArray(ExtractResource(Properties.Resources.products_tipp_110));
public static byte[] ExtractResource(Bitmap image)
{
MemoryStream ms = new MemoryStream();
image.Save(ms, ImageFormat.Png);
if (ms == null)
return null;
byte[] imageByteArray = new byte[ms.Length];
ms.Read(imageByteArray, 0, imageByteArray.Length);
return imageByteArray;
}
private static string Base64FromByteArray(byte[] image)
{
return "base64:" + Convert.ToBase64String(image);
}
output:
base64:AAAAAAAAAAAAAAAAAAAAAAAAAAAAA..... with all A's
Can you try this byte[] imageByteArray = ms.ToArray() to convert the memory stream into byte array as below.
Also, make sure your image is png as you have used ImageFormat.Png
String imgBase64=Base64FromByteArray(ExtractResource(Properties.Resources.products_tipp_110));
public static byte[] ExtractResource(Bitmap image)
{
MemoryStream ms = new MemoryStream();
image.Save(ms, ImageFormat.Png);
if (ms == null)
return null;
byte[] imageByteArray = ms.ToArray();;
return imageByteArray;
}
private static string Base64FromByteArray(byte[] image)
{
return "base64:" + Convert.ToBase64String(image);
}
Give this function Image and the format of Image, it will return you string.
public string ImageToBase64(Image image,
System.Drawing.Imaging.ImageFormat format)
{
using (MemoryStream 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;
}
}
I've found this sample code to convert an image to base 64, I'm not sure how to pass an image into it though. I want to be able to give a path to a specific directory. I've managed to find a file with this code:
byte[] ImageData = File.ReadAllBytes("storage/emulated/0/DCIM/Camera/img.jpg");
But I need to pass that into the following code.
public string ImageToBase64(Image image,
System.Drawing.Imaging.ImageFormat format)
{
using (MemoryStream 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;
}
}
Hope you can help. Thanks.
byte[] ImageData = File.ReadAllBytes(path_to_file);
string base64String = Convert.ToBase64String(ImageData);
i am trying to convert image from base64 . When i run this code i get the error ArgumentException is unhandeled parameter is not valid . Below is my code
public void LoadImage()
{
string bytes = "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";
Base64ToImage(bytes);
}
public Image Base64ToImage(string base64String)
{
// Convert Base64 String to byte[]
byte[] imageBytes = Convert.FromBase64String(base64String);
MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length);
// Convert byte[] to Image
ms.Write(imageBytes, 0, imageBytes.Length);
Image image1 = Image.FromStream(ms, true); // here error is generating
return image1;
}
I think that this line is more than enough, because it will create memory stream with image bytes.:
MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length);
So this one is not needed as all bytes are already in the stream:
ms.Write(imageBytes, 0, imageBytes.Length);
To position the stream at its start replace the previous line with seek call:
ms.Seek(0, SeekOrigin.Begin);
EDIT
Maybe it has something to do with string or the format used, because with image created in place it works well:
static public void LoadImage()
{
String bytes = CreateImageBase64();
Base64ToImage(bytes);
}
static public Image Base64ToImage(string base64String)
{
// Convert Base64 String to byte[]
byte[] imageBytes = Convert.FromBase64String(base64String);
MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length);
ms.Seek(0, SeekOrigin.Begin);
Image image1 = Image.FromStream(ms, true); // here error is generating
return image1;
}
static String CreateImageBase64()
{
//Create image
Image image = new Bitmap(3, 3);
//Save to stream
MemoryStream ms = new MemoryStream();
image.Save(ms, ImageFormat.Jpeg);
//Save to byte array
Byte[] imageBytes = new Byte[ms.Length];
ms.Seek(0, SeekOrigin.Begin);
ms.Read(imageBytes, 0, imageBytes.Length);
//Save to Base64
String base64Image = Convert.ToBase64String(imageBytes);
return base64Image;
}
...
LoadImage();
EDIT:
When I've used Encoding.ASCII.GetChars() on the array converted from Base64 string I got:
??\0sr\0*com.ups.ecis.core.shipments.ShipmentDigest\n^?2??\0 Z\0isABRReturnedinResponseZ\0isABRUserIneligibleZ\0isAIAZ\0isCN22NumberPresentZ\0isCN22RequestedZ\0isCombinedMIandLabe
It looks a bit strange for an image(of course if it does not contain enormous amounts of metadata). Maybe you can show the original xml. Who knows, the xml tag can be misnamed or misused.
Try This (If you want to set image directly to Image Control)
byte[] imageBytes = Convert.FromBase64String(base64string);
img.ImageUrl = "data:image/jpg;base64," + Convert.ToBase64String(imageBytes);
I'm trying to capture the screen and then convert it to a Base64 string. This is my code:
Rectangle bounds = Screen.GetBounds(Point.Empty);
Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height);
using (Graphics g = Graphics.FromImage(bitmap))
{
g.CopyFromScreen(Point.Empty, Point.Empty, bounds.Size);
}
// Convert the image to byte[]
System.IO.MemoryStream stream = new System.IO.MemoryStream();
bitmap.Save(stream, System.Drawing.Imaging.ImageFormat.Bmp);
byte[] imageBytes = stream.ToArray();
// Write the bytes (as a string) to the textbox
richTextBox1.Text = System.Text.Encoding.UTF8.GetString(imageBytes);
// Convert byte[] to Base64 String
string base64String = Convert.ToBase64String(imageBytes);
Using a richTextBox to debug, it shows:
BM6�~
So for some reason the bytes aren't correct which causes the base64String to become null. Any idea what I'm doing wrong? Thanks.
I found a solution for my issue:
Bitmap bImage = newImage; // Your Bitmap Image
System.IO.MemoryStream ms = new MemoryStream();
bImage.Save(ms, ImageFormat.Jpeg);
byte[] byteImage = ms.ToArray();
var SigBase64= Convert.ToBase64String(byteImage); // Get Base64
The characters you get by doing System.Text.Encoding.UTF8.GetString(imageBytes) will (almost certainly) contain unprintable characters. This could cause you to only see those few characters. If you first convert it to a base64-string, then it will contain only printable characters and can be shown in a text box:
// Convert byte[] to Base64 String
string base64String = Convert.ToBase64String(imageBytes);
// Write the bytes (as a Base64 string) to the textbox
richTextBox1.Text = base64String;
No need for byte[] ...just convert the stream directly (w/using constructs)
using (var ms = new MemoryStream())
{
using (var bitmap = new Bitmap(newImage))
{
bitmap.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
var SigBase64= Convert.ToBase64String(ms.GetBuffer()); //Get Base64
}
}