一个直接生成EXCEL代码

bashan bashan 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 1.4k累计阅读 1.4k平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄24年
关注
原创 最新推荐文章于 2026-06-22 13:35:54 发布 1.4k 阅读 AI 写同款· GEO 优化 ›
Excel文件读取解析 游戏中很多数据都是策划配置的Excel数据表，在使用中，我们一般会转化成csv文件，但是每改一次都要转一次也是麻烦，不如直接将Excel读取出来。怎么解析呢，我们需要使用到一个插件，插件地址如下 http://exceldatareader.codeplex.com/ 可以下载最新版引入到工程。在一个就是鉴于中文编码问题，这里的Excel要求是xlsx格式的，这样读出来的数据就不会出现乱码问题。 阅读详情

整了点东西,很想与大家分享,可是好不容易写了,又没发成功 

不想写了,直接把代码贴出来吧,有空了再写.

using System.Text;
using System.IO;
using System;
namespace ExcelComm
{
    public class cExcelFile
    {
        public enum ValueTypes
        {
            xlsInteger = 0,
            xlsNumber = 1,
            xlsText = 2
        }
        public enum CellAlignment
        {
            xlsGeneralAlign = 0,
            xlsLeftAlign = 1,
            xlsCentreAlign = 2,
            xlsRightAlign = 3,
            xlsFillCell = 4,
            xlsLeftBorder = 8,
            xlsRightBorder = 16,
            xlsTopBorder = 32,
            xlsBottomBorder = 64,
            xlsShaded = 128
        }
        public enum CellFont
        {
            xlsFont0 = 0,
            xlsFont1 = 64,
            xlsFont2 = 128,
            xlsFont3 = 192
        }
        public enum CellHiddenLocked
        {
            xlsNormal = 0,
            xlsLocked = 64,
            xlsHidden = 128
        }
        public enum MarginTypes
        {
            xlsLeftMargin = 38,
            xlsRightMargin = 39,
            xlsTopMargin = 40,
            xlsBottomMargin = 41
        }
        public enum FontFormatting
        {
            xlsNoFormat = 0,
            xlsBold = 1,
            xlsItalic = 2,
            xlsUnderline = 4,
            xlsStrikeout = 8
        }
        public struct FONT_RECORD
        {
            public short opcode;
            public short length;
            public short FontHeight;
            public byte FontAttributes1;
            public byte FontAttributes2;
            public byte FontNameLength;
        }
        public struct PASSWORD_RECORD
        {
            public short opcode;
            public short length;
        }
        public struct HEADER_FOOTER_RECORD
        {
            public short opcode;
            public short length;
            public byte TextLength;
        }
        public struct PROTECT_SPREADSHEET_RECORD
        {
            public short opcode;
            public short length;
            public short Protect;
        }
        public struct FORMAT_COUNT_RECORD
        {
            public short opcode;
            public short length;
            public short Count;
        }
        public struct FORMAT_RECORD
        {
            public short opcode;
            public short length;
            public byte FormatLenght;
        }
        public struct COLWIDTH_RECORD
        {
            public short opcode;
            public short length;
            public byte col1;
            public byte col2;
            public short ColumnWidth;
        }
        public struct BEG_FILE_RECORD
        {
            public short opcode;
            public short length;
            public short version;
            public short ftype;
        }
        public struct END_FILE_RECORD
        {
            public short opcode;
            public short length;
        }
        public struct PRINT_GRIDLINES_RECORD
        {
            public short opcode;
            public short length;
            public short PrintFlag;
        }
        public struct tInteger
        {
            public short opcode;
            public short length;
            public short row;
            public short col;
            public byte rgbAttr1;
            public byte rgbAttr2;
            public byte rgbAttr3;
            public short intValue;
        }
        public struct tNumber
        {
            public short opcode;
            public short length;
            public short row;
            public short col;
            public byte rgbAttr1;
            public byte rgbAttr2;
            public byte rgbAttr3;
            public double NumberValue;
        }
        public struct tText
        {
            public short opcode;
            public short length;
            public short row;
            public short col;
            public byte rgbAttr1;
            public byte rgbAttr2;
            public byte rgbAttr3;
            public byte TextLength;
        }
        public struct MARGIN_RECORD_LAYOUT
        {
            public short opcode;
            public short length;
            public double MarginValue;
        }
        public struct HPAGE_BREAK_RECORD
        {
            public short opcode;
            public short length;
            public short NumPageBreaks;
        }
        public struct DEF_ROWHEIGHT_RECORD
        {
            public int opcode;
            public int length;
            public int RowHeight;
        }
        public struct ROW_HEIGHT_RECORD
        {
            public int opcode;
            public int length;
            public int RowNumber;
            public int FirstColumn;
            public int LastColumn;
            public int RowHeight;
            public int linternal;
            public byte DefaultAttributes;
            public int FileOffset;
            public byte rgbAttr1;
            public byte rgbAttr2;
            public byte rgbAttr3;
        }
        [System.Runtime.InteropServices.DllImport("kernel32", EntryPoint = "RtlMoveMemory")]
        private static extern void CopyMemory(ref string lpvDest, ref short lpvSource, int cbCopy);
        private FileStream fs;
        private BEG_FILE_RECORD m_udtBEG_FILE_MARKER;
        private END_FILE_RECORD m_udtEND_FILE_MARKER;
        private HPAGE_BREAK_RECORD m_udtHORIZ_PAGE_BREAK;
        private short[] m_shtHorizPageBreakRows;
        private short m_shtNumHorizPageBreaks;

