Office文件的奥秘——.NET平台下不借助Office实现Word、Powerpoint等文件的解析(一)

原文 http://www.cnblogs.com/mayswind/archive/2013/03/17/2962205.html

 

【题外话】

这是2010年参加比赛时候做的研究,当时为了实现对Word、Excel、PowerPoint文件文字内容的抽取研究了很久,由于Java有 POI库,可以轻松的抽取各种Office文档,而.NET虽然有移植的NPOI,但是只实现了最核心的Excel文件的读写,所以之后查了很多资料才实 现了Word和PowerPoint文件文字的抽取。之后忙于各种事情一直没时间整理,后来虽然想写成文章但由于时间太久也记不清很多细节,现在重新查找 资料并整理如下,希望对大家有用。

 

【系列索引】 

  1. Office文件的奥秘——.NET平台下不借助Office实现Word、Powerpoint等文件的解析(一)获取Office二进制文档的DocumentSummaryInformation以及SummaryInformation
  2. Office文件的奥秘——.NET平台下不借助Office实现Word、Powerpoint等文件的解析(二)获取Word二进制文档(.doc)的文字内容(包括正文、页眉、页脚、批注等等)
  3. Office文件的奥秘——.NET平台下不借助Office实现Word、Powerpoint等文件的解析(三)
    详细介绍Office二进制文档中的存储结构,以及获取PowerPoint二进制文档(.ppt)的文字内容
  4. Office文件的奥秘——.NET平台下不借助Office实现Word、Powerpoint等文件的解析(完)
    介绍Office Open XML文档(.docx、.pptx)如何进行解析以及解析Office文件常见开源类库

 

【文章索引】

  1. .NET下读取Office文件的方式
  2. Windows复合二进制文件及其Header
  3. 我们从Directory开始
  4. DocumentSummaryInformation和SummaryInformation
  5. 相关链接

 

【一、.NET下读取Office文件的方式】

10年的时候参加比赛要做一个文件检索的系统,要包含Word、PowerPoint等文件格式的全文检索。由于之前用过.NET并且考虑到这些是
微软的格式,可能使用.NET读取会更容易些,但没想到.NET这边查到的资料只有Interop的方式读取Office文件。后来接触了Java的
POI,发现.NET也有移植的NPOI,但是只移植了核心的Excel读写,并没有Word、PowerPoint等文件的读写,所以最后没有办法只能
硬着头皮自己去做Word和PowerPoint文件的解析。

那么Interop是什么?Interop的全称是“Interoperability”,即微软希望托管的.NET能与非托管的COM进行互相调
用的一种方式。通过Interop读写Office即调用安装在计算机上的Office软件来实现Office的读写,其优点显而易见,文件还是由
Office生成或读取的,所以与自己打开Office是没有任何区别的;但缺点也非常明显,即运行程序的计算机上必须安装有对应版本的Office软件,同时操作Office文件时实际上是打开了对应的Office组件,所以运行效率低、耗内存大并且还可能产生内存泄露的问题。关于Interop方式读写Office文件的例子网上有很多,有兴趣的可以自行查阅,这里就不再多讲了。

那么,有没有方式不借助Office软件实现Office文件的读写呢?答案肯定是肯定的,就像Java中的POI及.NET中的NPOI实现的那
样,即通过程序自己读写文件来实现Office文件的读写。不过由于Office文件结构非常复杂,这里只提供文件摘要信息和文件文本内容的解析。不过即
使如此,对于全文检索什么的还是足够的。

 

【二、Windows复合二进制文件以及Header】

前几年,微软开放了一些私有格式的规范,使得所有人都可以对其文件进行解析,而不需要支付任何费用,这也使得我们编写解析文件的程序成为可能,相关
链接在文章最后可以找到。对于一个Microsoft Office文件,其实质是一个Windows复合二进制文件(Windows Compound
Binary File),文件的头Header是固定的512字节,Header记录文件最重要的参数。
Header之后可以分为不同的Sector,Sector的种类有FAT、Mini-FAT(属于Mini-Sector)、Directory、
DIF、Stroage等五种。为了方便称呼,我们规定每个Sector都有一个SectorID,Header后的Sector为第一个Sector,其SectorID为0。

