Thiết kế website giá rẻ

Question

So, I’m making a WinForms application and I need to convert an image to a Base64 string and add it to an xlsx data table. I then read this data and add it to the DataGridView. But on top of that I am also taking the Base64 string and converting it back to a picture and inserting it into a pictureBox(I have a gridBox). And the problem is that in the string
gridBox.BackgroundImage = Image.FromStream(memoryStream);
exception out of memory occurs. Base64 string is correct, I copied it and ran it through online converter. Maybe the size is too big, though not that big, maybe there are some other subtleties…. Please help me to understand. Thanks in advance!
Here are parts of the code:
Encoding:

<code>private void InsertToExcel(PictureBox gridBox, string excelFilePath, string sheetName)

{

Excel.Application excelApp = new Excel.Application();

excelApp.Visible = false;

Excel.Workbook workbook;

Excel.Worksheet worksheet;

workbook = excelApp.Workbooks.Open(excelFilePath);

worksheet = null;

foreach (Excel.Worksheet sheet in workbook.Sheets)

{

if (sheet.Name == sheetName)

{

worksheet = sheet;

}

Image image = gridBox.BackgroundImage; // here it is

byte[] imageBytes;

using (MemoryStream memoryStream = new MemoryStream())

{

image.Save(memoryStream, System.Drawing.Imaging.ImageFormat.Png);

imageBytes = memoryStream.ToArray();

}

string imageBase64 = Convert.ToBase64String(imageBytes);

worksheet.Cells[1, 1].Value = Update(_path);

worksheet.Cells[1, 2].Value = _minValue;

worksheet.Cells[1, 3].Value = imageBase64;

workbook.Close(true);

excelApp.Quit();

Marshal.ReleaseComObject(worksheet);

Marshal.ReleaseComObject(workbook);

Marshal.ReleaseComObject(excelApp);

}

</code>

<code>private void InsertToExcel(PictureBox gridBox, string excelFilePath, string sheetName) { Excel.Application excelApp = new Excel.Application(); excelApp.Visible = false; Excel.Workbook workbook; Excel.Worksheet worksheet; workbook = excelApp.Workbooks.Open(excelFilePath); worksheet = null; foreach (Excel.Worksheet sheet in workbook.Sheets) { if (sheet.Name == sheetName) { worksheet = sheet; } } Image image = gridBox.BackgroundImage; // here it is byte[] imageBytes; using (MemoryStream memoryStream = new MemoryStream()) { image.Save(memoryStream, System.Drawing.Imaging.ImageFormat.Png); imageBytes = memoryStream.ToArray(); } string imageBase64 = Convert.ToBase64String(imageBytes); worksheet.Cells[1, 1].Value = Update(_path); worksheet.Cells[1, 2].Value = _minValue; worksheet.Cells[1, 3].Value = imageBase64; workbook.Close(true); excelApp.Quit(); Marshal.ReleaseComObject(worksheet); Marshal.ReleaseComObject(workbook); Marshal.ReleaseComObject(excelApp); } </code>

private void InsertToExcel(PictureBox gridBox, string excelFilePath, string sheetName)
{
    Excel.Application excelApp = new Excel.Application();
    excelApp.Visible = false;

    Excel.Workbook workbook;
    Excel.Worksheet worksheet;

    workbook = excelApp.Workbooks.Open(excelFilePath);
    worksheet = null;

    foreach (Excel.Worksheet sheet in workbook.Sheets)
    {
        if (sheet.Name == sheetName)
        {
            worksheet = sheet;
        }
    }

    Image image = gridBox.BackgroundImage; // here it is

    byte[] imageBytes;

    using (MemoryStream memoryStream = new MemoryStream())
    {
        image.Save(memoryStream, System.Drawing.Imaging.ImageFormat.Png);
        imageBytes = memoryStream.ToArray();
    }

    string imageBase64 = Convert.ToBase64String(imageBytes);

    worksheet.Cells[1, 1].Value = Update(_path);
    worksheet.Cells[1, 2].Value = _minValue;
    worksheet.Cells[1, 3].Value = imageBase64;

    workbook.Close(true);
    excelApp.Quit();

    Marshal.ReleaseComObject(worksheet);
    Marshal.ReleaseComObject(workbook);
    Marshal.ReleaseComObject(excelApp);
}

Decoding:

<code>private void Search_Load(object sender, EventArgs e)

{

OpenExcelFile(filename);

}

private void OpenExcelFile(string path)

{

System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);

FileStream stream = File.Open(path, FileMode.Open, FileAccess.Read);

IExcelDataReader reader = ExcelReaderFactory.CreateReader(stream);

DataSet db = reader.AsDataSet(new ExcelDataSetConfiguration()

{

ConfigureDataTable = (x) => new ExcelDataTableConfiguration()

{

UseHeaderRow = false

}

});

tableCollection = db.Tables;

comboBox.Items.Clear();

foreach (DataTable table in tableCollection)

{

comboBox.Items.Add(table.TableName);

}

comboBox.SelectedIndex = 0;

stream.Close();

}

private void comboBox_Click(object sender, EventArgs e)

{

}

private void comboBox_SelectedIndexChanged(object sender, EventArgs e)

{

DataTable table = tableCollection[Convert.ToString(comboBox.SelectedItem)];

gridView.DataSource = table;

byte[] imageData = Convert.FromBase64String((string)table.Rows[0][2]);

using (MemoryStream memoryStream = new MemoryStream(imageData))

{

gridBox.BackgroundImage = Image.FromStream(memoryStream); // Here is the problem

}

</code>

<code>private void Search_Load(object sender, EventArgs e) { OpenExcelFile(filename); } private void OpenExcelFile(string path) { System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance); FileStream stream = File.Open(path, FileMode.Open, FileAccess.Read); IExcelDataReader reader = ExcelReaderFactory.CreateReader(stream); DataSet db = reader.AsDataSet(new ExcelDataSetConfiguration() { ConfigureDataTable = (x) => new ExcelDataTableConfiguration() { UseHeaderRow = false } }); tableCollection = db.Tables; comboBox.Items.Clear(); foreach (DataTable table in tableCollection) { comboBox.Items.Add(table.TableName); } comboBox.SelectedIndex = 0; stream.Close(); } private void comboBox_Click(object sender, EventArgs e) { } private void comboBox_SelectedIndexChanged(object sender, EventArgs e) { DataTable table = tableCollection[Convert.ToString(comboBox.SelectedItem)]; gridView.DataSource = table; byte[] imageData = Convert.FromBase64String((string)table.Rows[0][2]); using (MemoryStream memoryStream = new MemoryStream(imageData)) { gridBox.BackgroundImage = Image.FromStream(memoryStream); // Here is the problem } } </code>

private void Search_Load(object sender, EventArgs e)
{
    OpenExcelFile(filename);
}

private void OpenExcelFile(string path)
{
    System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);
    FileStream stream = File.Open(path, FileMode.Open, FileAccess.Read);


    IExcelDataReader reader = ExcelReaderFactory.CreateReader(stream);
    DataSet db = reader.AsDataSet(new ExcelDataSetConfiguration()
    {
        ConfigureDataTable = (x) => new ExcelDataTableConfiguration()
        {
            UseHeaderRow = false
        }
    });

    tableCollection = db.Tables;

    comboBox.Items.Clear();

    foreach (DataTable table in tableCollection)
    {
        comboBox.Items.Add(table.TableName);
    }

    comboBox.SelectedIndex = 0;

    stream.Close();
}

private void comboBox_Click(object sender, EventArgs e)
{

}

private void comboBox_SelectedIndexChanged(object sender, EventArgs e)
{
    DataTable table = tableCollection[Convert.ToString(comboBox.SelectedItem)];
    gridView.DataSource = table;


    byte[] imageData = Convert.FromBase64String((string)table.Rows[0][2]);

    using (MemoryStream memoryStream = new MemoryStream(imageData)) 
    {
        gridBox.BackgroundImage = Image.FromStream(memoryStream); // Here is the problem
    }

}

Example of an Image in Base64:
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

I tried to just optimize other parts of my App, but here I tried practically nothing, just checked that Encoding works correctly.

Thiết kế website giá rẻ

Danh mục

Out of memopy. C#