        public void FilePut(short data)
        {
            byte[] value = BitConverter.GetBytes(data);
            fs.Write(value, 0, value.Length);
        }
        public void FilePut(byte data)
        {
            fs.WriteByte(data);
        }
        public void FilePut(int data)
        {
            byte[] value = BitConverter.GetBytes(data);
            fs.Write(value, 0, value.Length);
        }
        public void FilePut(double data)
        {
            byte[] value = BitConverter.GetBytes(data);
            fs.Write(value, 0, value.Length);
        }
        public void FilePut(string data)
        {
            byte[] value = System.Text.Encoding.Default.GetBytes(data);
            fs.Write(value, 0, value.Length);
        }
        public void FilePut(byte[] data)
        {
            fs.Write(data, 0, data.Length);
        }
        public bool PrintGridLines
        {
            set
            {
                try
                {
                    PRINT_GRIDLINES_RECORD GRIDLINES_RECORD;
                    GRIDLINES_RECORD.opcode = 43;
                    GRIDLINES_RECORD.length = 2;
                    if (value == true)
                    {
                        GRIDLINES_RECORD.PrintFlag = 1;
                    }
                    else
                    {
                        GRIDLINES_RECORD.PrintFlag = 0;
                    }
                    FilePut(GRIDLINES_RECORD.opcode);
                    FilePut(GRIDLINES_RECORD.length);
                    FilePut(GRIDLINES_RECORD.PrintFlag);
                }
                catch (Exception ex)
                {
                }
            }
        }

        public bool ProtectSpreadsheet
        {
            set
            {
                try
                {
                    PROTECT_SPREADSHEET_RECORD PROTECT_RECORD;
                    PROTECT_RECORD.opcode = 18;
                    PROTECT_RECORD.length = 2;
                    if (value == true)
                    {
                        PROTECT_RECORD.Protect = 1;
                    }
                    else
                    {
                        PROTECT_RECORD.Protect = 0;
                    }
                    FilePut(PROTECT_RECORD.opcode);
                    FilePut(PROTECT_RECORD.length);
                    FilePut(PROTECT_RECORD.Protect);

                }
                catch (Exception ex)
                {
                }
            }
        }

        public void CreateFile(string strFileName)
        {

            try
            {
                if (File.Exists(strFileName))
                {
                    File.SetAttributes(strFileName, FileAttributes.Normal);
                    File.Delete(strFileName);
                }
                //m_shtFileNumber = FreeFile();
                //FileOpen(m_shtFileNumber, strFileName, OpenMode.Binary);
                fs = new FileStream(strFileName, FileMode.Create, FileAccess.Write);
                FilePut(m_udtBEG_FILE_MARKER.opcode);
                FilePut(m_udtBEG_FILE_MARKER.length);
                FilePut(m_udtBEG_FILE_MARKER.version);
                FilePut(m_udtBEG_FILE_MARKER.ftype);

                WriteDefaultFormats();
                m_shtHorizPageBreakRows = new short[1] { 0 };
                m_shtNumHorizPageBreaks = 0;


            }
            catch (Exception ex)
            {

            }
        }

        public void CloseFile()
        {
            try
            {
                short lTemp;
                if (m_shtNumHorizPageBreaks > 0)
                {
                    for (int lLoop1 = m_shtHorizPageBreakRows.GetUpperBound(0); lLoop1 >= m_shtHorizPageBreakRows.GetLowerBound(0); lLoop1--)
                    {
                        for (int lLoop2 = m_shtHorizPageBreakRows.GetLowerBound(0) + 1; lLoop2 <= lLoop1; lLoop2++)
                        {
                            if (m_shtHorizPageBreakRows[lLoop2 - 1] > m_shtHorizPageBreakRows[lLoop2])
                            {
                                lTemp = m_shtHorizPageBreakRows[lLoop2 - 1];
                                m_shtHorizPageBreakRows[lLoop2 - 1] = m_shtHorizPageBreakRows[lLoop2];
                                m_shtHorizPageBreakRows[lLoop2] = lTemp;
                            }
                        }
                    }
                    m_udtHORIZ_PAGE_BREAK.opcode = 27;
                    m_udtHORIZ_PAGE_BREAK.length = (short)(2 + (m_shtNumHorizPageBreaks * 2));
                    m_udtHORIZ_PAGE_BREAK.NumPageBreaks = m_shtNumHorizPageBreaks;
                    FilePut(m_udtHORIZ_PAGE_BREAK.opcode);
                    FilePut(m_udtHORIZ_PAGE_BREAK.length);
                    FilePut(m_udtHORIZ_PAGE_BREAK.NumPageBreaks);

                    for (int x = 0; x < m_shtHorizPageBreakRows.GetUpperBound(0); x++)
                    {
                        FilePut(MKI(m_shtHorizPageBreakRows[x]));
                    }
                }
                FilePut(m_udtEND_FILE_MARKER.opcode);
                FilePut(m_udtEND_FILE_MARKER.length);
                fs.Close();

            }
            catch (Exception ex)
            {

            }
        }