我们先来说Header,一个Header的部分截图及包含的信息如下,比较重要的用粗体表示。

  1. Header的前8字节Byte[],也就是整个文件的前8字节,都是固定的0xD0 0xCF 0x11 0xE0 0xA1 0xB1 0x1A 0xE1,如果不是则说明不是复合文件。
  2. 从008H到017H的16字节,是Class Id,不过很多文件都置的0。
  3. 从018H到019H的2字节UInt16,是文件格式的次要版本。
  4. 从01AH到01BH的2字节UInt16,是文件格式的主要版本。
  5. 从01CH到01DH的2字节UInt16,是固定为0xFE 0xFF,表示文档使用的是Little Endian(低位在前,高位在后)。
  6. 从01EH到01FH的2字节UInt16,是Sector大小的幂,默认为9(0x09 0x00),即每个Sector为512字节。
  7. 从020H到021H的2字节UInt16,是Mini-Sector大小的幂,默认为6(0x06 0x00),即每个Mini-Sector为64字节。
  8. 从022H到023H的2字节UInt16,是预留的,必须置0。
  9. 从024H到027H的4字节UInt32,是预留的,必须置0。
  10. 从028H到02BH的4字节UInt32,是预留的,必须置0。
  11. 从02CH到02FH的4字节UInt32,是FAT的数量。
  12. 从030H到033H的4字节UInt32,是Directory开始的SectorID。
  13. 从034H到037H的4字节UInt32,是用于事务的,必须置0。
  14. 从038H到03BH的4字节UInt32,是最小串(Stream)的最大大小,默认为4096(0x00 0x10 0x00 0x10)。
  15. 从03CH到03FH的4字节UInt32,是MiniFAT表开始的SectorID
  16. 从040H到043H的4字节UInt32,是MiniFAT表的数量。
  17. 从044H到047H的4字节UInt32,是DIFAT开始的SectorID
  18. 从048H到04BH的4字节UInt32,是DIFAT的数量。
  19. 从04CH到1FFH的436字节UInt32[],是前109块FAT表的SectorID。

那么我们可以写如下的代码将Header中重要的内容解析出来。

View Code

 1 #region 字段
 2 private FileStream m_stream;
 3 private BinaryReader m_reader;
 4 private Int64 m_length;
 5 private DirectoryEntry m_dirRootEntry;
 6
 7 #region 头部信息
 8 private UInt32 m_sectorSize;//Sector大小
 9 private UInt32 m_miniSectorSize;//Mini-Sector大小
10 private UInt32 m_fatCount;//FAT数量
11 private UInt32 m_dirStartSectorID;//Directory开始的SectorID
12 private UInt32 m_miniFatStartSectorID;//Mini-FAT开始的SectorID
13 private UInt32 m_miniFatCount;//Mini-FAT数量
14 private UInt32 m_difStartSectorID;//DIF开始的SectorID
15 private UInt32 m_difCount;//DIF数量
16 #endregion
17 #endregion
18
19 #region 读取头部信息
20 private void ReadHeader()
21 {
22     if (this.m_reader == null)
23     {
24         return;
25     }
26
27     //先判断是否是Office文件格式
28     Byte[] sig = (this.m_length > 512 ? this.m_reader.ReadBytes(8) : null);
29     if (sig == null ||
30         sig[0] != 0xD0 || sig[1] != 0xCF || sig[2] != 0x11 || sig[3] != 0xE0 ||
31         sig[4] != 0xA1 || sig[5] != 0xB1 || sig[6] != 0x1A || sig[7] != 0xE1)
32     {
33         throw new Exception("该文件不是Office文件!");
34     }
35
36     //读取头部信息
37     this.m_stream.Seek(22, SeekOrigin.Current);
38     this.m_sectorSize = (UInt32)Math.Pow(2, this.m_reader.ReadUInt16());
39     this.m_miniSectorSize = (UInt32)Math.Pow(2, this.m_reader.ReadUInt16());
40
41     this.m_stream.Seek(10, SeekOrigin.Current);
42     this.m_fatCount = this.m_reader.ReadUInt32();
43     this.m_dirStartSectorID = this.m_reader.ReadUInt32();
44
45     this.m_stream.Seek(8, SeekOrigin.Current);
46     this.m_miniFatStartSectorID = this.m_reader.ReadUInt32();
47     this.m_miniFatCount = this.m_reader.ReadUInt32();
48     this.m_difStartSectorID = this.m_reader.ReadUInt32();
49     this.m_difCount = this.m_reader.ReadUInt32();
50 }
51 #endregion

