博客园_Jaxu's home

还有什么不能做？——细谈在C#中读写Excel系列文章之四

2012-05-12T00:31:00Z

作为这一系列文章的最后一篇，向大家介绍下如何在Silverlight中解压和创建Excel OpenXml ZIP压缩包。由于Silverlight对本地客户端文件系统访问的安全级别要求比较高，不太容易像Windows应用程序那样可以随意地读写目录和文件，我们不得不考虑使用一些其它的办法。如使用Silverlight的OOB（Out of Browser）模式，可以允许Silverlight程序读写本地的部分目录和文件，下面这篇文章介绍了如何在Silverlight OOB模式下调用COM组件来操作Excel。

http://www.codeproject.com/Articles/83996/Silverlight-4-Interoperability-with-Excel-using-th

又回到使用COM组件的方式了，不过这个不是我们要讨论的问题，了解一下也无妨。先说说为什么我们要如此变态地在Silverlight中使用Excel OpenXML。

这其实是一个需求，用户的数据存放在SharePoint List中，想通过一个程序从List读取数据然后填充到一个Excel模板中提供下载。这个需求本身其实非常简单，关键是用户要求程序不能在客户端安装，服务器端不能有Custom Code，这两点要求几乎扼杀了我们所有可以使用的方法，第一不能使用诸如Windows Form或WPF application，第二不能创建SharePoint Feature或Webpart，当然就更别提创建单独的ASP.NET应用程序了，客户根本就没有提供空间去部署站点。另外Silverlight的OOB模式也不允许，因为OOB模式也是要在本地安装的，尽管它不同于传统意义上的Windows程序安装。这样，我们只有一条路可走，那就是创建Silverlight应用程序然后通过SharePoint的Silverlight Webpart部署到页面上，在Silverlight中直接调用Excel Services把从List中读取到的数据填充到Excel中。那跟Excel OpenXML有什么关系？我们不是已经往Excel里写入数据了吗？对，没错！如果你只是单纯往Excel模板中写入数据根本不需要再做任何操作，可是修改Excel文件的样式呢？

还记得在上一篇文章中的那个图吗？如果单元格中没有部分内容加粗，而只是单纯的换行或空格，我们可以直接通过Excel的公式或表达式来实现。

=CONCATENATE(" Short-term investments (including securities loaned", CHAR(10), " of $9,999 and $8,888")

=" Short-term investments (including securities loaned)" & CHAR(10)&" of " & TEXT("9999", "$#,##0") & " and " & TEXT("8888", "$#,##0")

上面两行代码分别使用了Excel中的Concatenate()函数和&连接符来填充单元格内容，其中CHAR(10)表示的就是回车符。但是我们无法在Excel中通过函数设置字符串的样式，Excel所有内置的函数都不能修改样式。或许我们可以尝试通过VBA来修改样式呢？在单独的Excel文件中这个办法是可行的，我们只需要在Workbook的Open事件或SheetChange事件中写入VBA代码，当事件被调用的时候样式会被自动修改。不过Excel Services不支持带有VBA或宏的Excel文件，当你尝试通过Excel Services读取一个带有VBA代码或宏的Excel文件时会抛出异常。所以，尝试通过VBA来修改样式是行不通的，尤其是那些特殊的样式，如上图中单元格内数字加粗和上标等。

因此，我们会考虑通过Excel OpenXML方式将已经填充好数据的Excel文件进行样式修改。按照前面几篇文章的介绍，修改Excel内容需要首先将其解压到一个临时目录，然后修改临时目录中相应的XML文件，最后再重新打包成一个Excel文件。可是在Silverlight中不太容易操作本地文件系统，因此我们只能考虑在文件Stream中完成操作了。

我们需要一个能支持在Silverlight工程中操作ZIP文件的类库，之前的那个开源类库http://www.icsharpcode.net/OpenSource/SharpZipLib/是使用较早的.NET Framework编写的，有许多类型和对象在Silverlight Framework中找不到无法编译通过。幸好这里我找到有人将其修改成Silverlight版本了，非常感谢！互联网是强大的。

http://web-snippets.blogspot.com/2008/03/unpacking-zip-files-in-silverlight-2.html

我这里也提供一个下载吧，以免原作者的空间打不开。SLSharpZipLib_Solution.zip

这里还有一个关于ShareZipLib示例的WiKi站点，可以研究下这个类库都能干些什么。

http://wiki.sharpdevelop.net/SharpZipLib_Updating.ashx#Updating_a_zip_file_in_memory_1

来看一个实际应用的例子。

/// <summary>
/// Format exported Excel file with a stream.
/// </summary>
/// <param name="zipfileStream">A stream of Excel zip file.</param>
/// <returns>Return a MemoryStream of updated Excel zip file.</returns>
public Stream FormatExcelWithStream(Stream zipfileStream)
{
// copy the current stream to a new stream
MemoryStream msZip = new MemoryStream();
long pos = 0;
pos = zipfileStream.Position;
zipfileStream.CopyTo(msZip);
zipfileStream.Position = pos;

XElement eleSheet = null;

// load sharedStrings xml document for updating
XElement eleSharedStrings = null;
using (Stream mainStream = FindEntryFromZipStream(zipfileStream, "xl/sharedStrings.xml"))
{
if (mainStream == null)
{
return msZip;
}
eleSharedStrings = XElement.Load(mainStream);
}

// distinct sheet xml document for searching
IEnumerable<ExcelFormattingSetting> noduplicates = ExcelFormattingSettings.Distinct(new ExcelFormattingSettingCompare());
foreach (ExcelFormattingSetting sheet in noduplicates)
{
zipfileStream.Position = 0;
using (Stream stream = FindEntryFromZipStream(zipfileStream, sheet.SheetName))
{
if (stream != null)
{
eleSheet = XElement.Load(stream);
// update sharedStrings.xml document
UpdateSharedStringsXMLDoc(sheet.SheetName, eleSharedStrings, eleSheet);
}
}
}

// update to stream
MemoryStream msEntry = new MemoryStream();
eleSharedStrings.Save(msEntry);
// The zipStream is expected to contain the complete zipfile to be updated
ZipFile zipFile = new ZipFile(msZip);

zipFile.BeginUpdate();

// To use the entryStream as a file to be added to the zip,
// we need to put it into an implementation of IStaticDataSource.
CustomStaticDataSource sds = new CustomStaticDataSource();
sds.SetStream(msEntry);

// If an entry of the same name already exists, it will be overwritten; otherwise added.
zipFile.Add(sds, "xl/sharedStrings.xml");

// Both CommitUpdate and Close must be called.
zipFile.CommitUpdate();
// Set this so that Close does not close the memorystream
zipFile.IsStreamOwner = false;
zipFile.Close();

return msZip;
}

/// <summary>
/// Find a specific stream with the entry name of the Excel zip file package.
/// </summary>
/// <param name="inputStream">The Excel zip file stream.</param>
/// <param name="entryName">Entry name in the Excel zip file package.</param>
/// <returns>Return the sepcific stream.</returns>
private Stream FindEntryFromZipStream(Stream inputStream, string entryName)
{
ZipInputStream zipStream = new ZipInputStream(inputStream);
ZipEntry zippedFile = zipStream.GetNextEntry();

//Do until no more zipped files left
while (zippedFile != null)
{
byte[] buffer = new byte[2048];
int bytesRead;

MemoryStream memoryStream = new MemoryStream();
// read through the compressed data
while ((bytesRead = zipStream.Read(buffer, 0, buffer.Length)) != 0)
{
memoryStream.Write(buffer, 0, bytesRead);
}
memoryStream.Position = 0;

if (zippedFile.Name.Equals(entryName))
{
return memoryStream;
}

zippedFile = zipStream.GetNextEntry();
}

return null;
}