        private void Init()
        {
            m_udtBEG_FILE_MARKER.opcode = 9;
            m_udtBEG_FILE_MARKER.length = 4;
            m_udtBEG_FILE_MARKER.version = 2;
            m_udtBEG_FILE_MARKER.ftype = 10;
            m_udtEND_FILE_MARKER.opcode = 10;
        }

        public cExcelFile()
        {
            //base.New();
            Init();
        }

        public void InsertHorizPageBreak(int lrow)
        {
            short row;
           
           
                if (lrow > 32767 || lrow < 0) row = 0;
                else row = (short)(lrow - 1);
                m_shtNumHorizPageBreaks = (short)(m_shtNumHorizPageBreaks + 1);
                short[] temp = m_shtHorizPageBreakRows;
                m_shtHorizPageBreakRows = new short[m_shtNumHorizPageBreaks + 1];
                int i = 0;
                while (i < temp.Length)
                {
                    m_shtHorizPageBreakRows[i] = temp[i];
                    i++;
                }
                m_shtHorizPageBreakRows[m_shtNumHorizPageBreaks] = row;
           
        }

        public void WriteValue(ValueTypes ValueType, CellFont CellFontUsed, CellAlignment Alignment, CellHiddenLocked HiddenLocked, int lrow, int lcol, object Value)
        {
            WriteValue(ValueType, CellFontUsed, Alignment, HiddenLocked, lrow, lcol, Value, 0);
        }
        public void WriteValue( ValueTypes ValueType, CellFont CellFontUsed,CellAlignment Alignment, CellHiddenLocked HiddenLocked, int lrow, int lcol, object Value, int CellFormat)
        {
            short l;
            string st;
            short col;
            short row;
            try
            {
                tInteger INTEGER_RECORD;
                tNumber NUMBER_RECORD;
                byte b;
                tText TEXT_RECORD;
                if (lrow > 32767)
                {
                    row = System.Convert.ToInt16(lrow - 65536);
                }
                else
                {
                    row = (short)(lrow - (short)1);
                }
                if (lcol > 32767)
                {
                    col = System.Convert.ToInt16(lcol - 65536);
                }
                else
                {
                    col = (short)(lcol - (short)1);
                }
                if (ValueType == ValueTypes.xlsInteger)
                {
                    INTEGER_RECORD.opcode = 2;
                    INTEGER_RECORD.length = 9;
                    INTEGER_RECORD.row = row;
                    INTEGER_RECORD.col = col;
                    INTEGER_RECORD.rgbAttr1 = System.Convert.ToByte(HiddenLocked);
                    INTEGER_RECORD.rgbAttr2 = System.Convert.ToByte(CellFontUsed + CellFormat);
                    INTEGER_RECORD.rgbAttr3 = System.Convert.ToByte(Alignment);
                    INTEGER_RECORD.intValue = System.Convert.ToInt16(Value);
                    FilePut(INTEGER_RECORD.opcode);
                    FilePut(INTEGER_RECORD.length);
                    FilePut(INTEGER_RECORD.row);
                    FilePut(INTEGER_RECORD.col);
                    FilePut(INTEGER_RECORD.rgbAttr1);
                    FilePut(INTEGER_RECORD.rgbAttr2);
                    FilePut(INTEGER_RECORD.rgbAttr3);
                    FilePut(INTEGER_RECORD.intValue);
                }
                else if (ValueType == ValueTypes.xlsNumber)
                {
                    NUMBER_RECORD.opcode = 3;
                    NUMBER_RECORD.length = 15;
                    NUMBER_RECORD.row = row;
                    NUMBER_RECORD.col = col;
                    NUMBER_RECORD.rgbAttr1 = System.Convert.ToByte(HiddenLocked);
                    NUMBER_RECORD.rgbAttr2 = System.Convert.ToByte(CellFontUsed + CellFormat);
                    NUMBER_RECORD.rgbAttr3 = System.Convert.ToByte(Alignment);
                    NUMBER_RECORD.NumberValue = System.Convert.ToDouble(Value);
                    FilePut(NUMBER_RECORD.opcode);
                    FilePut(NUMBER_RECORD.length);
                    FilePut(NUMBER_RECORD.row);
                    FilePut(NUMBER_RECORD.col);
                    FilePut(NUMBER_RECORD.rgbAttr1);
                    FilePut(NUMBER_RECORD.rgbAttr2);
                    FilePut(NUMBER_RECORD.rgbAttr3);
                    FilePut(NUMBER_RECORD.NumberValue);
                }
                else if (ValueType == ValueTypes.xlsText)
                {
                    st = ((string)(Value));
                    l = (short)GetLength(st);
                    TEXT_RECORD.opcode = 4;
                    TEXT_RECORD.length = 10;
                    TEXT_RECORD.TextLength = (byte)l;
                    TEXT_RECORD.length = (short)(8 + l);
                    TEXT_RECORD.row = row;
                    TEXT_RECORD.col = col;
                    TEXT_RECORD.rgbAttr1 = System.Convert.ToByte(HiddenLocked);
                    TEXT_RECORD.rgbAttr2 = System.Convert.ToByte(CellFontUsed + CellFormat);
                    TEXT_RECORD.rgbAttr3 = System.Convert.ToByte(Alignment);
                    FilePut(TEXT_RECORD.opcode);
                    FilePut(TEXT_RECORD.length);
                    FilePut(TEXT_RECORD.row);
                    FilePut(TEXT_RECORD.col);
                    FilePut(TEXT_RECORD.rgbAttr1);
                    FilePut(TEXT_RECORD.rgbAttr2);
                    FilePut(TEXT_RECORD.rgbAttr3);
                    FilePut(TEXT_RECORD.TextLength);
                    FilePut(st);
                }

            }
            catch (Exception ex)
            {

            }
        }