说个比较有意思的,.NET中的BinaryReader有很多读取的方法,比如ReadUInt16、ReadInt32之类的,只有 ReadUInt16的Summary写着“使用 Little-Endian 编码...”(见下图),其实不仅仅是ReadUInt16,所有ReadIntX、ReadUIntX、ReadSingle、ReadDouble都 是使用Little-Endian编码方式从流中读的,大家可以放心使用,而不需要一个字节一个字节的读再反转数组,我在10年的时候就走过弯路。解释在 MSDN各个方法中的备注里:http://msdn.microsoft.com/zh-cn/library/vstudio/system.io.binaryreader_methods.aspx

 

【三、我们从Directory开始】

复合文档中其实存放着很多内容,这么多内容需要有个目录,那么Directory就是这个目录。从Header中我们可以读取出Directory 开始的SectorID,我们可以Seek到这个位置(0x200 + sectorSize * dirStartSectorID)。Directory中每个DirectoryEntry固定为128字节,其主要结构如下:

  1. 从000H到040H的64字节,是存储DirectoryEntry名称的,并且是以Unicode存储的,即每个字符占2个字节,其实可以看做是UInt16。
  2. 从041H到042H的2字节UInt16,是DirectoryEntry名称的长度(包括最后的“\0”)。
  3. 从042H到042H的1字节Byte,是DirectoryEntry的类型。(主要的有:1为目录,2为节点,5为根节点)
  4. 从044H到047H的4字节UInt32,是该DirectoryEntry左兄弟的EntryID(第一个DirectoryEntry的EntryID为0,下同)。
  5. 从048H到04BH的4字节UInt32,是该DirectoryEntry右兄弟的EntryID。
  6. 从04CH到04FH的4字节UInt32,是该DirectoryEntry一个孩子的EntryID。
  7. 从074H到077H的4字节UInt32,是该DirectoryEntry开始的SectorID。
  8. 从078H到07BH的4字节UInt32,是该DirectoryEntry存储的所有字节长度。

显然,Directory其实是一个树形的结构,我们只要从第一个Entry(Root Entry)开始递归搜索就可以了。

为了方便开发,我们创建一个DirectoryEntry的类

View Code

  1 public enum DirectoryEntryType : byte
  2 {
  3     Invalid = 0,
  4     Storage = 1,
  5     Stream = 2,
  6     LockBytes = 3,
  7     Property = 4,
  8     Root = 5
  9 }
 10
 11 public class DirectoryEntry
 12 {
 13     #region 字段
 14     private UInt32 m_entryID;
 15     private String m_entryName;
 16     private DirectoryEntryType m_entryType;
 17     private UInt32 m_sectorID;
 18     private UInt32 m_length;
 19
 20     private DirectoryEntry m_parent;
 21     private List<DirectoryEntry> m_children;
 22     #endregion
 23
 24     #region 属性
 25     /// <summary>
 26     /// 获取DirectoryEntry的EntryID
 27     /// </summary>
 28     public UInt32 EntryID
 29     {
 30         get { return this.m_entryID; }
 31     }
 32
 33     /// <summary>
 34     /// 获取DirectoryEntry名称
 35     /// </summary>
 36     public String EntryName
 37     {
 38         get { return this.m_entryName; }
 39     }
 40
 41     /// <summary>
 42     /// 获取DirectoryEntry类型
 43     /// </summary>
 44     public DirectoryEntryType EntryType
 45     {
 46         get { return this.m_entryType; }
 47     }
 48
 49     /// <summary>
 50     /// 获取DirectoryEntry的SectorID
 51     /// </summary>
 52     public UInt32 SectorID
 53     {
 54         get { return this.m_sectorID; }
 55     }
 56
 57     /// <summary>
 58     /// 获取DirectoryEntry的内容大小
 59     /// </summary>
 60     public UInt32 Length
 61     {
 62         get { return this.m_length; }
 63     }
 64
 65     /// <summary>
 66     /// 获取DirectoryEntry的父节点
 67     /// </summary>
 68     public DirectoryEntry Parent
 69     {
 70         get { return this.m_parent; }
 71     }
 72
 73     /// <summary>
 74     /// 获取DirectoryEntry的子节点
 75     /// </summary>
 76     public List<DirectoryEntry> Children
 77     {
 78         get { return this.m_children; }
 79     }
 80     #endregion
 81
 82     #region 构造函数
 83     /// <summary>
 84     /// 初始化新的DirectoryEntry
 85     /// </summary>
 86     /// <param name="parent">父节点</param>
 87     /// <param name="entryID">DirectoryEntryID</param>
 88     /// <param name="entryName">DirectoryEntry名称</param>
 89     /// <param name="entryType">DirectoryEntry类型</param>
 90     /// <param name="sectorID">SectorID</param>
 91     /// <param name="length">内容大小</param>
 92     public DirectoryEntry(DirectoryEntry parent, UInt32 entryID, String entryName, DirectoryEntryType entryType, UInt32 sectorID, UInt32 length)
 93     {
 94         this.m_entryID = entryID;
 95         this.m_entryName = entryName;
 96         this.m_entryType = entryType;
 97         this.m_sectorID = sectorID;
 98         this.m_length = length;
 99         this.m_parent = parent;
100
101         if (entryType == DirectoryEntryType.Root || entryType == DirectoryEntryType.Storage)
102         {
103             this.m_children = new List<DirectoryEntry>();
104         }
105     }
106     #endregion
107
108     #region 方法
109     public void AddChild(DirectoryEntry entry)
110     {
111         if (this.m_children == null)
112         {
113             this.m_children = new List<DirectoryEntry>();
114         }
115
116         this.m_children.Add(entry);
117     }
118
119     public DirectoryEntry GetChild(String entryName)
120     {
121         for (Int32 i = 0; i < this.m_children.Count; i++)
122         {
123             if (String.Equals(this.m_children[i].EntryName, entryName))
124             {
125                 return this.m_children[i];
126             }
127         }
128
129         return null;
130     }
131     #endregion
132 }

