Welcome to OGeek Q&A Community for programmer and developer-Open, Learning and Share
Welcome To Ask or Share your Answers For Others

Categories

0 votes
113 views
in Technique[技术] by (71.8m points)

c# - Same Image, but different base64 string in Azure Web app and local machine

I have a very strange issue. I am converting Image to base64string in an asp.net web API hosted in Azure app service and getting the wrong image string.

If I run the code in the local machine I am getting the correct value.

public static string GetImageFromSharePointOnline(string imageUrl)
{
    try
    {
        using (var clientContext = CreateContext(URL))
        {
            clientContext.ExecutingWebRequest += ExecutingWebRequest;
            
            FileInformation fileInformation = null;
            Stream returnStream = new MemoryStream();
            int readCount;
            var buffer = new byte[8192];
            Uri image = new Uri(imageUrl);
            try
            {
                fileInformation = Microsoft.SharePoint.Client.File.OpenBinaryDirect(clientContext, image.AbsolutePath);
                while ((readCount = fileInformation.Stream.Read(buffer, 0, buffer.Length)) != 0)
                {
                    returnStream.Write(buffer, 0, readCount);
                }
            }
            catch (Exception ex) { }

            returnStream.Seek(0, SeekOrigin.Begin);
            
            return "data:image/" + GetFileExtensionFromUrl(imageUrl) + ";base64," + Convert.ToBase64String(buffer);
            // return Convert.ToBase64String(buffer);
        }
    }
    catch (Exception ex) { }
}

enter image description here

Azure web api output:

data:image/jpg;base64,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

与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…
Welcome To Ask or Share your Answers For Others

1 Reply

0 votes
by (71.8m points)

You're initializing a MemoryStream:

Stream returnStream = new MemoryStream();

(should be var returnStream = new MemoryStream();)
as the container for the bytes read from a Stream.

The Image bytes are read from the source Stream using a buffer:

var buffer = new byte[8192];

which is ok for a NetworkStream.
Assuming Uri image = new Uri(imageUrl); represents the same object in both environments, you the read a [buffer] number of bytes (which is the maximum value, the actual bytes read may be less than that) and write the bytes read - the value is stored in the readCount variable - to the MemoryStream:

try
{
    fileInformation = Microsoft.SharePoint.Client.File.OpenBinaryDirect(clientContext, image.AbsolutePath);
    while ((readCount = fileInformation.Stream.Read(buffer, 0, buffer.Length)) != 0)
    {
        returnStream.Write(buffer, 0, readCount);
    }
}

When the source Stream is read to end, the MemoryStream contains the Image bytes.
At this point, you want to convert the Image bytes to a Base64String.
Of course, you need to convert the content of your MemoryStream, returnStream, not the buffer content, which is only used as a temporary container for the bytes coming from the source Stream. So just change:

Convert.ToBase64String(buffer);

to:

Convert.ToBase64String(returnStream.ToArray());

Setting returnStream.Position = 0 before calling returnStream.ToArray() is not necessary in this context, but it doesn't hurt either.

Side note: those empty catch blocks don't serve you well. Either add logging features or remove.


与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…
OGeek|极客中国-欢迎来到极客的世界,一个免费开放的程序员编程交流平台!开放,进步,分享!让技术改变生活,让极客改变未来! Welcome to OGeek Q&A Community for programmer and developer-Open, Learning and Share
Click Here to Ask a Question

...