        public void SetMargin(MarginTypes Margin, double MarginValue)
        {
            try
            {
                MARGIN_RECORD_LAYOUT MarginRecord;
                MarginRecord.opcode = (short)Margin;
                MarginRecord.length = 8;
                MarginRecord.MarginValue = MarginValue;
                FilePut(MarginRecord.opcode);
                FilePut(MarginRecord.length);
                FilePut(MarginRecord.MarginValue);

            }
            catch (Exception ex)
            {
            }
        }

        public void SetColumnWidth(byte FirstColumn, byte LastColumn, short WidthValue)
        {
            try
            {
                COLWIDTH_RECORD COLWIDTH;
                COLWIDTH.opcode = 36;
                COLWIDTH.length = 4;
                COLWIDTH.col1 = (byte)(FirstColumn - 1);
                COLWIDTH.col2 = (byte)(LastColumn - 1);
                COLWIDTH.ColumnWidth = (short)(WidthValue * 256);
                FilePut(COLWIDTH.opcode);
                FilePut(COLWIDTH.length);
                FilePut(COLWIDTH.col1);
                FilePut(COLWIDTH.col2);
                FilePut(COLWIDTH.ColumnWidth);

            }
            catch (Exception ex)
            {

            }
        }

        public void SetFont(string FontName, short FontHeight, FontFormatting FontFormat)
        {
            short l;
            try
            {
                FONT_RECORD FONTNAME_RECORD;
                l = (short)GetLength(FontName);
                FONTNAME_RECORD.opcode = 49;
                FONTNAME_RECORD.length = (short)(5 + l);
                FONTNAME_RECORD.FontHeight = (short)(FontHeight * 20);
                FONTNAME_RECORD.FontAttributes1 = System.Convert.ToByte(FontFormat);
                FONTNAME_RECORD.FontAttributes2 = System.Convert.ToByte(0);
                FONTNAME_RECORD.FontNameLength = System.Convert.ToByte(l);
                FilePut(FONTNAME_RECORD.opcode);
                FilePut(FONTNAME_RECORD.length);
                FilePut(FONTNAME_RECORD.FontHeight);
                FilePut(FONTNAME_RECORD.FontAttributes1);
                FilePut(FONTNAME_RECORD.FontAttributes2);
                FilePut(FONTNAME_RECORD.FontNameLength);
                FilePut(FontName);
            }
            catch
            {
            }
        }

        public void SetHeader(string HeaderText)
        {
            short l;
            try
            {
                HEADER_FOOTER_RECORD HEADER_RECORD;
                l = (short)GetLength(HeaderText);
                HEADER_RECORD.opcode = 20;
                HEADER_RECORD.length = (short)(1 + l);
                HEADER_RECORD.TextLength = System.Convert.ToByte(l);

                FilePut(HEADER_RECORD.opcode);
                FilePut(HEADER_RECORD.length);
                FilePut(HEADER_RECORD.TextLength);
                FilePut(HeaderText);

            }
            catch
            {

            }
        }