/// <summary>
/// Update formatted strings to the sharedStrings.xml document in Excel zip file.
/// </summary>
/// <param name="sheetName"></param>
/// <param name="navSharedStrings"></param>
/// <param name="navSheet"></param>
private void UpdateSharedStringsXMLDoc(string sheetName, XElement eleSharedStrings, XElement eleSheet)
{
XNamespace nsSharedStrings = eleSharedStrings.GetDefaultNamespace();
XNamespace nsSheet = eleSheet.GetDefaultNamespace();
int i;
string sContent;

// update each formatting settings to the sharedStrings xml document
foreach (ExcelFormattingSetting setting in ExcelFormattingSettings.Where(s => s.SheetName.Equals(sheetName)))
{
// find out which si element need to update from the sheet xml document.
var siIndex = eleSheet.Element(nsSheet + "sheetData")
.Descendants(nsSheet + "c")
.Where(d => d.Attribute("r").Value == setting.ExcelPositionString).FirstOrDefault();
if (siIndex != null)
{
if (int.TryParse(siIndex.Value, out i))
{
var siEntry = eleSharedStrings.Elements(nsSharedStrings + "si").ElementAt(i);
if (siEntry != null)
{
var child = siEntry.Element(nsSharedStrings + "t");
if (child != null)
{
setting.OriginalText = child.Value;
sContent = setting.ProcessFormatting(setting.processFormatting);
// note, cannot set empty content to the new XElement.
if (!sContent.Equals(string.Empty))
{
XElement newElement = XElement.Parse("<si xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\">" + setting.ProcessFormatting(setting.processFormatting) + "</si>");
siEntry.ReplaceWith(newElement);
}
}
}
}
}
}
}

不能在原Stream上进行操作。首先将文件的Stream Copy出来一份。函数FindEntryFromZipStream()通过entryName来返回ZIP压缩包中指定的部分，返回类型为Stream。将找到的Stream交给UpdateSharedStringsXMLDoc()方法进行修改，该方法会逐一读取所有工作表XML文件，找到需要修改的部分的si节点的序号（该序号存放在工作表XML文件的sheetData->c->r节点中），然后修改sharedStrings.xml文件的内容。注意sharedStrings.xml文件加载的XElement对象只有一个，传入该对象到UpdateSharedStringsXMLDoc()方法进行修改，之后将其存入到一个MemoryStream对象中。接下来的代码便是将该MemoryStream重新加到ZIP包里，使用了类库提供的方法，注意如果指定的entryName在原ZIP包中存在则会直接替换，否则就添加。CustomStaticDataSource类是自定义的一个类，按照要求该类必须继承自IStaticDataSource接口。

public class CustomStaticDataSource : IStaticDataSource
{
private Stream _stream;
// Implement method from IStaticDataSource
public Stream GetSource()
{
return _stream;
}

// Call this to provide the memorystream
public void SetStream(Stream inputStream)
{
_stream = inputStream;
_stream.Position = 0;
}
}

所有的操作都在一个Stream里完成，不需要临时目录存放解压后的文件。这里是上面整个类的完整下载，ExcelFormattingAdjustor.zip

例子中将所有需要修改样式的单元定义成常量，然后在自定义类ExcelFormattingSetting中存储设置样式的一些参数，如原内容、工作表名称、样式替换字符串，以及如何修改样式的委托等。将所有ExcelFormattingSetting类的实例存放到一个集合里，遍历该集合对所有的设置项进行修改。你可以在ExcelFormattingSetting类的ProcessFormatting()方法中定义如何替换这些样式字符串，如果遇到需要特殊处理的情况，就在该类的实例中定义一个匿名函数，在匿名函数中进行处理。

更多的应用还在不断尝试中，如果能够提供一个功能丰富且成熟的类库，我们完全可以脱离COM组件来操作Excel，包括创建一个全新的Excel文件、读取数据生成报表、导出数据到Excel文件并自定义样式等等。但所有这一切都应该归功于OpenXML，它使得Office文件从一个自封闭的环境中解脱出来了，基于XML结构的文件是开放的，因此我们做的所有工作其实就是在操作XML，如此简单！不是吗？

本文链接

还有什么不能做？——细谈在C#中读写Excel系列文章之三

2012-05-10T23:35:00Z

在第二篇文章中我已经向大家详细介绍了Excel 2007以后版本的文件的OpenXML结构。所谓的OpenXML结构从本质上来讲其实就是一个ZIP压缩包，所有基于OpenXML数据结构的文件都一样。这样文件的结构是开放的，你不需要借助于任何第三方的组件就可以读取文件中的数据，或者修改文件的内容。而且所有资源文件诸如图片和多媒体文件都是被编译成一个固定的格式存放在压缩包中，而不是传统形式上的流。另外，以压缩包的形式存储数据也使得文件所占用的空间更小。

这些都是它的优点。其实，微软在.NET中已经提供了相应的类库来帮助我们操作OpenXML文件，就像我在第二篇文章中向大家介绍的一样，微软把OpenXML压缩包称之为一个Package，在Package中的文件称作Parts，不同的Parts有自己的Content Type。Content Type可以描述任何内容，如application XML，user XML，images，sounds，videos，或者其它二进制内容。各个Part之间通过一个被称之为relationship的part连接起来，这个part其实也是一种特殊的XML文件，后缀为".rels"，在Package中可以找到它。下图说明了一个Package中各个Part之间的关系，

虽然.NET中提供的Package类可以帮助我们非常方便地解析Excel包，但是也有许多的局限性，有的时候你不得不使用一些方法来自己读取包中的内容，或者尝试去修改包中的数据。

1. 将Package作为一个标准的zip文件进行解压。

2. 找到Package中你想要读取的parts。有许多的方法可以帮助你找到这些parts，你可以解析relationship，也可以直接通过path来定位到某一个文件，不过不太确定path在将来是否会有变化。或者还可以通过part的content type来找到它。

3. 读取part中的内容。如果parts是以XML的形式存放的，通过标准的XML类库就可以非常方便地读取到数据。如果是其它形式，如图片、声音或视频文件则也可以通过相应的方法来获取到内容。

另一方面，你也可以创建一个基于OpenXML的文件（如采用非COM组件的形式创建一个Excel文件），

1. 创建或复制所有必须的parts。通过标准XML类库来创建这些基于XML数据格式的parts，或者从其它package中复制这些parts，或者采用任何其它你所熟悉的方法。

2. 创建relationships部分。也就是创建一个后缀为".rels"的特殊XML文件。

3. 将整个package压缩成一个zip包，然后将文件的后缀修改成需要的类型（如docx，xlsx，或者pptx等）。只要package中的结构符合要求，修改之后的文件可以直接被打开。当然，该过程可以在完全没有安装office的机器上完成（例如服务器），然后分发给需要的地方使用。

所有这一切包括packages，parts，content types，以及relationships都被称之为OpenXML文档，微软将这个叫做Open Packaging Conventions。