然后我们递归搜索就可以了

View Code

 1 #region 常量
 2 private const UInt32 HeaderSize = 0x200;//512字节
 3 private const UInt32 DirectoryEntrySize = 0x80;//128字节
 4 #endregion
 5
 6 #region 读取目录信息
 7 private void ReadDirectory()
 8 {
 9     if (this.m_reader == null)
10     {
11         return;
12     }
13
14     UInt32 leftSiblingEntryID, rightSiblingEntryID, childEntryID;
15     this.m_dirRootEntry = GetDirectoryEntry(0, null, out leftSiblingEntryID, out rightSiblingEntryID, out childEntryID);
16     this.ReadDirectoryEntry(this.m_dirRootEntry, childEntryID);
17 }
18
19 private void ReadDirectoryEntry(DirectoryEntry rootEntry, UInt32 entryID)
20 {
21     UInt32 leftSiblingEntryID, rightSiblingEntryID, childEntryID;
22     DirectoryEntry entry = GetDirectoryEntry(entryID, rootEntry, out leftSiblingEntryID, out rightSiblingEntryID, out childEntryID);
23
24     if (entry == null || entry.EntryType == DirectoryEntryType.Invalid)
25     {
26         return;
27     }
28
29     rootEntry.AddChild(entry);
30
31     if (leftSiblingEntryID < UInt32.MaxValue)//有左兄弟节点
32     {
33         this.ReadDirectoryEntry(rootEntry, leftSiblingEntryID);
34     }
35
36     if (rightSiblingEntryID < UInt32.MaxValue)//有右兄弟节点
37     {
38         this.ReadDirectoryEntry(rootEntry, rightSiblingEntryID);
39     }
40
41     if (childEntryID < UInt32.MaxValue)//有孩子节点
42     {
43         this.ReadDirectoryEntry(entry, childEntryID);
44     }
45 }
46
47 private DirectoryEntry GetDirectoryEntry(UInt32 entryID, DirectoryEntry parentEntry, out UInt32 leftSiblingEntryID, out UInt32 rightSiblingEntryID, out UInt32 childEntryID)
48 {
49     leftSiblingEntryID = UInt16.MaxValue;
50     rightSiblingEntryID = UInt16.MaxValue;
51     childEntryID = UInt16.MaxValue;
52
53     this.m_stream.Seek(GetDirectoryEntryOffset(entryID), SeekOrigin.Begin);
54
55     if (this.m_stream.Position >= this.m_length)
56     {
57         return null;
58     }
59
60     StringBuilder temp = new StringBuilder();
61     for (Int32 i = 0; i < 32; i++)
62     {
63         temp.Append((Char)this.m_reader.ReadUInt16());
64     }
65
66     UInt16 nameLen = this.m_reader.ReadUInt16();
67     String name = (temp.ToString(0, (temp.Length < (nameLen / 2 - 1) ? temp.Length : nameLen / 2 - 1)));
68     Byte type = this.m_reader.ReadByte();
69
70     if (type > 5)
71     {
72         return null;
73     }
74
75     this.m_stream.Seek(1, SeekOrigin.Current);
76     leftSiblingEntryID = this.m_reader.ReadUInt32();
77     rightSiblingEntryID = this.m_reader.ReadUInt32();
78     childEntryID = this.m_reader.ReadUInt32();
79
80     this.m_stream.Seek(36, SeekOrigin.Current);
81     UInt32 sectorID = this.m_reader.ReadUInt32();
82     UInt32 length = this.m_reader.ReadUInt32();
83
84     return new DirectoryEntry(parentEntry, entryID, name, (DirectoryEntryType)type, sectorID, length);
85 }
86 #endregion
87
88 #region 辅助方法
89 private Int64 GetSectorOffset(UInt32 sectorID)
90 {
91     return HeaderSize + this.m_sectorSize * sectorID;
92 }
93
94 private Int64 GetDirectoryEntryOffset(UInt32 sectorID)
95 {
96     return HeaderSize + this.m_sectorSize * this.m_dirStartSectorID + DirectoryEntrySize * sectorID;
97 }
98 #endregion

 