        public void SetFooter(string FooterText)
        {
            short l;
            try
            {
                HEADER_FOOTER_RECORD FOOTER_RECORD;
                l = (short)GetLength(FooterText);
                FOOTER_RECORD.opcode = 21;
                FOOTER_RECORD.length = (short)(1 + l);
                FOOTER_RECORD.TextLength = System.Convert.ToByte(l);

                FilePut(FOOTER_RECORD.opcode);
                FilePut(FOOTER_RECORD.length);
                FilePut(FOOTER_RECORD.TextLength);
                FilePut(FooterText);

            }
            catch (Exception ex)
            {

            }
        }

        public void SetFilePassword(string PasswordText)
        {
            short l;
            try
            {
                PASSWORD_RECORD FILE_PASSWORD_RECORD;
                l = (short)GetLength(PasswordText);
                FILE_PASSWORD_RECORD.opcode = 47;
                FILE_PASSWORD_RECORD.length = l;
                FilePut(FILE_PASSWORD_RECORD.opcode);
                FilePut(FILE_PASSWORD_RECORD.length);
                FilePut(PasswordText);

            }
            catch (Exception ex)
            {
            }
        }

        private void WriteDefaultFormats()
        {
            FORMAT_COUNT_RECORD cFORMAT_COUNT_RECORD;
            FORMAT_RECORD cFORMAT_RECORD;

            string[] aFormat = new string[24];
            int l;
            string q = "/"";
            aFormat[0] = "General";
            aFormat[1] = "0";
            aFormat[2] = "0.00";
            aFormat[3] = "#,##0";
            aFormat[4] = "#,##0.00";
            aFormat[5] = "#,##0// " + q + "$" + q + ";//-#,##0// " + q + "$" + q;
            aFormat[6] = "#,##0// " + q + "$" + q + ";[Red]//-#,##0// " + q + "$" + q;
            aFormat[7] = "#,##0.00// " + q + "$" + q + ";//-#,##0.00// " + q + "$" + q;
            aFormat[8] = "#,##0.00// " + q + "$" + q + ";[Red]//-#,##0.00// " + q + "$" + q;
            aFormat[9] = "0%";
            aFormat[10] = "0.00%";
            aFormat[11] = "0.00E+00";
            aFormat[12] = "dd/mm/yy";
            aFormat[13] = "dd/// mmm// yy";
            aFormat[14] = "dd/// mmm";
            aFormat[15] = "mmm// yy";
            aFormat[16] = "h:mm// AM/PM";
            aFormat[17] = "h:mm:ss// AM/PM";
            aFormat[18] = "hh:mm";
            aFormat[19] = "hh:mm:ss";
            aFormat[20] = "dd/mm/yy// hh:mm";
            aFormat[21] = "##0.0E+0";
            aFormat[22] = "mm:ss";
            aFormat[23] = "@";
            cFORMAT_COUNT_RECORD.opcode = 31;
            cFORMAT_COUNT_RECORD.length = 2;
            cFORMAT_COUNT_RECORD.Count = System.Convert.ToInt16(aFormat.GetUpperBound(0));
            FilePut(cFORMAT_COUNT_RECORD.opcode);
            FilePut(cFORMAT_COUNT_RECORD.length);
            FilePut(cFORMAT_COUNT_RECORD.Count);

            for (int lIndex = aFormat.GetLowerBound(0); lIndex <= aFormat.GetUpperBound(0); lIndex++)
            {
                l = aFormat[lIndex].Length;
                cFORMAT_RECORD.opcode = 30;
                cFORMAT_RECORD.length = System.Convert.ToInt16(l + 1);
                cFORMAT_RECORD.FormatLenght = (byte)l;
                FilePut(cFORMAT_RECORD.opcode);
                FilePut(cFORMAT_RECORD.length);
                FilePut(cFORMAT_RECORD.FormatLenght);
                //for (int a = 1; a <= l; a++)
                //{
                //    int b = Convert.ToInt32(aFormat[lIndex].Substring(a, 1));
                //    //Mid(aFormat[lIndex], a, 1);
                //    FilePut(aFormat[lIndex]);
                //}
                FilePut(aFormat[lIndex]);
            }
        }

        private byte[] MKI(short x)
        {
            //string temp;
            //temp = Space(2);
            //CopyMemory(temp, x, 2);
            //MKI = temp;
            return BitConverter.GetBytes(x);
        }

        private int GetLength(string strText)
        {
            return Encoding.Default.GetBytes(strText).Length;
        }

        public void SetDefaultRowHeight(int HeightValue)
        {
            try
            {
                DEF_ROWHEIGHT_RECORD DEFHEIGHT;
                DEFHEIGHT.opcode = 37;
                DEFHEIGHT.length = 2;
                DEFHEIGHT.RowHeight = HeightValue * 20;
                FilePut(DEFHEIGHT.opcode);
                FilePut(DEFHEIGHT.length);
                FilePut(DEFHEIGHT.RowHeight);

            }
            catch
            {

            }
        }