有关Excel OpenXML的内部结构以及一些比较重要的节点含义在前一篇文章中已经做了一些介绍，除了直接使用.NET类库中的Package类之外，我们当然也可以使用其它的第三方类库或者自己编写代码读取包中的内容，这里有一个.NET的开源类库专门用来操作zip压缩文件。

http://www.icsharpcode.net/OpenSource/SharpZipLib/

提供一个程序集下载吧，源代码大家去上面这个网址下载。ICSharpCode.ShareZipLib.zip

借用该类库中的ExtractZip()和CreateZip()方法可以帮助我们读取或修改（创建）Excel文件。当然这个类库中的某些代码是使用较早的.NET版本中的语法和对象来编写的，诸如ArratList、Hashtable等，它可能不适合在Silverlight工程中使用（支持Silverlight的.NET Framework与普通的.NET Framework有许多区别并且变化比较频繁），接下来的文章中我会向大家介绍如何在Silverlight工程中使用它。但现在并不妨碍我们在其它类型的工程中使用。

来看一看实际的例子。这里有一个类提供了一些方法用来读取和修改Excel文件中的数据：

1 using System.Collections.Generic;
2 using System.Data;
3 using System.Globalization;
4 using System.IO;
5 using System.Text;
6 using System.Xml;
7 using ICSharpCode.SharpZipLib.Zip;
8
9 namespace XlsxReadWrite
10 {
11 internal static class XlsxRW
12 {
13 public static void DeleteDirectoryContents(string directory)
14 {
15 var info = new DirectoryInfo(directory);
16
17 foreach (var file in info.GetFiles())
18 {
19 file.Delete();
20 }
21
22 foreach (var dir in info.GetDirectories())
23 {
24 dir.Delete(true);
25 }
26 }
27
28 public static void UnzipFile(string zipFileName, string targetDirectory)
29 {
30 new FastZip().ExtractZip(zipFileName, targetDirectory, null);
31 }
32
33 public static void ZipDirectory(string sourceDirectory, string zipFileName)
34 {
35 new FastZip().CreateZip(zipFileName, sourceDirectory, true, null);
36 }
37
38 public static IList<string> ReadStringTable(Stream input)
39 {
40 var stringTable = new List<string>();
41
42 using (var reader = XmlReader.Create(input))
43 {
44 for (reader.MoveToContent(); reader.Read(); )
45 {
46 if (reader.NodeType == XmlNodeType.Element && reader.Name == "t")
47 {
48 stringTable.Add(reader.ReadElementString());
49 }
50 }
51 }
52
53 return stringTable;
54 }
55
56 public static void ReadWorksheet(Stream input, IList<string> stringTable, DataTable data)
57 {
58 using (var reader = XmlReader.Create(input))
59 {
60 DataRow row = null;
61 int columnIndex = 0;
62 string type;
63 int value;
64
65 for (reader.MoveToContent(); reader.Read(); )
66 if (reader.NodeType == XmlNodeType.Element)
67 switch (reader.Name)
68 {
69 case "row":
70 row = data.NewRow();
71 data.Rows.Add(row);
72
73 columnIndex = 0;
74
75 break;
76
77 case "c":
78 type = reader.GetAttribute("t");
79 reader.Read();
80 value = int.Parse(reader.ReadElementString(), CultureInfo.InvariantCulture);
81
82 if (type == "s")
83 row[columnIndex] = stringTable[value];
84 else
85 row[columnIndex] = value;
86
87 columnIndex++;
88
89 break;
90 }
91 }
92 }
93
94 public static IList<string> CreateStringTables(DataTable data, out IDictionary<string, int> lookupTable)
95 {
96 var stringTable = new List<string>();
97 lookupTable = new Dictionary<string, int>();
98
99 foreach (DataRow row in data.Rows)
100 foreach (DataColumn column in data.Columns)
101 if (column.DataType == typeof(string))
102 {
103 var value = (string)row[column];
104
105 if (!lookupTable.ContainsKey(value))
106 {
107 lookupTable.Add(value, stringTable.Count);
108 stringTable.Add(value);
109 }
110 }
111
112 return stringTable;
113 }
114
115 public static void WriteStringTable(Stream output, IList<string> stringTable)
116 {
117 using (var writer = XmlWriter.Create(output))
118 {
119 writer.WriteStartDocument(true);
120
121 writer.WriteStartElement("sst", "http://schemas.openxmlformats.org/spreadsheetml/2006/main");
122 writer.WriteAttributeString("count", stringTable.Count.ToString(CultureInfo.InvariantCulture));
123 writer.WriteAttributeString("uniqueCount", stringTable.Count.ToString(CultureInfo.InvariantCulture));
124
125 foreach (var str in stringTable)
126 {
127 writer.WriteStartElement("si");
128 writer.WriteElementString("t", str);
129 writer.WriteEndElement();
130 }
131
132 writer.WriteEndElement();
133 }
134 }
135
136 public static string RowColumnToPosition(int row, int column)
137 {
138 return ColumnIndexToName(column) + RowIndexToName(row);
139 }
140
141 public static string ColumnIndexToName(int columnIndex)
142 {
143 var second = (char)(((int)'A') + columnIndex % 26);
144
145 columnIndex /= 26;
146
147 if (columnIndex == 0)
148 return second.ToString();
149 else
150 return ((char)(((int)'A') - 1 + columnIndex)).ToString() + second.ToString();
151 }
152
153 public static string RowIndexToName(int rowIndex)
154 {
155 return (rowIndex + 1).ToString(CultureInfo.InvariantCulture);
156 }
157
158 public static void WriteWorksheet(Stream output, DataTable data, IDictionary<string, int> lookupTable)
159 {
160 using (XmlTextWriter writer = new XmlTextWriter(output, Encoding.UTF8))
161 {
162 writer.WriteStartDocument(true);
163
164 writer.WriteStartElement("worksheet");
165 writer.WriteAttributeString("xmlns", "http://schemas.openxmlformats.org/spreadsheetml/2006/main");
166 writer.WriteAttributeString("xmlns:r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships");
167
168 writer.WriteStartElement("dimension");
169 var lastCell = RowColumnToPosition(data.Rows.Count - 1, data.Columns.Count - 1);
170 writer.WriteAttributeString("ref", "A1:" + lastCell);
171 writer.WriteEndElement();
172
173 writer.WriteStartElement("sheetViews");
174 writer.WriteStartElement("sheetView");
175 writer.WriteAttributeString("tabSelected", "1");
176 writer.WriteAttributeString("workbookViewId", "0");
177 writer.WriteEndElement();
178 writer.WriteEndElement();
179
180 writer.WriteStartElement("sheetFormatPr");
181 writer.WriteAttributeString("defaultRowHeight", "15");
182 writer.WriteEndElement();
183
184 writer.WriteStartElement("sheetData");
185 WriteWorksheetData(writer, data, lookupTable);
186 writer.WriteEndElement();
187
188 writer.WriteStartElement("pageMargins");
189 writer.WriteAttributeString("left", "0.7");
190 writer.WriteAttributeString("right", "0.7");
191 writer.WriteAttributeString("top", "0.75");
192 writer.WriteAttributeString("bottom", "0.75");
193 writer.WriteAttributeString("header", "0.3");
194 writer.WriteAttributeString("footer", "0.3");
195 writer.WriteEndElement();
196
197 writer.WriteEndElement();
198 }
199 }
200
201 public static void WriteWorksheetData(XmlTextWriter writer, DataTable data, IDictionary<string, int> lookupTable)
202 {
203 var rowsCount = data.Rows.Count;
204 var columnsCount = data.Columns.Count;
205 string relPos;
206
207 for (int row = 0; row < rowsCount; row++)
208 {
209 writer.WriteStartElement("row");
210 relPos = RowIndexToName(row);
211 writer.WriteAttributeString("r", relPos);
212 writer.WriteAttributeString("spans", "1:" + columnsCount.ToString(CultureInfo.InvariantCulture));
213
214 for (int column = 0; column < columnsCount; column++)
215 {
216 object value = data.Rows[row][column];
217
218 writer.WriteStartElement("c");
219 relPos = RowColumnToPosition(row, column);
220 writer.WriteAttributeString("r", relPos);
221
222 var str = value as string;
223 if (str != null)
224 {
225 writer.WriteAttributeString("t", "s");
226 value = lookupTable[str];
227 }
228
229 writer.WriteElementString("v", value.ToString());
230
231 writer.WriteEndElement();
232 }
233
234 writer.WriteEndElement();
235 }
236 }
237 }
238 }

