1. If you want to exit you app without calling any finalizers or finally blocks use:

Environment.FailFast();

2. Instead of

sting filePath = directoryPath + “\” + filename;

you can use:

sting filePath = System.IO.Path.Combine(directoryPath, filename);

3. Forget about “rn” for new line, you can use Environment.NewLine instead. It’s better because it’s system independent

4. You can create a typed reference from a variable:

int i = 100;

TypedReference typeRef = __makeref(i);

5. From the example above, you can extract the original type:

Type type = __reftype(typeRef);

6. You can extract the value from TypedReference:

int j = __refvalue(typeRef, int);

7. You can use the ‘@’ character in the beginning of variable names. It’s suitable to be used for vars:

var @obj = new object();

8. If you want the garbage collector to collect some object while it can be accessed by the application, you can use the System.WeakReference class, you can read more about it HERE.

P.S. I’ve test all the examples above under .NET Frawork 3.5.

I think if the enum will be used by a single class then you should add the enum declaration inside the class. But if the enum is global and will be used by many classes you can create a new file where you can add declarations of all globally used enums. But to create separate files for all enums it too wasteful

using System.Collections.Generic;

…

public static Dictionary<string, string> dict = new Dictionary<string, string>() {
{“key 1″, “value 1″},
{“key 2″, “value 2″},
{“key 3″, “value 3″}
};

That’s all. It’s similar to the array declaration

http://site.com

www.site.com

https://site.com

https://www.site.com

Even more, I wanted after url detection, it to be replaced with:

http://site.com -> http://site.com

www.site.com -> http://www.site.com

https://site.com -> https://site.com

https://www.site.com -> https://www.site.com

I use Regex’s Replace method. It detects all urls and replaces them with the correct format. Here is the full example:

string originalText;

…

string convertedText = Regex.Replace(originalText,
@”((http(?<http1>(s?))://(?<www1>(www.)))|(http(?<http2>(s?))://)|((?<www2>(www.))))(?<url>([wd:#@%/;$()~_?+-=\.&]*))”,
@”http${http1}${http2}://${www1}${www2}${url}”);

…

P.S. I hope that the example above could be useful to someone else, too. If you find some bug or suggestion, I’ll be very thankful to hear how it can be fixed

In this example:
1) Create some string array that represent table data
2) Create a new Docx file and init it
3) Create styles for the table and fill it with data
4) Fill the table with data
5) Add the table to the document and save the changes

//t some data to export in table
string[][] data = {new string[]{“column 1″, “column 2″, “column 3″, “column 4″, “column 5″},
new string[]{“A”, “B”, “C”, “D”, “E”},
new string[]{“1″, “2″, “3″, “4″, “5″},
new string[]{“Dev”, “The”, “Web”, “dot”, “NET”}
};

/*t create and init a new docx file and
a WordprocessingDocument object to represent it t*/
WordprocessingDocument doc = WordprocessingDocument.Create(“E:\dox-export.docx”,
WordprocessingDocumentType.Document);

MainDocumentPart mainDocPart = doc.AddMainDocumentPart();
mainDocPart.Document = new Document();
Body body = new Body();
mainDocPart.Document.Append(body);

/*t init the cell border styles t*/
TableCellProperties cellProperties = new TableCellProperties(
new TableCellBorders
{
TopBorder = new TopBorder
{
Val = new EnumValue<BorderValues>(BorderValues.BasicBlackDots),
Size = new UInt32Value((uint)8),
Color = new StringValue(“000000″)
},
RightBorder = new RightBorder
{
Val = new EnumValue<BorderValues>(BorderValues.BasicBlackDots),
Size = new UInt32Value((uint)8),
Color = new StringValue(“000000″)
},
BottomBorder = new BottomBorder
{
Val = new EnumValue<BorderValues>(BorderValues.BasicBlackDots),
Size = new UInt32Value((uint)8),
Color = new StringValue(“000000″)
},
LeftBorder = new LeftBorder
{
Val = new EnumValue<BorderValues>(BorderValues.BasicBlackDots),
Size = new UInt32Value((uint)8),
Color = new StringValue(“000000″)
},
});

/*t fill the string[][] data into
DocumentFormat.OpenXml.Wordprocessing.Table object t*/

Table table = new Table();
for (int i = 0; i < data.Length; ++i)
{
TableRow row = new TableRow();

for (int j = 0; j < data[i].Length; ++j)
{
TableCell cell = new TableCell(cellProperties.Clone() as TableCellProperties);

cell.Append(new Paragraph(
new Run(
new Text(data[i][j])
)));

row.Append(cell);
}

table.Append(row);
}

/*t add some info about the dox export t*/
body.Append(new Paragraph(
new Run(
new Text(“Table exported by DevTheWeb.NET”)
)));

body.Append(table);

/*t don’t forget to save your changes t*/
doc.MainDocumentPart.Document.Save();
doc.Dispose();

That’s all, if we open the dox file, we can see the exported table:

What is Open XML and Open XML SDK?

Open XML is an open standard that defines a set of XML schemas for representing spreadsheets, presentations, charts and word processing documents. Microsoft Office 2007 applications (Word, Excel and PowerPoint) use the Open XML as the default file format. The Open XML file formats are based on ZIP and XML.

The Open XML SDK 2.0 provides classes to manipulate Open XML documents. The Open XML SDK 2.0 uses the LINQ (Language-Integrated Query) technology to provide strongly typed object access to the XML content inside the parts of the Open XML documents.

Download and Install

You can download Open XML SDK 2.0 HERE.

System Requirements:

• OS: Windows 7; Windows Server 2003 SP 2; Windows Server 2008 R2; Windows Server 2008 SP 2; Windows Vista SP 2; Windows XP SP 3
• .NET Framework version 3.5 SP1
• At least 300 MB available disk space

Using the Open XML API 2.0 in Visual Studio 2008 Project

To use the API in your Visual Studio project, all you need to do is to add Reference to DocumentFormat.OpenXml:

In Solution Explorer, right-click References and select Add Reference.

In the dialog box, select .NET tab and select DocumentFormat.OpenXml option and then click OK.

Read Docx’s Text

It’s very easy to read the text of Word 2007 Document file, here’s an example:

using System.IO;
using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;

//t local variables
WordprocessingDocument doc;
string result = “”;

try
{
//t load the .docx document
doc = WordprocessingDocument.Open(stringForFilePath, false);

result = (doc.MainDocumentPart.Document).Body.InnerText;
}
catch (Exception ex)
{
//t handle the exception
}

return result;

Conclusion
At first look it seems to be easy to work with the Open XML 2.0 SDK, it’s easy to install use in Visual Studio 2008. I created a simple program that loads text from docx file:

You can download it HERE.

may find useful the following table of comparison between WCF Web Services and Standard Web Services.

It seems that WCF offers much more portability and flexibility to develop a service when comparing to web service.

The bad news is that only 52.7% of the users has .NET Framework 3.5 installed on their PCs, but as you can see from the table they become more and more very fast

P.S. The latest information about .NET version penetration was for October 2009, if you found newer I’ll be very thankful to post a link to it as a comment and I’ll update the table above.