        public void SetRowHeight(int Row, short HeightValue)
        {
            int o_intRow;
            try
            {
                if (Row > 32767)
                {
                    o_intRow = System.Convert.ToInt32(Row - 65536);
                }
                else
                {
                    o_intRow = System.Convert.ToInt32(Row) - 1;
                }
                ROW_HEIGHT_RECORD ROWHEIGHTREC;
                ROWHEIGHTREC.opcode = 8;
                ROWHEIGHTREC.length = 16;
                ROWHEIGHTREC.RowNumber = o_intRow;
                ROWHEIGHTREC.FirstColumn = 0;
                ROWHEIGHTREC.LastColumn = 256;
                ROWHEIGHTREC.RowHeight = HeightValue * 20;
                ROWHEIGHTREC.linternal = 0;
                ROWHEIGHTREC.DefaultAttributes = 0;
                ROWHEIGHTREC.FileOffset = 0;
                ROWHEIGHTREC.rgbAttr1 = 0;
                ROWHEIGHTREC.rgbAttr2 = 0;
                ROWHEIGHTREC.rgbAttr3 = 0;

                FilePut(ROWHEIGHTREC.opcode);
                FilePut(ROWHEIGHTREC.length);
                FilePut(ROWHEIGHTREC.RowNumber);
                FilePut(ROWHEIGHTREC.FirstColumn);
                FilePut(ROWHEIGHTREC.LastColumn);
                FilePut(ROWHEIGHTREC.RowHeight);
                FilePut(ROWHEIGHTREC.linternal);
                FilePut(ROWHEIGHTREC.DefaultAttributes);
                FilePut(ROWHEIGHTREC.FileOffset);
                FilePut(ROWHEIGHTREC.rgbAttr1);
                FilePut(ROWHEIGHTREC.rgbAttr2);
                FilePut(ROWHEIGHTREC.rgbAttr3);

            }
            catch
            {

            }
        }
    }

}

收录于
C#

当前文章被收录于：

C#
5 篇文章 0 人学习
订阅专栏 查看详情
标签
#excel #integer #byte #alignment #exception
#struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GemBox.ExcelLite：.NET中处理Excel的高效开源控件 本文还有配套的精品资源，点击获取 简介：GemBox.ExcelLite是一个开源.NET库，允许开发者在C#和VB.NET项目中无需Microsoft Excel即可高效处理Excel文件。该控件支持XLS和XLSX格式，提供了丰富的API来操作单元格、行、列等，并支持读写数据、应用样式、计算公式、插入图表和图像，以及导出为PDF和其他格式。此外，它具有良好的性能，跨平台... 阅读详情

相关推荐

接口开发时，利用Excel快速生成实体类

接口开发的时候，直接把接口文档拷到Excel，然后利用Excel快速生成实体类，包含注释内容 ，可以节省大部分重复劳动

【Unity】解析Excel数据，并自动创建对应的C#类

参考：Unity C#配置表工具 解析流程： 1. 配置Excel 2. 读取解析Excel (引用Excel.dll, ICSharpCode.SharpZipLib.dll) 3. 重新整理解析到的数据 4. 创建Excel对应的C#类，声明变量 5. 在类的构建函数中给变量赋值 6. 保存类文件，可在游戏直接使用 优点： 1. 每个Excel对应一个类，使用灵活......

萧然 3320

导出到Excel的C#类（不需要安装Excel）

不需要电脑安装Excel就能将数据导出成真正的Excel文件，很方便。两条语句就能搞定。

GemBox.ExcelLite.dll导出到Excel