1. DeleteDirectoryContents()方法用来清空临时目录的内容，该临时目录被用来存放解压Excel之后的文件。

2. UnzipFile()方法直接使用了开源类库中的ExtractZip()方法，将Excel文件解压到临时目录。

3. ZipDirectory()方法使用开源类库中的CreateZip()方法将临时目录中的内容重新打包成zip压缩文件。

4. ReadStringTable()方法用来读取xl/sharedStrings.xml文件中节点t的内容。其实应该是直接读取si节点的内容，应为并不是所有的si节点都有t子节点。

考虑一个情况：在Excel的单元格中，选中一部分内容，如内容中的某一个数字或某一个单词，然后对它单独设置样式。通过这种方法你可以将Excel单元格中的某一部分内容设置为粗体、上标，还可以在单元格内进行换行等。如下图：

在Excel单元格内设置的样式被存放到sharedStrings.xml文件中后会变成如下这种形式：

<si>
<r>
<t xml:space="preserve"> Short-term investments (including securities loaned
of </t>
</r>
<r>
<rPr>
<b/>
<sz val="8"/>
<color rgb="FF404040"/>
<rFont val="Verdana"/>
<family val="2"/>
</rPr>
<t>$9,999</t>
</r>
<r>
<rPr>
<sz val="8"/>
<color rgb="FF404040"/>
<rFont val="Verdana"/>
<family val="2"/>
</rPr>
<t xml:space="preserve"> and $8,888)</t>
</r>
</si>

这个时候节点si中的内容就不是单纯的子节点t了。因此，如何解析XML文件需要根据实际情况去考虑，这主要取决于你在Excel文件中存储的内容。

5. ReadWorksheet()方法会按照指定的工作表XML文件（如"xl/worksheets/sheet1.xml"）在sharedStrings.xml文件中查找数据，并将结果存放到一个DataTable中。

6. CreateStringTables()和WriteStringsTable()方法用来创建一个sharedStrings.xml文件。

7. WriteWorksheet()方法用来创建一个工作表XML文件。

来看看如何调用：

1 private void ReadInput(object sender, RoutedEventArgs e)
2 {
3 // Get the input file name from the text box.
4 var fileName = this.inputTextBox.Text;
5
6 // Delete contents of the temporary directory.
7 XlsxRW.DeleteDirectoryContents(tempDir);
8
9 // Unzip input XLSX file to the temporary directory.
10 XlsxRW.UnzipFile(fileName, tempDir);
11
12 IList<string> stringTable;
13 // Open XML file with table of all unique strings used in the workbook..
14 using (var stream = new FileStream(Path.Combine(tempDir, @"xl\sharedStrings.xml"),
15 FileMode.Open, FileAccess.Read))
16 // ..and call helper method that parses that XML and returns an array of strings.
17 stringTable = XlsxRW.ReadStringTable(stream);
18
19 // Open XML file with worksheet data..
20 using (var stream = new FileStream(Path.Combine(tempDir, @"xl\worksheets\sheet1.xml"),
21 FileMode.Open, FileAccess.Read))
22 // ..and call helper method that parses that XML and fills DataTable with values.
23 XlsxRW.ReadWorksheet(stream, stringTable, this.data);
24 }
25
26 private void WriteOutput(object sender, RoutedEventArgs e)
27 {
28 // Get the output file name from the text box.
29 string fileName = this.outputTextBox.Text;
30
31 // Delete contents of the temporary directory.
32 XlsxRW.DeleteDirectoryContents(tempDir);
33
34 // Unzip template XLSX file to the temporary directory.
35 XlsxRW.UnzipFile(templateFile, tempDir);
36
37 // We will need two string tables; a lookup IDictionary<string, int> for fast searching
38 // an ordinary IList<string> where items are sorted by their index.
39 IDictionary<string, int> lookupTable;
40
41 // Call helper methods which creates both tables from input data.
42 var stringTable = XlsxRW.CreateStringTables(this.data, out lookupTable);
43
44 // Create XML file..
45 using (var stream = new FileStream(Path.Combine(tempDir, @"xl\sharedStrings.xml"),
46 FileMode.Create))
47 // ..and fill it with unique strings used in the workbook
48 XlsxRW.WriteStringTable(stream, stringTable);
49
50 // Create XML file..
51 using (var stream = new FileStream(Path.Combine(tempDir, @"xl\worksheets\sheet1.xml"),
52 FileMode.Create))
53 // ..and fill it with rows and columns of the DataTable.
54 XlsxRW.WriteWorksheet(stream, this.data, lookupTable);
55
56 // ZIP temporary directory to the XLSX file.
57 XlsxRW.ZipDirectory(tempDir, fileName);
58
59 // If checkbox is checked, show XLSX file in Microsoft Excel.
60 if (this.openFileCheckBox.IsChecked == true)
61 System.Diagnostics.Process.Start(fileName);
62 }

你所要做的只是对XML进行操作，仅此而以！

支持.NET操作zip压缩包的类库应该还有很多，任何一个都可以，因为Excel的OpenXML文件本身就是一个标准的zip压缩包。但是上面的方法还是有一个局限性，那就是需要临时目录来存放解压之后的文件，以及重新打包时所指定的源文件。对普通的Windows应用程序或asp.net应用程序而言这个并没有什么困难，只要权限允许，读写临时目录没有任何问题，但是在Silverlight中则有所不同，因为在Silverlight中读写客户端文件需要比较高的安全级别和认证，这就导致解压文件会有困难，一个简单的方法就是直接在文件的流中进行解压和修改，然后再将流打包成zip文件。下一篇文章中我会向大家介绍如何在Silverlight中使用，以及如何定义一个类来完成Excel文件中某些字符串样式的修改。

本文链接

还有什么不能做？——细谈在C#中读写Excel系列文章之二

2012-05-09T22:27:00Z

在前一篇文章中我谈到了Excel 2007以后版本的文件其实就是一个zip压缩包，里面包含了该Excel文件的所有内容和使用的资源，大部分文件都是以XML的形式存放的。再来回顾一下解压之后的文件夹结构，