【四、DocumentSummaryInformation和SummaryInformation

Office文档包含很多摘要信息,比如标题、作者、编辑时间等等,如下图。

摘要信息又分为两类,一类是DocumentSummaryInformation,另一类是SummaryInformation,分别包含不同 种类的摘要信息。通过上述的代码应该能获取到Root Entry下有一个叫“\005DocumentSummaryInformation”的Entry和一个叫“ \005SummaryInformation”的Entry。

对于DocumentSummaryInformation,其结构如下

  1. 从018H到01BH的4字节UInt32,是存储属性组的个数。
  2. 从01CH开始的每20字节,是属性组的信息:
    • 对于前16字节Byte[],如果是0x02 0xD5 0xCD 0xD5 0x9C 0x2E 0x1B 0x10 0x93 0x97 0x08 0x00 0x2B 0x2C 0xF9 0xAE,则表示是DocumentSummaryInformation;如果是0x05 0xD5 0xCD 0xD5 0x9C 0x2E 0x1B 0x10 0x93 0x97 0x08 0x00 0x2B 0x2C 0xF9 0xAE,则表示是UserDefinedProperties。
    • 对于后4字节UInt32,则是该属性组相对于Entry的偏移。

对于每个属性组,其结构如下:

  1. 从000H到003H的4字节UInt32,是属性组大小。
  2. 从004H到007H的4字节UInt32,是属性组中属性的个数。
    从008H开始的每8字节,是属性的信息:
  • 对于前4字节UInt32,是属性编号,表示属性的种类。
  • 对于后4字节UInt32,是属性内容相对于属性组的偏移。

常见的属性编号有以下这些:

View Code

 1 public enum DocumentSummaryInformationType : uint
 2 {
 3     Unknown                 = 0x00,
 4     CodePage                = 0x01,
 5     Category                = 0x02,
 6     PresentationTarget      = 0x03,
 7     Bytes                   = 0x04,
 8     LineCount               = 0x05,
 9     ParagraphCount          = 0x06,
10     Slides                  = 0x07,
11     Notes                   = 0x08,
12     HiddenSlides            = 0x09,
13     MMClips                 = 0x0A,
14     Scale                   = 0x0B,
15     HeadingPairs            = 0x0C,
16     DocumentParts           = 0x0D,
17     Manager                 = 0x0E,
18     Company                 = 0x0F,
19     LinksDirty              = 0x10,
20     CountCharsWithSpaces    = 0x11,
21     SharedDoc               = 0x13,
22     HyperLinksChanged       = 0x16,
23     Version                 = 0x17,
24     ContentStatus           = 0x1B
25 }

对于每个属性,其结构如下:

  1. 从000H到003H的4字节UInt32,是属性内容的类型。

    • 类型为0x02时为UInt16。
    • 类型为0x03时为UInt32。
    • 类型为0x0B时为Boolean。
    • 类型为0x1E时为String。
  2. 剩余的字节为属性的内容。
    1. 除了类型是String时为不定长,其余三种均为4位字节(多余字节置0)。
    2. 类型是String时前4字节是字符串的长度(包括“\0”),所以没法使用BinaryReader的ReadString读取。之后长度为字符串内容,字符串是使用单字节编码进行存储的,可以使用Encoding中的GetString获取字符串内容。