利用GemBox.ExcelLite.dll脱离Excel环境，把DataGridView数据导出到Excel文件。 public void DataGridView2Excel_GemBox(DataGridView dgv) { #region 导出前判断 //行数必须大于0 if (dgv....

weixin_33921089的博客 217

GemBox.ExcelLite开源操作Excel控件

net中的GemBox.ExcelLite开源操作Excel控件

GemBox.ExcelLite.dll

该组件是个超完美的报表解决方案,支持在同个Excel中的多个sheet,这样就不受Excel(2003 )仅能放65535条记录的限制了.支持模板。此版本已破解。

GemBox.ExcelLite "完美"的导入Excel的控件(补充)

在《GemBox.ExcelLite "完美"的导入Excel的控件》中说到该控件不支持数据集的导入。 这几天，看到网上有很多Helper的代码来辅助实现包括这个的一系列功能。 代码如下： 代码 1 using System; 2 using System.Collections.Generic; 3 using System.Text; 4 using Syst...

weixin_30633405的博客 357

Excel生成Proto类、Proto管理类、Bytes文件 C#源码

1、通过Excel生成Proto文件。 2、通过Proto文件创建Proto类。 3、通过Proto类，序列化出Bytes文件。 （1）差异化打表，加快打表速度。 （2）强力打表，以上三个流程全部走一遍。 (3) 只更新 Bytes 数据文件 4、自定义Proto读取管理类（可自己实现）。 5、根据Excel文件生成C#对应枚举，加快开发。 6、单独处理网络proto文件，创建Proto类

以php为例直接用html生成excel文件

以前都用PHPExcel等工具来生成Excel，功能很强大，但是有时我们只是要一个简单的数据输出而已，再使用那些就有些繁琐了。最近碰巧发现了一个十分简便的方法，就此记录下来。这里主要是使用了Content-Type来实现我们想要的功能，然后使用PHP等编程语言来取得我们想要的数据。在html的header中加入以下两句就能使你的网页内容以.xls附件形式直接下载下来header("Content-t

Cooldiok的博客 6591

博图HMI多语言文本列表一键生成攻略：从Excel模板到TIA Portal的完整流程

本文详细介绍了如何利用Excel模板和TIA Portal API实现博图HMI多语言文本列表的一键生成。通过标准化Excel模板设计、解析TIA Portal的XML结构，并结合C#代码实现自动化导入，大幅提升多语言项目的开发效率。特别适用于需要支持多语言版本的自动化设备HMI界面开发。

weixin_26934905的博客 218

RK3568/RK3588之修改8250驱动实现RS485收发的自动切换

在串口发送前，若为485，则将控制引脚拉为发送状态，在发送后，循环查看是否发送完成，若发送完成则将引脚置回读状态，如此一来，就能实现在内核测控制方向切换，而不会因为延时造成数据丢失，经过测试此办法可行。全部修改完成后，重新编译生成内核文件和设备树文件，烧写到板子上即可。

哒宰的博客 3111

.net core导出Excel(html格式直接导出)

.net导出Excel有很多方法, 用过直接生成二进制xls的方式, 经过长期的测试发现,不是很稳定.生成的xls文件经常打不开. 其中最稳定的方法当属Html格式的导出, 也就是直接拼接 xml字符串. 强烈建议是用输出html的方式导出Excel 为了简化和灵活的生成html格式的excel字符串. 我采用了RazorEngine.Core 模板引擎, 用它生成excel非常的灵活. 这样做的好处是可以自己灵活的定义表头… 一般应用都是要自定义表头的…虽然不及直接编辑xls文件方便, 但是胜在稳定性远超

走错路的程序员 2051

AD936x Evaluation Software 详细配置

作者：ShownSun 工作室：时沿科技 文章目录AD936x Evaluation Software详细配置1 系统概述2 AD9361 Wireless Transceiver Evaluation Setup2.1 标签描述2.2 用户参数2.3详细配置3 AD936x RF Wizard3.1 标签描述3.2 用户参数3.3 详细配置4 AD936x Digital Filter Wizard4.1 标签描述4.1.1 时钟配置4.1.2 滤波器配置4.1.3 接收滤波器配置4.1.4 发射滤..

ShownSun博客 5192

EXCEL表格中直接使用vb6创建的dll中的自定义函数

在EXCEL单元格中直接使用由VB6.0创建的dll中的自定义函数

阿亮的专栏 3109

中移物联ML307C模组OPENCPU开发环境搭建全攻略

本文详细介绍了中移物联ML307C模组OPENCPU开发环境搭建的全过程。从OPENCPU模式的核心优势解析，到SDK获取、Python与scons工具安装，再到解读SDK目录结构与实战编译命令，最后提供常见问题避坑指南，帮助开发者快速构建高效的物联网应用编译环境。

weixin_29168393的博客 741

【SABRE 3D, SABRE 3DxT,LAM设备】2025年9月13日-安全配置-准备工作

请遵循本规程将SABRE 3D/3DxT/3D Scimitar系统设置为安全配置，以便能够在电镀单元、APT模块、XMM（或SRD）模块、工厂接口（FI）外壳或中央通道内部及周边区域执行作业p104-p117。在生产过程中暂停调度程序存在一定风险：若待维护模块未离线且在其他模块完成处理前重启调度程序，可能对生产晶圆造成影响。维护人员需特别注意电镀模块内的晶圆状态，并尽可能快速地恢复调度程序。确认待维护模块内无晶圆滞留暂停调度程序并将相应模块设置为离线状态打开模块检修门并关闭安全盖板（槽位）

weixin_46735260的博客 1363

PHP生成Excel，然后另存为的方法

1.以下方法是直接下载（显示另存为）一个test1.xls的Excel表。 &lt;? header("Content-type:application/xls"); header("Content-Disposition:attachment;filename=test1.xls"); echo "test1/t"; echo "test2/t/n"; echo "te...

zhenzhong 247

30天入门 SAP BTP 开发系列之八：动手在 SAP BTP 上开发第一个 ABAP 透明表

ABAP Cloud 环境下创建透明表的方法与数据迁移实践 本文介绍了在 SAP BTP ABAP 环境中创建透明表并迁移数据的完整流程。与传统的 SE11 事务码不同，ABAP Cloud 需通过 ABAP Development Tool 创建数据库表，使用代码定义表结构。作者详细演示了如何： 在开发包中创建名为 Z优快云_TRAVEL 的透明表 使用 ABAP 代码定义表字段和约束 通过 ABAP 类实现数据从标准表/DMO/TRAVEL 到新建表的迁移 验证数据迁移结果 文中还提供了相关技术概念的

2007 年 ~ 2025 年，深耕 SAP 技术 18 年 1781

php生成有复杂结构的excel文档

以前都用PHPExcel等工具来生成Excel，但是我们有时候需要非常复杂的样式，比如有合并单元格和拆分单元格，甚至有颜色，行间距之类的，这样做起来很费劲，而且你如果使用插件，你也需要学习这里我们可以使用html网页格式来转换为excel文件。  在html的header中加入以下两句就能使你的网页内容以.xls附件形式直接下载下来 header("Content-type: applica...

yolo模型训练找我，AI游戏合作找我 2080

OpenClaw小白安装全攻略：5000字详解，3分钟上手

为什么值得装 OpenClaw？最近科技圈爆火的 OpenClaw（昵称 “小龙虾”），不是普通 AI 聊天工具 —— 它是能本地部署、直接操控电脑的 AI 智能体，相当于给电脑配了个 “全能助手”：整理文件、自动搜资料、写文档、控制浏览器，甚至对接微信 / 飞书发消息，全程不用手动操作。更关键的是：它免费开源、支持全平台，新手不用懂代码，复制粘贴命令就能装，数据存在本地不泄露隐私。截至 2026 年 3 月，GitHub 星标已破 25 万，券商都出研报推荐，上班族、学生党用它提升效率超香！

通俗易懂学IT 1211

Codex 接入国产大模型指南：客户端与 CLI 双端实战

CC Switch是目前最流行的 Codex / Claude Code 模型切换工具，内置了协议转换功能，支持几乎所有主流国产模型。核心原理Codex → 本地 8317 端口（CC Switch）→ 协议转换 → 国产模型 API整个过程对 Codex 完全透明，Codex 以为自己在跟标准的 Responses API 对话。用户类型推荐方案理由新手 / 不想折腾配置简单，免费额度够用追求稳定体验通义千问（原生接入）官方兼容，功能最完整企业用户自建 AI 网关可控性强，支持多用户管理预算有限。

篮球界最会写bug的人；程序猿中打球最菜的人。 573

PHP 生成excel

php标头Excel和utf-8

weixin_45849851的博客 324

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android：LinePhone3.2.7(最新版本)，官网地址：http://www.linphone.org/

Excel生成目录

Sub 建立目录()    Dim i As Byte    On Error Resume Next    Application.ScreenUpdating = False    Dim XStr, YStr, ZStr    XStr = " -"    ZStr = ""    For i = 1 To Worksheets.Count        If Worksheets(i).N...

qq_37291187的博客 754

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等，可在创建的窗口进行控制

假人有限元模型

假人模型，车辆碰撞假人有限元模型，适合做乘员安全的研究者利用

Demo:代码完成Excel数据并发送Email附件_SAP刘梦_新浪博客

有时候没有上载操作，直接组织数据并生成Excel 附件直接发送。 效果图 参考代码 文本代码请查阅 https://mp.weixin.qq.com/s/Bo4ygAt0NhtycrYkvrjkXQ 欢迎加入SAP群：775662808 ...

森林木的博客 279

IEM模型，地表粗糙度模拟

利用微波反演土壤水分时候，利用IEM模型可以实现对随机地表的模拟

Struts2通过流格式生成Excel下载文件

在工作中需要在JSP页面中，将POI生成的Excel文件直接下载，开发平台是基于Struts2+Spring2的，在网上查了一下，例子不少，也都给我提供了一定的帮助，但很少有拿来不需要进行调试就直接能用的代码例子。所以我把自己最后的实现代码贴出来，希望能对后来者有一定的帮助，或许实现方法不是最好的，但应该是不需要进行过多调试就可以直接用的。 主要关注@Result的params参数设置部...

yoshikiriku的博客 244

php生成excel到服务器,phpoffice生成文件到服务器指定文件

原代码/*** 导出excel信息* @param string $titles 导出的表格标题* @param string $keys 需要导出的键名* @param array $data 需要导出的数据* @param string $file_name 导出的文件名称*/function export_excel($titles = '', $keys...

weixin_39864261的博客 886
下一篇： 奇怪,为什么我的linux网络不对
点赞 0
评论 3
书签 书签 1
bashan
bashan
博客等级 码龄24年 0粉丝 9原创
+ 关注 专栏目录 订阅专栏
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值