其中比较重要的是xl文件夹，里面包含了一些很有用的信息。sharedStrings.xml文件存放了Excel中所有的字符串数据。

worksheets文件夹中存放了所有的工作表信息，如果你的Excel文件中包含多个工作表，则这里你会发现有多个与工作表对应的xml文件。

来看一下sharedStrings.xml和工作表xml文件之间的关系。首先找到对应的工作表xml文件，如上图所示文件夹中的sheet3.xml，找到该xml文件的sheetData节点，下面包含有row节点，用来表示该工作表中的每一行，属性r代表行号。子节点c表示了该行中的每一个单元格，属性r表示单元格在Excel工作表的位置，如“A1”。注意属性t="s"，它表示该单元格的内容是存储在sharedStrings.xml文件中的，其子节点v的值用来说明该值在sharedStrings.xml文档中的位置。

sharedStrings.xml文件中包含有很多si节点，其中存放的就是Excel文件里各个工作表中的字符串数据。上图中v节点的值代表的就是sharedStrings.xml文件中si节点的序号，该序号从1开始计数。通过这个关系，我们就可以在sharedStrings.xml文件中找到我们想要的数据了。

弄清楚这个关系之后，我们再来看看如何通过代码取到我们想要的数据。从.NET Framework 3.0之后提供了一个新的类库可以帮助我们直接读取Excel包里面的文件。如果你的.NET工程是普通的Windows应用程序，那可以直接在工程中引用WindowsBase.dll类库。如果你的工程是非Windows应用程序，如Silverlight，则无法引用该类库，在后续的文章中我还会再介绍如何在Silverlight工程中读取Excel包里的文件。

还是直接上代码吧，写太多文字大家看得也累！

1 using System;
2 using System.Collections.Generic;
3 using System.ComponentModel;
4 using System.Data;
5 using System.Drawing;
6 using System.Linq;
7 using System.Text;
8 using System.Windows.Forms;
9 using System.IO;
10 using System.IO.Packaging;
11 using System.Xml;
12 using System.Xml.Linq;
13
14 namespace ExcelPackageOperator
15 {
16 public partial class Form1 : Form
17 {
18 public Form1()
19 {
20 InitializeComponent();
21
22 List<Cell> parsedCells = new List<Cell>();
23 string fileName = @"C:\Users\jaxu\Desktop\Example.xlsx";
24
25 using(Package xlsxPackage = Package.Open(fileName, FileMode.Open, FileAccess.Read))
26 {
27 // load sharedStrings.xml document from Excel package
28 PackagePartCollection allParts = xlsxPackage.GetParts();
29 PackagePart sharedStringsPart = (from part in allParts
30 where part.Uri.OriginalString.Equals("/xl/sharedStrings.xml")
31 select part).Single();
32
33 // load to XElement from sharedStrings.xml document
34 XElement sharedStringsElement = XElement.Load(XmlReader.Create(sharedStringsPart.GetStream()));
35
36 // read all fixed text to a dictionary from sharedStrings document
37 Dictionary<int, string> sharedStrings = new Dictionary<int, string>();
38 ParseSharedStrings(sharedStringsElement, sharedStrings);
39
40 // get worksheet 1
41 XElement worksheetElement = GetWorksheet(3, allParts);
42
43 IEnumerable<XElement> cells = from c in worksheetElement.Descendants(ExcelNamespaces.excelNamespace + "c")
44 select c;
45
46 foreach (XElement cell in cells)
47 {
48 if (cell.HasElements && cell.Attribute("t") != null && cell.Attribute("t").Value.Equals("s"))
49 {
50 string cellPosition = cell.Attribute("r").Value;
51 int index = IndexOfNumber(cellPosition);
52 string column = cellPosition.Substring(0, index);
53 int row = Convert.ToInt32(cellPosition.Substring(index, cellPosition.Length - index));
54 int valueIndex = Convert.ToInt32(cell.Descendants(ExcelNamespaces.excelNamespace + "v").Single().Value);
55
56 parsedCells.Add(new Cell(column, row, sharedStrings[valueIndex]));
57 }
58 }
59 }
60
61 //From here is additional code not covered in the posts, just to show it works
62 foreach (Cell cell in parsedCells)
63 {
64 this.textBox1.Text += cell.ToString() + "\r\n";
65 //Console.WriteLine(cell);
66 }
67 }
68
69 private void ParseSharedStrings(XElement SharedStringsElement, Dictionary<int, string> sharedStrings)
70 {
71 IEnumerable<XElement> sharedStringsElements = from s in SharedStringsElement.Descendants(ExcelNamespaces.excelNamespace + "si")
72 select s;
73
74 int Counter = 0;
75 foreach (XElement sharedString in sharedStringsElements)
76 {
77 sharedStrings.Add(Counter, sharedString.Value); Counter++;
78 }
79 }
80
81 private XElement GetWorksheet(int worksheetID, PackagePartCollection allParts)
82 {
83 PackagePart worksheetPart = (from part in allParts
84 where part.Uri.OriginalString.Equals(String.Format("/xl/worksheets/sheet{0}.xml", worksheetID))
85 select part).Single();
86 return XElement.Load(XmlReader.Create(worksheetPart.GetStream()));
87 }
88
89 private int IndexOfNumber(string value)
90 {
91 for (int counter = 0; counter < value.Length; counter++)
92 {
93 if (char.IsNumber(value[counter]))
94 {
95 return counter;
96 }
97 }
98
99 return 0;
100 }
101 }
102
103 internal static class ExcelNamespaces
104 {
105 internal static XNamespace excelNamespace = XNamespace.Get("http://schemas.openxmlformats.org/spreadsheetml/2006/main");
106 internal static XNamespace excelRelationshipsNamepace = XNamespace.Get("http://schemas.openxmlformats.org/officeDocument/2006/relationships");
107 }
108
109 public class Cell
110 {
111 public Cell(string column, int row, string data)
112 {
113 this.Column = column;
114 this.Row = row;
115 this.Data = data;
116 }
117
118 public override string ToString()
119 {
120 return string.Format("{0}:{1} - {2}", Row, Column, Data);
121 }
122
123 public string Column
124 {
125 get; set;
126 }
127
128 public int Row
129 {
130 get; set;
131 }
132
133 public string Data
134 {
135 get; set;
136 }
137 }
138 }

1. 使用Package类直接打开Excel文件，该类属于System.IO.Packing命名空间，必须确保工程中引用了WindowsBase.dll类库。

2. 通过GetParts()方法读取包里面的内容。注意LINQ语句取到的是sharedStrings.xml文件。

3. 将读取到的sharedStrings.xml文件加载到XElement对象中，然后通过PaseSharedStrings这个自定义函数读取里面所有的si子节点并存放到一个字典里。

4. 自定义函数GetWorksheet用来将指定的工作表xml从包中读取出来加载到XElement对象中。

5. 程序接下来的部分就是遍历工作表xml中所有的节点c，并从属性r中找出单元格的行编号和列编号。然后将准备好的数据存储到parsedCells集合中，该集合的类型是一个自定义的Cell对象，该对象包含三个属性（行编号、列编号和数据内容）和一个改写的ToString()方法，该方法用来定义数据输出格式。