为了方便开发,我们创建一个DocumentSummary的类。比较有意思的是,不论DocumentSummaryInformation还是 SummaryInformation,第一个属性都是记录该组内容的代码页编码,可以通过Encoding.GetEncoding()获取对应的编码 然后用GetString把对应的字符串解析出来:

View Code

 1 public class DocumentSummaryInformation
 2 {
 3     #region 字段
 4     private DocumentSummaryInformationType m_propertyID;
 5     private Object m_data;
 6     #endregion
 7
 8     #region 属性
 9     /// <summary>
10     /// 获取属性类型
11     /// </summary>
12     public DocumentSummaryInformationType Type
13     {
14         get { return this.m_propertyID; }
15     }
16
17     /// <summary>
18     /// 获取属性数据
19     /// </summary>
20     public Object Data
21     {
22         get { return this.m_data; }
23     }
24     #endregion
25
26     #region 构造函数
27     /// <summary>
28     /// 初始化新的非字符串型DocumentSummaryInformation
29     /// </summary>
30     /// <param name="propertyID">属性ID</param>
31     /// <param name="propertyType">属性数据类型</param>
32     /// <param name="data">属性数据</param>
33     public DocumentSummaryInformation(UInt32 propertyID, UInt32 propertyType, Byte[] data)
34     {
35         this.m_propertyID = (DocumentSummaryInformationType)propertyID;
36         if (propertyType == 0x02) this.m_data = BitConverter.ToUInt16(data, 0);
37         else if (propertyType == 0x03) this.m_data = BitConverter.ToUInt32(data, 0);
38         else if (propertyType == 0x0B) this.m_data = BitConverter.ToBoolean(data, 0);
39     }
40
41     /// <summary>
42     /// 初始化新的字符串型DocumentSummaryInformation
43     /// </summary>
44     /// <param name="propertyID">属性ID</param>
45     /// <param name="propertyType">属性数据类型</param>
46     /// <param name="codePage">代码页标识符</param>
47     /// <param name="data">属性数据</param>
48     public DocumentSummaryInformation(UInt32 propertyID, UInt32 propertyType, Int32 codePage, Byte[] data)
49     {
50         this.m_propertyID = (DocumentSummaryInformationType)propertyID;
51         if (propertyType == 0x1E) this.m_data = Encoding.GetEncoding(codePage).GetString(data).Replace("\0", "");
52     }
53     #endregion
54 }

然后我们进行读取就可以了:

View Code

 1 private List<DocumentSummaryInformation> m_documentSummaryInformation;
 2
 3 #region 读取DocumentSummaryInformation
 4 private void ReadDocumentSummaryInformation()
 5 {
 6     DirectoryEntry entry = this.m_dirRootEntry.GetChild('\x05' + "DocumentSummaryInformation");
 7
 8     if (entry == null)
 9     {
10         return;
11     }
12
13     Int64 entryStart = this.GetSectorOffset(entry.SectorID);
14
15     this.m_stream.Seek(entryStart + 24, SeekOrigin.Begin);
16     UInt32 propertysCount = this.m_reader.ReadUInt32();
17     UInt32 docSumamryStart = 0;
18
19     for (Int32 i = 0; i < propertysCount; i++)
20     {
21         Byte[] clsid = this.m_reader.ReadBytes(16);
22         if (clsid[0] == 0x02 && clsid[1] == 0xD5 && clsid[2] == 0xCD && clsid[3] == 0xD5 &&
23             clsid[4] == 0x9C && clsid[5] == 0x2E && clsid[6] == 0x1B && clsid[7] == 0x10 &&
24             clsid[8] == 0x93 && clsid[9] == 0x97 && clsid[10] == 0x08 && clsid[11] == 0x00 &&
25             clsid[12] == 0x2B && clsid[13] == 0x2C && clsid[14] == 0xF9 && clsid[15] == 0xAE)//如果是DocumentSummaryInformation
26         {
27             docSumamryStart = this.m_reader.ReadUInt32();
28             break;
29         }
30         else
31         {
32             this.m_stream.Seek(4, SeekOrigin.Current);
33         }
34     }
35
36     if (docSumamryStart == 0)
37     {
38         return;
39     }
40
41     this.m_stream.Seek(entryStart + docSumamryStart, SeekOrigin.Begin);
42     this.m_documentSummaryInformation = new List<DocumentSummaryInformation>();
43     UInt32 docSummarySize = this.m_reader.ReadUInt32();
44     UInt32 docSummaryCount = this.m_reader.ReadUInt32();
45     Int64 offsetMark = this.m_stream.Position;
46     Int32 codePage = Encoding.Default.CodePage;
47
48     for (Int32 i = 0; i < docSummaryCount; i++)
49     {
50         this.m_stream.Seek(offsetMark, SeekOrigin.Begin);
51         UInt32 propertyID = this.m_reader.ReadUInt32();
52         UInt32 properyOffset = this.m_reader.ReadUInt32();
53
54         offsetMark = this.m_stream.Position;
55
56         this.m_stream.Seek(entryStart + docSumamryStart + properyOffset, SeekOrigin.Begin);
57         UInt32 propertyType = this.m_reader.ReadUInt32();
58         DocumentSummaryInformation info = null;
59         Byte[] data = null;
60
61         if (propertyType == 0x1E)
62         {
63             UInt32 strLen = this.m_reader.ReadUInt32();
64             data = this.m_reader.ReadBytes((Int32)strLen);
65             info = new DocumentSummaryInformation(propertyID, propertyType, codePage, data);
66         }
67         else
68         {
69             data = this.m_reader.ReadBytes(4);
70             info = new DocumentSummaryInformation(propertyID, propertyType, data);
71
72             if (info.Type == DocumentSummaryInformationType.CodePage)//如果找到CodePage的属性
73             {
74                 codePage = (Int32)(UInt16)info.Data;
75             }
76         }
77
78         this.m_documentSummaryInformation.Add(info);
79     }
80 }
81 #endregion