注意数据是从字典中取出来的，字典的Key值就是节点r的子节点v的值！还记得文章一开始我们介绍的sharedStrings.xml文件和工作表xml文件之间的关系吗？这里就是借用的这个关系。另外在遍历工作表xml中的节点c时是过滤掉了那些不包含有属性t="s"的节点的，因为这些节点直接存储了数据，而不需要再从sharedStrings.xml去取。

6. 输出parsedCells集合中的数据。

好了，程序的结构就是这样。代码可能稍稍有点长，只看主要的部分，其实还是很简单的：借用WindowsBase类库中的System.IO.Packing.Package对象来读取Excel包里的内容，然后找出sharedStrings.xml文件中的所有字符串数据并存放到一个字典中，遍历你想要操作的工作表xml文件，按单元格的位置从字典中找出对应的数据显示出来。

不过还是有一个遗憾。在使用.NET现有的功能时总会遇到一些问题！该对象并没有提供对Excel文件的修改和保存功能，至少我没有发现。也就是说它可以允许我们在不调用COM组件的情况下非常方便地读取Excel文件中的数据，包括字符串和数字。另外还有一个问题就是该类库不能在Silverlight工程中引用，如果你刚好想在Silverlight工程中使用该功能那么只能想其它的方法了。不过有一个问题值得思考，那就是既然Excel是一个zip压缩包，而且里面大部分的数据都是以xml文件的格式存储的，我们何不自己写代码解压然后读取或者修改xml文件呢？甚至我们还可以把修改之后的文件重新打包还原成一个新的Excel文件，这样的话我们就可以实现Excel文件内容的修改，而且也可以在Silverlight工程中使用了。

我会在接下来的文章中介绍如何把Excel文件作为zip压缩包来进行操作，包括读取和修改。

本文链接

还有什么不能做？——细谈在C#中读写Excel系列文章之一

2012-05-08T22:56:00Z

在写这一系列文章之前，我要首先申明一个事情，那就是自打.NET一开始我们大概就已经开始使用它在自己的程序中与Excel进行交互了，诸如从Excel中读取数据显示报表、将程序中的数据导出到Excel中等等。这个看似很平常，而且我相信有很多的人都写过或看过类似的程序。在早期版本的.NET中我们需要在Windows中执行一个命令（时间太久我也不太记得这个命令叫什么了）来将Office COM组件变成托管代码以便在.NET程序中调用，后来的.NET Framework可以完全支持Office COM组件的调用，但需要在工程中添加引用。但是无论怎样，我们在程序中都是对Office COM组件进行操作，这样会有许多不便，无论从程序执行效率上还是代码编辑上都会让你感觉很别扭。

那现在又有什么不同呢？

我的意思是说如果你的程序运行的环境没有安装Office，或者说运行环境中没有注册Office COM组件，那会怎样？

你可能会说那不是程序本身的问题，我们甚至可以要求客户提供Office COM组件。但是请注意，如果你的程序要求跨平台使用，而Office COM组件在目标平台上并不受支持（怎么会有这么奇怪的需求？！），你可能会遇到点麻烦。这个时候我们可以考虑在程序中提供一个替代的选项来禁用相应的功能，从而避免程序错误地使用并不存在的Office COM组件。

不过，如果能有一个行之有效的办法解决所有的问题难道不是一件令人兴奋的事情吗？我们可否绕过Office COM组件而直接对文件本身进行操作呢？（有点痴心妄想了）这个想法有点夸张，在早期版本的Excel文件中（应该是在Excel 2007之前）几乎是行不通的，但从Excel 2007之后这个事情变得可行了。

在Excel 2007之后的版本中，文件名的后缀变成XLSX了，其实这个也是SpreadsheetXL。我们有三种方法可以操作它：自己写解析器分析文件中的内容，这个可能会比较麻烦；第二种是使用Microsoft提供的OpenXML SDK来操作Excel文件，OPENXML SDK到目前为止应该有两个版本，而且包含的功能还是很丰富的；第三种就是直接使用自.NET Framework 3.0之后提供的新功能直接操作Excel文件。

先介绍下什么是XLSX文件。看下面这个图就明白了。

XLSX文件本身就是一个压缩包，里面包含了Excel文件中所有的数据和样式，包括一些资源文件（如图片、链接等等），这些文件几乎都以XML的形式放在压缩包里不同的文件夹中。只要我们熟悉了这些XML文件的结构以及不同文件夹的用途，就可以非常方便地以ZIP压缩文件的形式操作XLSX文件了。下面这个图就是解压XLSX文件后的内容：

稍后我会介绍如何通过各种不同的方式来使用XLSX文件以及各种不同的应用。但在这之前我想先说一下Excel的REST应用。这里有几个链接可以帮助你了解什么是Excel REST应用。

http://msdn.microsoft.com/en-us/library/ee556820.aspx

http://www.cnblogs.com/dwang/archive/2010/12/08/1899983.html

http://msdn.microsoft.com/en-us/library/hh124646.aspx

Excel REST是SharePoint Excel Services提供的一个用来访问Excel文件的服务，我们只需要通过一个简单的URL就可以得到Excel文件中的数据，使用非常方便。而且我们还可以通过这个URL来修改Excel中某些单元格的数据，甚至获取或修改图表。具体的使用方法和例子大家可以查看MSDN，上面会有非常详细的介绍。

在使用Excel REST服务返回Range数据时，如果所对应的工作表有自定义名称，URL应该是怎样的？这里有几个例子：

读取Student表，范围从A1到G5，注意%7C是转义之后的冒号。

http://<ServerName>/_vti_bin/ExcelRest.aspx/ExcelTemplates/sampleWorkbook.xlsx/Model/Ranges('Student!A1%7CG5')?$format=html

读取Teacher and Student表，范围从D5到CG27。注意表名中的空格可能需要进行转义。另外就是表名用了两个单引号括起来。

http://<ServerName>/_vti_bin/ExcelRest.aspx/ExcelTemplates/sampleWorkbook.xlsx/Model/Ranges('''Teacher%20and%20Student''!D5%7CCG27')?$format=html

读取Teacher表，范围为A10单元格。注意表名也用了两个单引号括起来。

http://<ServerName>/_vti_bin/ExcelRest.aspx/ExcelTemplates/sampleWorkbook.xlsx/Model/Ranges('''Teacher''!A10%7CA10')?$format=html

在Excel中，自定义的表名可以用两个单引号括起来。Excel REST Services返回的数据类型有三种：html、atom和xml。注意atom是RSS的格式，如果返回的数据类型不符合RSS规范则无法显示。

本文链接

如何在XSLT中将字符串转换为大写或小写形式

2012-04-16T17:31:00Z

查阅w3school的文档，你会看到XSLT提供了两个系统函数用于转换字符串的大小写形式：upper-case()和lower-case()。但是这两个函数是针对于XSLT2.0以上版本的，Microsoft所使用的XSLT都是1.0版本的，所以当你在代码中使用这两个函数时会提示无效。这里有一个替代的解决方案，使用translate()函数可以解决这个问题。

<xsl:variable name="smallcase" select="'abcdefghijklmnopqrstuvwxyz'" />
<xsl:variable name="uppercase" select="'ABCDEFGHIJKLMNOPQRSTUVWXYZ'" />

<xsl:template match="/">
<xsl:value-of select="translate(doc, $smallcase, $uppercase)" />
</xsl:template>