而SummaryInformation与DocumentSummaryInformation相比读取方式是一样的,只不过属性组的16位标识 为0xE0 0x85 0x9F 0xF2 0xF9 0x4F 0x68 0x10 0xAB 0x91 0x08 0x00 0x2B 0x27 0xB3 0xD9。

常见的SummaryInformation属性的属性编号如下:

View Code

 1 public enum SummaryInformationType : uint
 2 {
 3     Unknown = 0x00,
 4     CodePage = 0x01,
 5     Title = 0x02,
 6     Subject = 0x03,
 7     Author = 0x04,
 8     Keyword = 0x05,
 9     Commenct = 0x06,
10     Template = 0x07,
11     LastAuthor = 0x08,
12     Reversion = 0x09,
13     EditTime = 0x0A,
14     CreateDateTime = 0x0C,
15     LastSaveDateTime = 0x0D,
16     PageCount = 0x0E,
17     WordCount = 0x0F,
18     CharCount = 0x10,
19     ApplicationName = 0x12,
20     Security = 0x13
21 }

其他代码由于与DocumentSummaryInformation相近就不再单独给出了。

附,本文所有代码下载:http://files.cnblogs.com/mayswind/DotMaysWind.OfficeReader_1.rar

 

【五、相关链接】

1、Microsoft Open Specifications:http://www.microsoft.com/openspecifications/en/us/programs/osp/default.aspx
2、用PHP读取MS Word(.doc)中的文字:https://imethan.com/post-2009-10-06-17-59.html3、Office檔案格式:http://www.programmer-club.com.tw/ShowSameTitleN/general/2681.html4、LAOLA file system:http://stuff.mit.edu/afs/athena/astaff/project/mimeutils/share/laola/guide.html

 

【后记】

花了好几天的时间才写完读取DocumentSummaryInformation和SummaryInformation,果然自己写程序用和写成文章区别太大了,前者差不多就行,后者还得仔细查阅资料。如果您觉得好就点下推荐呗。

版权声明:本文发布于 博客园,作者为 大魔王mAysWINd,文章欢迎转载,但请保留此段版权声明和原始链接,谢谢合作!

时间: 2023-01-07

Office文件的奥秘——.NET平台下不借助Office实现Word、Powerpoint等文件的解析(一)的相关文章

Android平台下利用zxing实现二维码开发

现在走在大街小巷都能看到二维码,而且最近由于项目需要,所以研究了下二维码开发的东西,开源的二维码扫描库主要有zxing和zbar,zbar在iPos平台上应用比较成熟,而在Android平台上主流还是用zxing库,因此这里主要讲述如何利用zxing进行二维码开发. 1.如何将zxing的Android源码导入工程. 在导入zxing的android源码之前,先去官方下载zxing的源码:http://code.google.com/p/zxing/downloads/list. 我这里下载的是

java 下载 断点续传-用java语言从web下载文件到本地指定路径下