事先定义好两个变量，用于存储英文中26个字母的大小写形式，然后在translate()函数中对要进行的字符串进行转换。上例中是将字符串转换为大写形式，颠倒$smallcase和$uppercase两个变量的位置实现将字符串转换为小写形式。

本文链接

XSLT解析InfoPath生成的XML文件并去掉文件中的InfoPath额外信息

2012-04-12T23:29:00Z

InfoPath表单用来生成模板所规定格式的XML文档，但是在生成的XML文件中常常会包含一些额外信息，这些信息也是以节点的形式出现在XML文件中，并且在根节点之外，主要用于在IE中识别该XML文件是用InfoPath表单生成的可以直接用InfoPath打开，如果你在其它的浏览器中打开这些文件，则不会出现文件打开的提示。这些额外信息在程序中处理的时候难免会带来一些麻烦，影响我们对XML节点的处理和操作。这些额外信息可以在C#中找到相应的对象，看我的另一篇文章http://www.cnblogs.com/jaxu/archive/2011/10/04/2198752.html。

例如我有一个非常简单的页面，功能就是把指定的XML文件原样输出到页面上，我考虑用XSLT对象来解析这些XML文件，然后把结果输出到页面上。XSLT中的代码应该非常简单，只需要将所有的节点原样输出就行了。

然后在C#代码中使用XPathDocument和XslCompiledTransform来转换输出结果。但是我发现这样做在IE中打开页面的时候总是提示要打开文件，原因就是因为IE识别出了这些XML文件中的InfoPath的额外信息。当然，如果你用FireFox打开的话则不会出现提示，而且你还能看到那些额外信息也被解析出来了。最简单的解决办法就是在输出之前将这些额外信息去掉，你完全可以在C#里来实现，这里给出用XSLT的实现方法。

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="msxsl"
>
<xsl:output indent="yes" omit-xml-declaration="yes" method="xml" />



<xsl:template match="/">

<xsl:apply-templates select="@*[namespace-uri()='']|node()"/>
</xsl:template>


<xsl:template match="node()">

<xsl:element name="{name()}" namespace="{namespace-uri()}">

<xsl:apply-templates select="@*[namespace-uri()='']|node()"/>
</xsl:element>
</xsl:template>


<xsl:template match="@*|text()|comment()">
<xsl:copy/>
</xsl:template>


<xsl:template match="processing-instruction('mso-infoPathSolution')">

</xsl:template>


<xsl:template match="processing-instruction('mso-application')">

</xsl:template>


<xsl:template match="processing-instruction('MicrosoftWindowsSharePointServices')">

</xsl:template>

</xsl:stylesheet>

代码中使用了XSLT的template匹配以及系统函数，在匹配到InfoPath额外信息节点时什么也不输出，从而在最终的输出结果中将InfoPath额外信息过滤掉。

本文链接

使用Microsoft Expression Encoder将音频转换为视频并配上背景图片或背景音乐

2012-04-06T22:45:00Z

Microsoft Expression Encoder是Microsoft Expression产品中的一部分，它主要的功能是转换和重新编码媒体文件，如将视频或音频文件转换为Web支持的格式，或者进行各种音视频文件格式之间的转换，将媒体文件转换为Microsoft Smooth Streaming支持的格式或者Silverlight媒体文件格式等。Encoder提供的功能很强大，而且非常专业，大家可以去微软的官方站点查看介绍和下载使用版本，http://www.microsoft.com/download/en/details.aspx?id=19652。

有关如何在Encoder中转换Smooth Streaming格式的文件请看我另一篇较早的文章http://www.cnblogs.com/jaxu/archive/2010/01/08/1642143.html。

本文主要介绍下如何在Encoder中将音频格式的文件转换为视频格式，并且添加播放时的背景图片或背景音乐。

1. 打开Expression Encoder导入一个你想要转换的音频文件。直接点击Encoder窗体下方的Import按钮即可。导入成功后Encoder会给出该音频文件的相关信息并显示在Media Content中，如下图：

2. 在窗体的右侧选择Encode tab，然后选择输出格式。由于导入的媒体文件是音频格式，所以默认情况下Video复选框是没有被选上的。勾选Video，然后可以根据需要选择不同的Video和Audio的编码格式。Encoder给出了很多用来进行媒体文件转换的选项，如进行文件截取Clips，修改尺寸，比特率、帧率等等。

3. 在Output tab中选择好输出文件的位置，然后直接点击窗体下方的Encode按钮就可以开始转换工作了。转换时间的长短取决于被转换文件的大小和机器的性能，一般情况下几十兆的文件转换时间大概在几分钟左右。

4. 因为是将音频文件转换为视频格式，因此转换完后在Windows Media Player中播放时是没有画面的，也就是说用户体验并不好。Encoder允许你给视频提供Overlay image，也就是在视频播放的时候放置在视频上方的图片，我们可以使用该功能添加背景图片。在设置窗口中选择Enhance tab，然后在Visual Overlay中勾选Add Overlay，在弹出的对话框中选择你要添加的图片。你还可以设置该图片在视频中的什么时间段显示，以及透明度、大小和位置等等。这里我们直接选择Maintain Aspect Radio，意思就是说图片的长宽比是固定的，这样的话当你放大和缩小视频播放起时图片的大小会自动调整。同样，在Audio Overlay中你还可以添加背景音乐，方法与Visual Overlay类似。

你可以看到进度条上方绿色的duration以及你所使用的Visual Overlay图片的文件名，可以选择Visual Overlay图片在视频的什么时间段内显示。当然，如果你要转换的文件本身就是视频文件并且包含有真实的视频内容，则你可以借用该功能添加说明内容的图片或者广告等等。下面是转换完成后在Windows Media Player中播放时的效果。

本文链接

SQL Server打开数据表中的XML内容时报错的解决办法

2012-02-15T06:40:00Z

从SQL Server2005开始提供了一种新的数据类型XML type，它允许用户将数据以XML文件的格式直接存储到数据表中。结合在ASP.NET中使用Linq to Sql，我们可以非常方便地将XML文件存储到SQL Server数据库中。但是在默认情况下，如果你存储的XML文件比较大（超过2MB），在SQL Server管理器中不能直接点击查看XML内容而报以下错误提示：

如何解决该问题呢？很简单，其实错误提示中已经描述地很清楚了，在SQL Server Management Studio中点击Tools菜单，选择Options。然后找到下图对应的设置节点，将XML data的最大字符限制改成Unlimited（无限制）即可。

默认情况下，SQL Server为了提高查询效率，在Management Studio中最多只返回小于2MB的XML数据内容，如果你存储的XML文件的内容大于2MB则剩余的字符会自动被截断，从而在打开的时候出错。

本文链接

IE9不能在线打开InfoPath表单的解决办法

2012-01-31T09:25:00Z

在IE9中，我们在线打开SharePoint文档库中的InfoPath表单时会出现下面的错误，如何解决这个问题？

1. 在IE9的工具栏上单击右键，选择Menu bar，显示菜单栏。

2. 在菜单栏中选择Tools->Compatibility View Settings，在打开的窗口中将当前站点添加到兼容性视图的列表中。

3. 点击确定，刷新页面。然后就可以IE9中在线打开InfoPath表单了。当然，你也可以勾选Display all websites in Compatibility View，这样所有的站点都会默认在兼容模式下打开，也就不会出现无法在线打开InfoPath表单的问题了。

本文链接

日期和时间处理的类库