问题描述 用java语言从web下载文件到本地指定路径下 java语言实现从外部网站下载文件到我们公司的服务器上,支持断点续传并且用一个线程下载一个文件,请问哪位有什么思路或者源码参考.麻烦大家给我出出主意. 网上都是从服务器上下载到本地的案例.这种可以应用到我这种需求上吗? 顺便问下http协议和ftp协议下载文件是否支持下载到本地指定路径,对文件大小类型有没有限制. 解决方案 1.先用代码解析外部网站下载页面获取下载地址 2.代码实现http协议请求解析得到的下载地址,下载文件到本地 3.代

mac-为什么不能修改Mac下/usr/local/nginx/conf/nginx.conf文件

问题描述 为什么不能修改Mac下/usr/local/nginx/conf/nginx.conf文件 为什么不能修改Mac下/usr/local/nginx/conf/nginx.conf文件 如果可以,有其它方法在Mac下修改nginx配置呢? 解决方案 可以查看下权限,或者拷贝一份试试能否修改 解决方案二: 应该可以修改,是不是权限的问题?

hadoop下的存储在hdfs中的视频文件怎么播放?

问题描述 hadoop下的存储在hdfs中的视频文件怎么播放? hadoop下的存储在hdfs中的视频文件怎么播放?可以直接拿到视频文件的http路径吗,我现在想实现的是像百度云这样的可以在线播放,但是不知道怎么得到文件的路径,而hdfs提供的API只有上传下载文件这些,对于这样的问题要怎么解决呢?? 解决方案 你需要用HDFS API来获取 package org.myorg.hdfsdemo; import java.io.BufferedReader; import java.io.IOE

不同WINDOWS平台下磁盘逻辑扇区的直接读写

不同WINDOWS平台下磁盘逻辑扇区的直接读写 关键字:VWIN32.中断.DeviceIoControl 一.概述 在DOS操作系统下,通过BIOS的INT13.DOS的INT25(绝对读).INT26(绝对写)等功能调用实现对磁盘逻辑扇区或物理扇区的读写是很方便的,C语言中还有对应上述功能调用的函数:biosdisk.absread和abswrite等.但在WINDOWS操作系统下编写WIN32应用程序时却再也不能直接使用上述的中断调用或函数了.那么,在WINDOWS操作系统下能不能实现磁盘

qt-vs2012平台下将工具集改成VS2010 V100之后生成出错

问题描述 vs2012平台下将工具集改成VS2010 V100之后生成出错 vs2012平台下新建QT application工程,将工具集改成VS2010 V100之后生成出错,情况如下:1>qtmaind.lib(qtmain_win.obj) : error LNK2038: 检测到"_MSC_VER"的不匹配项: 值"1700"不匹配值"1600"(moc_rr.obj 中) 解决方案 工程属性->配置属性-> 清单工具

usb-android 平台下可否根据VID/PID配置赋予路径权限

问题描述 android 平台下可否根据VID/PID配置赋予路径权限 请问一下,USB设备(假设VID=0X05A9PID=0X1234)插入Android后,USB路径可能是 /dev/bus/usb/003/010 但是这个路径没有写权限,在系统集成的时候怎么配置指定VID/PID的路径读写权限呢 ? 比较笨的方法是ueventd.rc文件里面分别列出可能的path,但是这样就把其他VID PID的路径也给了权限,存在风险./dev/bus/usb/001/0* 0666 root usb

XML在.net平台下的自定义控件的应用

xml|控件   Xml全称可扩展标记语言(extensible marked language),这套语言系统由于在数据处理,跨平台等方面的独特优势,在近几年风靡全球.Xml语言系统把任何数据都作为"键"和"值"来进行处理,这一点类似于很多数据库管理系统(DBMS),而且它与具体的机器指令无关,其存储方式是纯文本文件,因此具有出色的跨平台性.另外它允许用户创建自己的数据指令系统,在这套指令系统的框架下,用户可以把所有信息转换成易于存取的数据,大大加快了开发的周期和

XML在.net平台下的自定义控件的应用(2)

xml|控件 第二步,就是加入XML特性注意,任何xml文档在其被处理之前最好先进行有效性验证,提供验证一般有两种重要的途径.其一就是提供DTD(文档类型定义),实际上就是让用户提供指令集,然后在xml文档加载的时候对其进行有效性分析,看是否有无效指令,简单说就是创建一个编译环境:另外一个就是提供一个所谓的schema..其作用跟DTD完全一样,只是在表现形式上好于DTD,因为它本身也是一个XML文档.这里我采用了schema的形式,当然了,读者用兴趣也可以将其替换问相应的DTD版本.下面