2011-12-31T01:31:00Z

发一个专门处理时间和日期的类库，记录以备查询。

using System;

namespace Utilities
{
/// <summary>
/// Common DateTime Methods.
/// </summary>
///
public enum Quarter
{
First = 1,
Second = 2,
Third = 3,
Fourth = 4
}

public enum Month
{
January = 1,
February = 2,
March = 3,
April = 4,
May = 5,
June = 6,
July = 7,
August = 8,
September = 9,
October = 10,
November = 11,
December = 12
}

public class DateUtilities
{
#region Quarter

public static DateTime GetStartOfQuarter( int Year, Quarter Qtr )
{
if( Qtr == Quarter.First ) // 1st Quarter = January 1 to March 31
return new DateTime( Year, 1, 1, 0, 0, 0, 0 );
else if( Qtr == Quarter.Second ) // 2nd Quarter = April 1 to June 30
return new DateTime( Year, 4, 1, 0, 0, 0, 0 );
else if( Qtr == Quarter.Third ) // 3rd Quarter = July 1 to September 30
return new DateTime( Year, 7, 1, 0, 0, 0, 0 );
else // 4th Quarter = October 1 to December 31
return new DateTime( Year, 10, 1, 0, 0, 0, 0 );
}

public static DateTime GetEndOfQuarter( int Year, Quarter Qtr )
{
if( Qtr == Quarter.First ) // 1st Quarter = January 1 to March 31
return new DateTime( Year, 3, DateTime.DaysInMonth( Year, 3 ), 23, 59, 59, 999 );
else if( Qtr == Quarter.Second ) // 2nd Quarter = April 1 to June 30
return new DateTime( Year, 6, DateTime.DaysInMonth( Year, 6 ), 23, 59, 59, 999 );
else if( Qtr == Quarter.Third ) // 3rd Quarter = July 1 to September 30
return new DateTime( Year, 9, DateTime.DaysInMonth( Year, 9 ), 23, 59, 59, 999 );
else // 4th Quarter = October 1 to December 31
return new DateTime( Year, 12, DateTime.DaysInMonth( Year, 12 ), 23, 59, 59, 999 );
}

public static Quarter GetQuarter( Month month )
{
if( month <= Month.March ) // 1st Quarter = January 1 to March 31
return Quarter.First;
else if( ( month >= Month.April ) && ( month <= Month.June ) ) // 2nd Quarter = April 1 to June 30
return Quarter.Second;
else if( ( month >= Month.July ) && ( month <= Month.September ) ) // 3rd Quarter = July 1 to September 30
return Quarter.Third;
else // 4th Quarter = October 1 to December 31
return Quarter.Fourth;
}

public static DateTime GetEndOfLastQuarter()
{
if( DateTime.Now.Month <= (int)Month.March ) //go to last quarter of previous year
return GetEndOfQuarter( DateTime.Now.Year - 1, GetQuarter( Month.December ));
else //return last quarter of current year
return GetEndOfQuarter( DateTime.Now.Year, GetQuarter( (Month)DateTime.Now.Month));
}

public static DateTime GetStartOfLastQuarter()
{
if( DateTime.Now.Month <= 3 ) //go to last quarter of previous year
return GetStartOfQuarter( DateTime.Now.Year - 1, GetQuarter( Month.December ));
else //return last quarter of current year
return GetStartOfQuarter( DateTime.Now.Year, GetQuarter( (Month)DateTime.Now.Month));
}

public static DateTime GetStartOfCurrentQuarter()
{
return GetStartOfQuarter( DateTime.Now.Year, GetQuarter( (Month)DateTime.Now.Month ));
}

public static DateTime GetEndOfCurrentQuarter()
{
return GetEndOfQuarter( DateTime.Now.Year, GetQuarter( (Month)DateTime.Now.Month ));
}
#endregion

#region Weeks
public static DateTime GetStartOfLastWeek()
{
int DaysToSubtract = (int)DateTime.Now.DayOfWeek + 7;
DateTime dt = DateTime.Now.Subtract( System.TimeSpan.FromDays( DaysToSubtract ) );
return new DateTime( dt.Year, dt.Month, dt.Day, 0, 0, 0, 0 );
}

public static DateTime GetEndOfLastWeek()
{
DateTime dt = GetStartOfLastWeek().AddDays(6);
return new DateTime( dt.Year, dt.Month, dt.Day, 23, 59, 59, 999 );
}

public static DateTime GetStartOfCurrentWeek()
{
int DaysToSubtract = (int)DateTime.Now.DayOfWeek ;
DateTime dt = DateTime.Now.Subtract( System.TimeSpan.FromDays( DaysToSubtract ) );
return new DateTime( dt.Year, dt.Month, dt.Day, 0, 0, 0, 0 );
}

public static DateTime GetEndOfCurrentWeek()
{
DateTime dt = GetStartOfCurrentWeek().AddDays(6);
return new DateTime( dt.Year, dt.Month, dt.Day, 23, 59, 59, 999 );
}
#endregion

#region Months

public static DateTime GetStartOfMonth( int Month, int Year )
{
return new DateTime( Year, Month, 1, 0, 0, 0, 0 );
}

public static DateTime GetEndOfMonth( int Month, int Year )
{
return new DateTime( Year, Month, DateTime.DaysInMonth( Year, Month ), 23, 59, 59, 999 );
}

public static DateTime GetStartOfLastMonth()
{
if( DateTime.Now.Month == 1 )
return GetStartOfMonth( 12, DateTime.Now.Year - 1);
else
return GetStartOfMonth( DateTime.Now.Month -1, DateTime.Now.Year );
}

public static DateTime GetEndOfLastMonth()
{
if( DateTime.Now.Month == 1 )
return GetEndOfMonth( 12, DateTime.Now.Year - 1);
else
return GetEndOfMonth( DateTime.Now.Month -1, DateTime.Now.Year );
}

public static DateTime GetStartOfCurrentMonth()
{
return GetStartOfMonth( DateTime.Now.Month, DateTime.Now.Year );
}

public static DateTime GetEndOfCurrentMonth()
{
return GetEndOfMonth( DateTime.Now.Month, DateTime.Now.Year );
}
#endregion

#region Years
public static DateTime GetStartOfYear( int Year )
{
return new DateTime( Year, 1, 1, 0, 0, 0, 0 );
}

public static DateTime GetEndOfYear( int Year )
{
return new DateTime( Year, 12, DateTime.DaysInMonth( Year, 12 ), 23, 59, 59, 999 );
}

public static DateTime GetStartOfLastYear()
{
return GetStartOfYear( DateTime.Now.Year - 1 );
}

public static DateTime GetEndOfLastYear()
{
return GetEndOfYear( DateTime.Now.Year - 1 );
}

public static DateTime GetStartOfCurrentYear()
{
return GetStartOfYear( DateTime.Now.Year );
}

public static DateTime GetEndOfCurrentYear()
{
return GetEndOfYear( DateTime.Now.Year );
}
#endregion

#region Days

public static DateTime GetStartOfDay( DateTime date )
{
return new DateTime( date.Year, date.Month, date.Day, 0, 0, 0, 0 );
}

public static DateTime GetEndOfDay( DateTime date )
{
return new DateTime( date.Year, date.Month, date.Day, 23, 59, 59, 999 );
}

#endregion
}
}

本文链接