Beth Massi - Sharing the goodness that is VB : XML

Silicon Valley Code Camp Oct. 3-4 : Schedule is up!

Beth Massi — Mon, 28 Sep 2009 22:37:25 GMT

As I mentioned before, I’ll be speaking this weekend at Silicon Valley Code Camp (http://siliconvalley-codecamp.com/). This is a FREE event at at Foothill College and it’s not just Microsoft technologies. A lot of great speakers will be there too.

The schedule is up so check it out and mark the ones you plan on attending. I’ll be presenting two sessions on Saturday:

Also on Sunday there will be a Cloud Camp Unconference where early adopters of cloud computing technologies can exchange ideas and give insight on how to plan for and take advantage of cloud computing.

There are already over 1300 people registered so it’s sure to be a great event. Register today!

See you this weekend!

Merging Text & Photos into a Word Document using Open XML SDK

Beth Massi — Fri, 25 Sep 2009 00:55:10 GMT

Yesterday I posted about how we could create a letter generator (mail merge) that took data from a database to create a Word 2007 document using the System.IO.Packaging class. I showed how to take data from Northwind using a single LINQ query to create XDocument objects representing letters to customers and then create a single document of all the data using XML Literals.

Today I want to show how we can embed images into the documents as well as text. Since we’re using Northwind for this example, we’ll use the Employee.Photo field from that database.

The Letter Template with Photo

The first thing to do is create a letter template with our field placeholders as well as an image placeholder. We’ll also need to insert a page break at the end because we’re going to merge all the letters into a single document for easy printing:

The next step is to grab the document.xml from this docx file. Because it’s an Open XML package, as I showed in yesterday’s post, we can just rename this file with a .zip extension temporarily and drill into the word\document.xml. However, there’s an easier way to work with these packages by installing the Open XML package editor Visual Studio add-in from the VSTO Power Tools download.

Once you install the VSTO Power tools, save this template in your project. Then you can just double-click on the .docx file in the Solution Explorer and it will open the package editor (it also works with .pptx and .xslx files). Now you can drill into the document.xml directly in Visual Studio and inspect all the parts of the package easily.

The difference between this template and the template we used yesterday is there is an image imbedded into the document. So you will see an image embedded into the package in the media folder. This is referred to as an “image part”. This part is linked to the “main document part” which is the word\document.xml file. The Open XML package editor shows the links (relationships) to all the parts. When you look at the relationship properties you’ll see that it has a unique ID. This is the same ID that you will see in the main document part at the point where we embedded the image, in our case it’s set to rId4. (I’ve omitted all the WordProccessingML for clarity):

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<w:document ...
  <w:body> ...

        <w:drawing> ...

              <a:graphic xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main">
              <a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture">
                <pic:pic xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture">
                  <pic:nvPicPr>
                    <pic:cNvPr id="0" name="image1.png"/>
                    <pic:cNvPicPr/>
                  </pic:nvPicPr>
                  <pic:blipFill>
                    <a:blip r:embed="rId4" cstate="print"/>
                    <a:stretch>
                      <a:fillRect/>
                    </a:stretch>
                  </pic:blipFill>
                  <pic:spPr>
                    <a:xfrm>
                      <a:off x="0" y="0"/>
                      <a:ext cx="1829055" cy="2124372"/>
                    </a:xfrm>
                    <a:prstGeom prst="rect">
                      <a:avLst/>
                    </a:prstGeom>
                  </pic:spPr>
                </pic:pic>
              </a:graphicData>
            </a:graphic> ...
          
        </w:drawing> ...

        <w:p w:rsidR="00622A50" w:rsidRDefault="00622A50">
            <w:r>
                <w:br w:type="page"/>
            </w:r>
        </w:p> ...

  </w:body>
</w:document>

Installing the Open XML SDK

As I mentioned yesterday, manipulating the package directly with the System.IO.Packaging classes gets a little bit tricky when you have to start adding embedded images and objects and linking them together. Instead, it’s easier to use the Open XML SDK to do this because it will handle linking new image parts we add to the package automatically for us. The SDK provides a strongly-typed way of accessing the parts in a package so it cuts down on the amount of code you have to write yourself. Version 1.0 requires only .NET 2.0, Version 2 requires .NET 3.5 and uses LINQ to provide more functionality when querying the parts. This version is currently a CTP. For what we’re doing you can use either version but I have Version 2 installed.

The assembly that is installed in the GAC when you install the SDK is called DocumentFormat.OpenXml.dll and you’ll need to add a project reference to this. When you distribute your application you can simply xcopy the assembly with your application for easy deployment. (After you add the reference, select it in the Server Explorer and then in the Properties window set Copy Local to True in order to have it outputted to the \bin folder when you build your application.)

Now we can add the namespace imports we’ll be working with at the top of our program, including the DocumentFormat.OpenXml.Packaging namespace:

Imports <xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
Imports System.Xml
Imports System.IO
Imports DocumentFormat.OpenXml.Packaging

Modifying the Letter Class and LINQ Query to Get the Photo

In order to create letters for our customers in the database, we want to end up with a collection of XDocuments with our data merged into them. I created a Letter class that has two properties, CustomerID As String and Document As XDocument. We’re also going to add a new property for the photo byte array called EmployeePhoto As Byte() and OrderID as Integer. Next we need to modify the query so that it selects the photo as well as add the above WordProcessingML into our XML Literal to specify where the image should appear in the document. Because the relationship IDs must be unique, I’m going to use the OrderID as the suffix for the relationship ID for each of the images we want to embed. Like before, we can use embedded expressions to merge the data into the right places in the XDocument.

(I’ve omitted all the XML with the embedded expressions for clarity, take a loot at the code sample for the whole listing.) The bolded areas show the modified sections of the query:

Dim letters = _
  From Order In db.Orders _
  Join Employee In db.Employees _
    On Order.EmployeeID Equals Employee.EmployeeID _
  Where Order.OrderDate IsNot Nothing AndAlso _
    Order.ShippedDate IsNot Nothing AndAlso _
    Order.ShippedDate.Value.Date >= #1/1/1998# _
  Let DateOrder = Order.OrderDate.Value.ToShortDateString _
  Let DateShip = Order.ShippedDate.Value.ToShortDateString _
  Select New Letter With { _
    .CustomerID = Order.CustomerID, _
    .OrderID = Order.OrderID, _



    .EmployeePhoto = If(Employee.Photo IsNot Nothing, Employee.Photo.ToArray, Nothing), _
    .Document = <?xml version="1.0" encoding="utf-8" standalone="yes"?>
        <w:document ... 
            <w:body> ...
                <w:p w:rsidR="00A9498E" w:rsidRDefault="00A9498E" w:rsidP="00AA2EC6">
                    <w:r>
                        <w:t xml:space="preserve">If you have any issues please contact </w:t>
                    </w:r>
                    <w:proofErr w:type="spellStart"/>
                    <w:r>
                        <w:t><%= Employee.FirstName & " " & Employee.LastName %></w:t>
                    </w:r>
                    <w:proofErr w:type="spellEnd"/>
                        <w:r>
                            <w:t xml:space="preserve"> at</w:t>
                        </w:r>
                        <w:r w:rsidR="005F35D6">
                            <w:t xml:space="preserve"> ext.</w:t>
                        </w:r>
                        <w:r>
                            <w:t xml:space="preserve"></w:t>
                        </w:r>
                        <w:r w:rsidR="005F35D6">
                            <w:t><%= Employee.Extension %></w:t>
                        </w:r>
                        </w:p> ...
                        <w:drawing> ...
                            <pic:blipFill> ...
                                <a:blip r:embed=<%= "rId" & Order.OrderID %>/> ...
                        </w:drawing> ...
                        <w:p w:rsidR="00622A50" w:rsidRDefault="00622A50">
                            <w:r>
                                <w:br w:type="page"/>
                            </w:r>
                        </w:p> ...
                    </w:body>
                </w:document>}

The query returns an IEnumerable(Of Letter) objects with the Document property set to the document.xml data for that customer and the EmployeePhoto set to the photo byte array. If we wanted to create separate documents (which is exactly what I demonstrated in my DevProConnections article) it’s actually pretty simple because all we need to do is copy the template and then replace the document.xml and the image data, we don’t have to mess with the relationship ID at all. However if we want to create a single document with all our letters we need to delete the placeholder image part and add new unique image parts for the Letter.EmployeePhoto.

Adding and Linking the Images into a Single Word Document

Because relationship IDs must be unique in a document I used the OrderID as the embedded expression for the r:embed attribute in the XML Literal above. You can choose to use any unique ID you want but it must start with an alpha character, that’s why I prefixed it with “rId”. When you use the Open XML SDK to add the new image parts we have to specify the relationship ID to use. To update the code we wrote yesterday to work with the Open XML SDK and also work with images we first need to add a call to open the Word document template, grab the main document part and then delete the image part by calling DeletePart:

'Place the letters in a separate directory
Dim sourceFile = CurDir() & "\LetterTemplate.docx"
Dim letterDir = CurDir() & "\Letters\"
My.Computer.FileSystem.CreateDirectory(letterDir)

Dim mergeFile = letterDir & "AllLetters.docx"
My.Computer.FileSystem.CopyFile(sourceFile, mergeFile, True)

'Open the Document template using the Open XML SDK
Using wordDoc = WordprocessingDocument.Open(mergeFile, True)

    'get the main document part (document.xml)
    Dim mainPart = wordDoc.MainDocumentPart()

    'Delete the placeholder image from the template so we can replace it with the real photos
    mainPart.DeletePart("rId4")

This opens the Word document as read/write and then deletes the placeholder image. You should also notice at this point that the code is a bit simpler to open the package than yesterday because we don’t have to declare the relative URI’s or content types. The Open XML SDK helps us here. Next we need to load the document.xml into an XElement object and grab the body:

    Dim mainDocumentXML As XElement
    Using sr As New StreamReader(mainPart.GetStream)
        mainDocumentXML = XElement.Load(sr)
    End Using

    Dim mainBody = mainDocumentXML...<w:body>.First()
    Dim i = 0

Now we can loop through all the letters, grab the body of those XDocuments and then add an image part. We need to specify the content type and the relationship ID that must match what we embedded in the XML Literal in our query. Then we can either replace the main document body with the first letter (overwrite our placeholder data) otherwise we append the rest of the letter contents into the document:

    For Each letter In letters
        Dim nextBody = letter.Document...<w:body>.First()
        'Add the new imagePart. The SDK takes care of linking this properly.
        Dim imagePart = mainPart.AddImagePart("image/png", "rId" & letter.OrderID)

        If i = 0 Then
           'Replace the first body contents in the template
           mainBody.ReplaceNodes(nextBody.Elements())
        Else
           'Otherwise append the next letter contents
           mainBody.Add(nextBody.Elements())
        End If

Next we need to feed the byte array data into the ImagePart. Note that since I’m using Northwind for this example there is an OLE header on those images that we must strip off that is 78 bytes. If you are using your own images stored in SQL Server you won’t have to do that:

        'Now feed the byte array into the ImagePart
        If letter.EmployeePhoto IsNot Nothing Then
            'Using ms As New System.IO.MemoryStream(letter.EmployeePhoto.ToArray)
            'NOTE: Northwind Photos have an OLE header on them that we must strip off.
            ' You don't have to do this if you are using your own SQL-server stored images
            Using ms As New System.IO.MemoryStream(letter.EmployeePhoto, 78, _
                                                   letter.EmployeePhoto.Length - 78)
                imagePart.FeedData(ms)
            End Using
        End If

        i += 1
    Next

Now that we’ve built up the document XML, added our image parts and linked them properly, the final step is to replace the document part with our XML just like before:

    'Replace the document part with our XML
    Using sw As New StreamWriter(mainPart.GetStream(FileMode.Create))
        mainDocumentXML.Save(sw)
    End Using

End Using

Now when we run the application you will see a single document with all the letters, including photos, that’s much easier to print than multiple files.

There’s Always Room for Improvement

LINQ & Northwind savvy folks may notice that I’m actually creating duplicates of the employee photos. Since I’m flattening out the data in my query to have 1 photo per order there could be an unnecessary amount of duplicate images. This can cause the document to get bloated. To be more efficient we should reuse the relationship ID’s to the images if they are the same on multiple orders. One approach would be to modify the LINQ query and Letter object to select the EmployeePhoto and then have a collection of order & document data under that. I’ll leave that experiment up to you :-)

Take a look at the full code listing for this example as well as the complete project with other Open XML examples here on Code Gallery.

Enjoy!

Mail Merging Into a Single Word Document Using XML Literals

Beth Massi — Thu, 24 Sep 2009 02:18:00 GMT

With the release of Microsoft Office 2007 we can work with a much simpler, standard, XML format called Open XML which opens the door for many types of applications that cannot work via COM. What if you needed to build a scalable web service that processes many documents in high volume? What if you wanted to quickly read or write to these formats from a client application but wanted to have minimal dependencies on other applications? These types of programs do not want to require Microsoft Office be installed to run. The cool thing is you have the tools already with Visual Basic 2008. XML Literals are an easy way to manipulate any kind of XML, including Open XML.

I’ve written before on how to use XML Literals to manipulate Word documents, if you missed them:

If you aren’t familiar with XML Literals or Open XML then I’d suggest reading the article in the first bullet above first. It’s a great intro into XML Literals, Open XML and it also demonstrates a couple practical ways of reading and writing to Word document formats directly.

Recently I got a great question on how to change the program outlined in the last bullet above to merge letters we were creating on the fly from a database into a single document instead of multiple documents like we’re doing. This would make it much easier for an end user to print them. That’s such an obvious thing I can’t believe I didn’t think of that! For those of you that aren’t familiar with what we did I’ll give a quick recap of that application.

Creating Word Documents with XML Literals

What I wanted to do is take all the Customers in the Northwind database who had some orders shipping today and send them thank you letters. To get started I created a new Word 2007 document with the letter text and some placeholder field names to indicate where I want the data:

Save the document (I named it Doc1.docx) and then rename the .docx extension to .zip and you can drill into the package and see a bunch of XML documents inside it. If we drill down through the zip file we'll see that the text we just typed is located in the \word\document.xml file. Copy this xml and paste it into the Visual Basic editor, it will infer it as an XDocument object, and then you can use embedded expressions to replace the placeholders. (If I’ve lost you, read this article which explains it step-by-step.)

In order to create letters for our customers in the database, we want to end up with a collection of XDocuments with our data merged into them. I created a simple class called Letter that has two properties, CustomerID As String and Document As XDocument. Then I wrote a LINQ query to select the data and embed it into the document (I’ve omitted all the WordProcessingML for clarity, take a loot at the code sample for the whole listing.)

Dim letters = _
    From Order In db.Orders _
    Join Employee In db.Employees _
        On Order.EmployeeID Equals Employee.EmployeeID _
    Where Order.OrderDate IsNot Nothing AndAlso _
        Order.ShippedDate IsNot Nothing AndAlso _
        Order.ShippedDate.Value.Date >= #1/1/2007# _
    Let DateOrder = Order.OrderDate.Value.ToShortDateString _
    Let DateShip = Order.ShippedDate.Value.ToShortDateString _
    Select New Letter With { _
        .CustomerID = Order.Customer.CustomerID, _
        .Document = <?xml version="1.0" encoding="utf-8" standalone="yes"?>
    <w:document ...
    <w:p w:rsidR="00705CFF" w:rsidRDefault="00112228" w:rsidP="00AA2EC6">
        <w:r>
            <w:br/>
        </w:r>
        <w:r w:rsidR="007A5236">
            <w:t xml:space="preserve">Dear </w:t>
        </w:r>
            <w:proofErr w:type="spellStart"/>
        <w:r>
            <w:t><%= Order.Customer.ContactName %></w:t>
        </w:r>
        <w:proofErr w:type="spellEnd"/>
            <w:r w:rsidR="00AA2EC6">
                <w:t>,</w:t>
            </w:r>
     </w:p>
     <w:p w:rsidR="00E04FB0" w:rsidRDefault="00AA2EC6" w:rsidP="00AA2EC6">
        <w:r>
            <w:t xml:space="preserve">We’d like to inform you that the order you placed on </w:t>
        </w:r>
        <w:proofErr w:type="spellStart"/>
            <w:r w:rsidR="00112228">
                <w:t><%= DateOrder %></w:t>
            </w:r>
        <w:proofErr w:type="spellEnd"/>
            <w:r w:rsidR="00806521">
                <w:t xml:space="preserve"> has shipped on </w:t>
            </w:r>
        <w:proofErr w:type="spellStart"/>
            <w:r w:rsidR="00112228">
                <w:t><%= DateShip %></w:t>
            </w:r>
... </w:document>}

The query returns an IEnumerable(Of Letter) objects with the Document property set to the document.xml data for that customer. The next step involved taking the template Doc1.docx file, making a copy of it and then simply replacing the document.xml part inside the package with the one here in the Letter class for each letter. However, what I did was create separate letters for each customer. Instead we want to create one .docx file with ALL the letter data merged inside.

Merging into a Single Word Document

The first thing we need to do is insert a page break between all our letters. The easiest thing to do is to open back up your template Doc1.docx file in Word and insert a page break, save it, and then look at the document.xml again in the package. You should see this WordProccessingML element inserted near the end:

<w:p w:rsidR="00622A50" w:rsidRDefault="00622A50">
    <w:r>
        <w:br w:type="page"/>
    </w:r>
</w:p>

Paste this into the query above in the document exactly where you pulled it out of the document.xml.

Next we have a couple options on how to manipulate the package (docx file). I’ve shown how to use the Open XML SDK before to manipulate documents but in this simple case we can use the System.IO.Packaging classes directly. This is because all we’re doing is working with text in the document. If we were working with images or embedded objects it would be easier to use the SDK. In the next post we’ll add photos of the employees on each order into the document, but for this post let’s just focus on how to merge the text.

So the first thing we need to do is Import some namespaces including an XML namespace that we’re going to use:

Imports <xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
Imports System.IO
Imports System.IO.Packaging

Next we need to set up some variables and copy the Doc1.docx template to a new file I’m calling AllLetters.docx.

Dim uri As New Uri("/word/document.xml", UriKind.Relative)
Dim contentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"
Dim sourceFile = CurDir() & "\Doc1.docx"
Dim letterDir = CurDir() & "\Letters\"
My.Computer.FileSystem.CreateDirectory(letterDir)

Dim mergeFile = letterDir & "AllLetters.docx"
My.Computer.FileSystem.CopyFile(sourceFile, mergeFile, True)

Now we can open the template package and load the main document part as an XElement:

Using p As Package = Package.Open(mergeFile)

    'get the main document part (document.xml)
    Dim mainPart = p.GetPart(uri)
    Dim mainDocumentXML As XElement




    Using sr As New StreamReader(mainPart.GetStream)
        mainDocumentXML = XElement.Load(sr)
    End Using

The next part is where it gets fun. A word document has a top element structure like this:

<w:document>
    <w:body>
       ...
    </w:body>
</w:document>

So what we need to do is grab the body of the template, replace it with the first customer’s document body we have and then append the rest of the elements inside the bodies of the rest of the documents. A word document can only have one <w:body> element for it to be legal. The way we get the <w:body> XElement from the document is using the descendants syntax with the three dot notation (…):

    Dim mainBody = mainDocumentXML...<w:body>.First()
    Dim i = 0

    For Each letter In letters
        Dim nextBody = letter.Document...<w:body>.First()
        If i = 0 Then
            'Replace the first body contents in the template
            mainBody.ReplaceNodes(nextBody.Elements())
        Else
            'Append the new contents for the rest of the customers
            mainBody.Add(nextBody.Elements())
        End If
        i += 1
    Next

Now that we’ve built up the right body with all our letter data in it, we can replace the main document.xml part in the package and close it.

    'Delete the current document.xml file in the template
    p.DeletePart(uri)
    'Replace that part with our new merged XDocument
    Dim replace As PackagePart = p.CreatePart(uri, contentType)

    Using sw As New StreamWriter(replace.GetStream())
        mainDocumentXML.Save(sw)
        sw.Close()
    End Using

    p.Close()
End Using

Now when we run this, all the letters will be mail merged into the same document for easy printing:

As I mentioned if we have embedded images or objects that we need to replace it gets a little trickier. In the DevProConnections Article I have an example of how to create multiple documents with embedded pictures of the employee’s photo. In the next post I’ll show you how we can use the Open XML SDK to create a single document with embedded pictures as well.

Until then, have a look at the complete code I put up on Code Gallery.

[UPDATE: Merging Text & Photos into a Word Document using Open XML SDK]

Enjoy!

DevProConnections Article: Taking Advantage of LINQ and XML in Microsoft Office 2007

Beth Massi — Mon, 17 Aug 2009 20:05:00 GMT

This month I have an article on DevProConnections:

Taking Advantage of LINQ and XML in Microsoft Office 2007

In this article, I talk about how a lot of applications that need to take advantage of Microsoft Office can do so without going through COM. Many programs that need to process documents often require manipulation of the file formats directly and doing that through the Office component object model won’t scale very well. It also requires that Microsoft Office be installed to run. A better route in a lot of these cases is to use the Open XML SDK. With the release of Office 2007, Word documents, Excel spreadsheets and PowerPoint presentations are based on an open standard for packaging XML files called Open XML. Using Visual Basic’s powerful and simple implementation of LINQ to XML you can work with these new document formats much easier than ever before.

I show a couple practical examples of reading data from Word documents and updating a database as well as reading data from a database to create Word documents – all without COM. No Office applications need to be installed in order to read and write to these formats directly.

This article is based on the two episodes I did on DnrTV:

[UPDATE: Here's code samples (also includes a presentation pptx)]

Working with Open XML in Visual Basic

More resources:

Open XML Format SDK 2.0

Open XML Resource Center

Microsoft Visual Studio Tools for the Office System Power Tools v1.0.0.0

Word 2007 Content Control Toolkit

VSTO Developer Center

Visual Basic Developer Center

Enjoy!

Using Windows Presentation Foundation in Office Clients

Beth Massi — Tue, 11 Aug 2009 03:31:51 GMT

I was cleaning up my desk today and in the piles of mail and gobs of paper I found the SDN Magazine “Women in Technology” issue 101 that featured an article I wrote that was released in print back in May. Well, I just noticed today that near the end of June they made most of the articles available online, including mine. :-)

Using Windows Presentation Foundation and Line-of-Business Data in Microsoft Office Clients

In this article I talk about how to expose Line-of-Business data via ADO.NET Data Services to an Excel client using WPF. Office solutions you build with Visual Studio are designed to work with Windows Forms controls but you can also use WPF controls in your solutions as well. Any UI element that can host Windows Forms controls in an Office solution (VSTO) can also host WPF controls using the Winforms ElementHost as a container.

Using WPF controls in Office allows you to think out of the box and provide world-class data visualizations that are not possible with Windows Forms controls. And you can do it easily in an instantly familiar end-user application like those in the Office family. But what if you don’t have any fancy data visualizations? Even the simplest controls that display data are often better off as WPF controls in Office applications because they better match the UI styles used in the latest versions of Office. Using WPF can make your add-ins look built into the Office applications themselves, providing a better user experience.

This article describes one piece of the Northwind Office Business Application (OBA) we created in the beginning of the year so if you’re interested in OBA development with Outlook, Word, Excel and Sharepoint I’d suggest reading these as well:

OBA Part 1 - Exposing Line-of-Business Data

OBA Part 2 - Building and Outlook Client against LOB Data

OBA Part 3 - Storing and Reading Data in Word Documents

OBA Part 4 - Building an Excel Client against LOB Data

OBA Part 5 - Building the SharePoint 2007 Workflow

The full sample application, built with Visual Studio 2008, is here: http://code.msdn.microsoft.com/OBANorthwind

Of course, the rest of the magazine is pack full of awesome articles from very well known women in technology (scroll to the bottom of this page for the whole list). I’m honored to be featured with them in this issue. Thanks again to Marianne van Wanrooij and the folks at SDN for putting this together and I’ll see you in October at the SDN Conference!

Enjoy!

Good Times at DevTeach, Vancouver

Beth Massi — Sat, 20 Jun 2009 03:24:41 GMT

Last week I spoke at DevTeach in Vancouver which was held at the beautiful Four Seasons in downtown. I love this Canadian conference because the attendees are great – super friendly and social, and ask a lot of great questions. I mostly interacted with folks building applications for the government or working as consultants and wanting to freshen up their .NET skills. It was also nice to see a good number of VB developers here. I gave three talks and ended up in the top 3 speakers overall which was great :-).

Future Directions for Visual Basic and C#

Before the conference I did a joint user’s group talk and about 120 people showed up to see “Future Directions for Visual Basic and C#” which has also been delivered before at PDC and TechEd by folks on the Language Team. I did a flavor of Jonathan Aneja’s TechEd talk but I also included new C# features which I have to say are a welcome relief to me personally. Unfortunately my VM was misbehaving so badly that Visual Studio was running at a snail’s pace. But I joked around and got through it ending up with some good comments and questions. I did the talk again at the conference and my VM was just fine – go figure. As a bonus for the conference attendees I also included a VB REPL demo and it was a hit. Check out John’s TechEd recording for variations of the VB demos that I showed.

Most interesting was the group that attended the talk. It was almost a 50/50 split between VB and C# devs in the room with some cross-over (doing both). I even had 3 C++ programmers attend. I started out with all the new VB features, then showed all the new C# features and then finished up with the new features in both. I had a lot of fun with the session, jabbing at both languages here and there and poking fun in places where one was catching up to the other and vice versa. Here’s the breakdown of new stuff in each language:

Feature	VB10	C#4
Auto-implemented Properties	Y	Y
Collection Initializers	Y	Y
Multiline & Statement Lambdas	Y	Y
Implicit Line Continuation	Y	N/A
Named/Optional Parameters	Y	Y
Late binding support (dynamic)	Y	Y
Omit ref on COM calls	Y	Y
DLR Integration	Y	Y
Generic Variance	Y	Y
PIA deployment not needed	Y	Y

Y = Already exists in VB9/C#3
Y = New in VB10/C#4

Check out the Visual Studio 2010 Language samples and language walkthroughs for details on each of these features.

The C# crowd seemed in particular to like the Named & Optional parameter support commenting that “It’s useful because it saves me writing code”. I actually showed all of the C# 4 features in one method that demonstrated COM interop with Office lifted from this walkthrough. The VB crowd was particularly pleased to see no more underscores and auto-implemented properties. And those that commented in the session were pleased to see the language parity. I’m just glad I didn’t get any rotten tomatoes thrown at me from either side. :-)

Here’s some more resources to check out:

Data Sources and Data Binding with WPF

I’ve done this talk many times before and it’s always a lot of fun. I've been blogging on data binding in WPF as well as doing How Do I videos for a while now. This talk takes WPF data binding from a Winforms developer perspective and I try to demonstrate that investments made in your Winforms data sources can be used in WPF. The crowd seemed relieved ;-). I also showed the drag-drop data binding in Visual Studio 2010 building a form similar to what Milind showed in this Channel 9 interview. The team has also been blogging heavily about WPF data binding in VS2010 on the VS Data blog so check it out.

Here’s some more resources to check out:

Data Sources and Data Binding in WPF

WPF Forms over Data Videos

Channel 9 Interview: WPF Drag-Drop Data Binding in Visual Studio 2010

VS Data Team Blog

Visual Studio 2010 and .NET Framework 4 Beta 1

Conquering XML with LINQ in Visual Basic 9

This has got to be one of my most favorite talks of all time. I've written a lot on this topic. I have been doing this one for a couple years now and what’s great about it is that it never gets old. It’s amazing how many folks are still not aware of XML Literals in VB. Only about 10% of attendees had used them before so I started with the basics and worked my way up into the demos. This talk scored very high for me and I think it’s because I show a lot of practical examples of using XML Literals and LINQ to XML. I didn’t show any betas or unreleased bits either and I think folks appreciated that they could go home and get working with it right away.

I got through all the demos and showed a good amount of Open XML SDK to manipulate Office 2007 documents. I also showed off the VSTO Power tools a bit for viewing the Open XML packages. Amongst the many demos we went through, we built a letter generator from scratch like I've shown before here. I also did my famous Virtual Earth demo that people always enjoy.

Here’s some more resources to check out:

I also attended a few sessions myself on MVVM and Silverlight so you may see more of that cranking out of this blog at some point. ;-) I look forward to the next DevTeach!

Enjoy!

dnrTV: More Fun with Office and XML Literals

Beth Massi — Mon, 20 Apr 2009 22:33:00 GMT

Yesterday Carl posted another dnrTV show with yours truly. This is a follow up from the last show where I went over the Open XML SDK and LINQ to XML in order to manipulate and query Office documents. Last show focused on CustomXML parts and Word content controls. In this show I demonstrate how to create Word and Excel docs from database data using XML Literals.

dnrTV Show #137: Beth Massi on the Open XML SDK
dnrTV Show #138: Beth Massi on Open XML and Office

Here are some links to check out from the shows:

And here's the source code for the demos I showed.

Enjoy!

dnrTV: Showing off the Open XML SDK and LINQ

Beth Massi — Wed, 08 Apr 2009 01:05:00 GMT

Yesterday Carl posted another dnrTV show with yours truly. This time I’m talking about the Open XML SDK, something that I’ve written and spoken about many times. In this episode I show how to use Word 2007 content controls and map them to custom XML parts so that you can query structured data from unstructured documents using Visual Basic’s LINQ to XML. What’s really cool about the Open XML format is that you don’t need Office installed at all – no COM Interop needed. You’re working with the file formats directly. And it’s super simple using VB’s XML literals and LINQ with the SDK.

Unfortunately I didn’t have a lot of time when I did the show with Carl and I couldn’t finish my demos. So this morning I filmed another quick episode that shows how to create documents from database data directly, so keep on the lookout for the follow up show :-).

dnrTV Show: Beth Massi on the Open XML SDK

And here are the links from the show:

[UPDATE: Here's code samples (also includes a presentation pptx)]

Working with Open XML in Visual Basic

Enjoy!

Channel 9 Interview: ASP.NET MVC using Visual Basic XML Literals

Beth Massi — Mon, 16 Feb 2009 20:20:40 GMT

I just posted an interview on Channel 9 with Dmitry Robsman, the Product Unit Manager for ASP.NET. In this interview he shows us how he implemented ASP.NET MVC views using Visual Basic's XML Literals instead of .aspx pages. Dmitry shows us how this makes coding the views much cleaner using standard OOP principals. He also makes some very interesting observations about DSLs and Visual Basic XML literals. You can download the code Dmitry shows in the interview from his blog here.

Enjoy!

OBA Part 3 - Storing and Reading Data in Word Documents

Beth Massi — Fri, 13 Feb 2009 04:55:33 GMT

In my last few posts we've been building a simple Office Business Application (OBA) for the new Northwind Traders. If you missed them:

In this post I'm going to talk about how we can create a purchase order in Word 2007 that contains data about the items being purchased and how we can query that data and place it into our database. We'll use this code as a basis for our SharePoint Workflow which we will build out in the next post.

If you recall our architecture diagram of our Northwind Traders OBA involved our Sales Reps submitting purchase orders as Word 2007 documents up to SharePoint which kicked off a workflow to parse the document and update the database with the order data through our data service.

This allows us to store the unstructured document on SharePoint and the structured order data in our database.

However before we build out the SharePoint Workflow we need a clean way to store and then retrieve the structured order data inside the Word 2007 document. Since Word 2007 documents are Open XML we can use the Open XML SDK and LINQ to XML to easily parse the document. (I've talked about how to manipulate documents with Open XML SDK before here.)

Content Controls

One way to store data in an Word 2007 document is by using content controls. These allow you to define specific data areas/fields in the document which are then bound to XML that is placed inside the document. When users enter data into these areas of the document the data is stored as a CustomXML Part inside the document. You can use Visual Studio to create content controls and map them to XML or you can use Word itself. There's also a nifty tool called the Word 2007 Content Control Toolkit that makes the mapping more visual. I'd also highly recommend installing the VSTO Power Tools as well which includes a VS Add-In for manipulating Open XML documents. This allows you to look inside the document easily to inspect all the parts directly within Visual Studio.

So the first thing to do is to create a purchase order template and lay out the content controls on the document. We'll create something very simple using Microsoft Word 2007. On the Developer tab you will see the Controls section. There you can choose which types of controls to lay out on the document. Click the properties button to assign a friendly title and tag to the control. Here I've laid out the minimum information we'll need to submit an order to the system:

Users can write anything else around the content controls but the system only cares about capturing the data we've specified. This gives us the ability to store structured and unstructured data completely inside the .docx file.

Creating and Mapping the XML

Now we are ready to map the values of the content controls to some custom XML. The XML document for our order looks like this. (Note that there are 10 <OrderDetail> elements I just snipped them for brevity):

<OrderEntry xmlns="urn:microsoft:examples:oba">
  <CustomerID />
  <OrderDate />
  <Shipper />
  <OrderDetails>
    <OrderDetail>
      <ProductName />
      <Quantity />
    </OrderDetail>
    <OrderDetail>...
  </OrderDetails>
</OrderEntry>

Now open up the Word 2007 Content Control Toolkit an open the OrderEntryTemplate.docx. Under Actions select "Create a new Custom XML Part", switch to edit view, and then paste in the XML:

Next switch to Bind View and then drag the elements onto the content controls on the left. Make sure you select the element first and then drag it.

Once you're done, save the document and then you can open it in Visual Studio if you've loaded the VSTO Power Tools. This will show the Open XML parts of the document and you can expand the customXml folder and see that our XML has been added to the document.

If you back into Word and fill out the content controls and then view the document in Visual Studio again, you will see that the item1.xml custom XML part will contain the data we entered.

Now that we have a purchase order template we can give this to our sales reps who can collaborate with our high volume customers via email to fill it out. They can then submit the purchase orders to a SharePoint list that can run a workflow to extract the order data and update the database through the data service.

Using the Open XML SDK to Retrieve the Order Data

The easiest way to programmatically manipulate Office 2007 Open XML documents is by using the Open XML SDK. Once you install it you can then Add Reference to the DocumentFormat.OpenXML assembly. In order to use LINQ to XML you'll also need a reference to System.Core and System.Xml.Linq. These are imported automatically when you create a new project in Visual Studio 2008. You'll also need to add a Service Reference to the ADO.NET Data Service like I've shown before. So let's start simple and just create a console application for now called NorthwindOrderDocParser. Later we'll talk about moving this to a SharePoint workflow.

Before we start parsing the document let's create a couple simple classes that store the data we're extracting from our document.

''' <summary>
''' These classes represents the order data that is inside the Word Document. 
''' </summary>
''' <remarks></remarks>
Public Class DocumentOrderData

    Sub New(ByVal customerID As String, ByVal orderDate As Date, ByVal shipperName As String)
        _CustomerID = customerID
        _OrderDate = orderDate
        _Shipper = shipperName
    End Sub

    Private _CustomerID As String
    Public Property CustomerID() As String
        Get
            Return _CustomerID
        End Get
        Set(ByVal value As String)
            _CustomerID = value
        End Set
    End Property

    Private _OrderDate As Date
    Public Property OrderDate() As Date
        Get
            Return _OrderDate
        End Get
        Set(ByVal value As Date)
            _OrderDate = value
        End Set
    End Property

    Private _Shipper As String
    Public Property Shipper() As String
        Get
            Return _Shipper
        End Get
        Set(ByVal value As String)
            If value Is Nothing OrElse value.Trim = "" Then
                value = "Speedy Express"
            End If
            _Shipper = value
        End Set
    End Property

    Private _details As New List(Of Detail)
    Public ReadOnly Property Details() As List(Of Detail)
        Get
            Return _details
        End Get
    End Property

    Public Class Detail
        Sub New(ByVal productName As String, ByVal quantity As Short)
            _ProductName = productName
            _Quantity = quantity
        End Sub

        Private _ProductName As String
        Public Property ProductName() As String
            Get
                Return _ProductName
            End Get
            Set(ByVal value As String)
                _ProductName = value
            End Set
        End Property

        Private _Quantity As Short
        Public Property Quantity() As Short
            Get
                Return _Quantity
            End Get
            Set(ByVal value As Short)
                _Quantity = value
            End Set
        End Property
    End Class
End Class

Next, let's add a schema for the OrderEntry XML data that is contained in the document. This will give us IntelliSense on our XML when we're using LINQ to XML. We can just open the document in Visual Studio like before and copy the OrderEntry XML data into the clipboard. Then we can Add a new XML to Schema Item and paste into the Wizard's dialog box. This will infer the schema and place the XSD file into the project automatically for us. Notice that I specified a namespace on our OrderEntry XML data. We now can import this namespace into our main program along with a few other .NET namespaces we'll need:

'Reference to our data service and data entities:
Imports NorthwindOrderDocParser.NorthwindService
'Open XML SDK:
Imports DocumentFormat.OpenXml.Packaging
Imports System.IO
'Default XML Namespace:
Imports <xmlns="urn:microsoft:examples:oba">

We are almost ready to start writing our main program to parse the purchase order. First we need a test document. For this test I filled out the following information in a document called MyTestOrder.docx.

Now we can write our main program:

Module Module1

    Sub Main()
        Try
            Dim docFile = My.Computer.FileSystem.GetFileInfo("MyTestOrder.docx")

            Dim docData As DocumentOrderData
            Using sr = docFile.OpenRead()
                'Attempt to parse the document for order data
                docData = ParseOrderDocument(sr)
                sr.Close()
            End Using

            If docData IsNot Nothing Then
                Dim employeeEmail = "sales@nwtraders.com"

                'Attempt to add the order data through the service
                AddNewOrder(docData, employeeEmail)
                Console.WriteLine("Order saved successfully.")
            Else
                Console.WriteLine("No order data was found in the document.")
            End If

        Catch ex As Exception
            Console.WriteLine("Order could not be processed." & vbCrLf & ex.ToString())
        End Try

        Console.ReadLine()
    End Sub

The ParseOrderDocument method is going to need to grab the XML data from our Custom XML parts as we iterate over the part collection. It's a collection because there can actually be many Custom XML definitions in our document. In order to make grabbing the XML data from the parts easier let's create an Extension method that extends the OpenXMLPart type. I like to place Extension methods in a separate file called Extensions.vb:

Imports DocumentFormat.OpenXml.Packaging
Imports System.IO
Imports System.Xml

Module Extensions

    ' Create an extension method so we can easily access the part XML
    <System.Runtime.CompilerServices.Extension()> _
    Function GetXDocument(ByVal part As OpenXmlPart) As XDocument
        Dim xdoc As XDocument

        Using sr As New StreamReader(part.GetStream())
            xdoc = XDocument.Load(XmlReader.Create(sr))
            sr.Close()
        End Using

        Return xdoc
    End Function
End Module

Now we can go back to our main Module1 and add a the ParseOrderDocument method. Notice that I'm using the Extension method we created in the For Each part... loop to return the custom XML as an XDocument. Then I use the child axis property <OrderEntry> (displayed in IntelliSense as I type the query) to see if the element exists. Also notice that since I imported our XML namespace at the top of the file it will only return an <OrderEntry> element in that namespace. So we're safe not to clash with other custom XML that may be added to the document by other processes.

''' <summary>
''' Attempts to parse the word document for order data and returns an order
'''  object with all the required. The document must have a customXML part 
'''  that adheres to the OrderEntry.xsd
''' </summary>
''' <param name="docStream">The document to parse</param>
''' <returns>The order data contained in the document</returns>
''' <remarks></remarks>
Function ParseOrderDocument(ByVal docStream As Stream) As DocumentOrderData
    Dim orderData As DocumentOrderData = Nothing

    Try
        'Use the Open XML SDK to open the document and access parts easily
        Dim wordDoc = WordprocessingDocument.Open(docStream, False)

        Using wordDoc
            'Get the main document part (document.xml)
            Dim mainPart = wordDoc.MainDocumentPart
            Dim docXML As XElement = Nothing

            'Find the order data custom XML part
            For Each part In mainPart.CustomXmlParts
                docXML = part.GetXDocument.<OrderEntry>.FirstOrDefault()
                If docXML IsNot Nothing Then
                    Exit For
                End If
            Next

            If docXML Is Nothing Then
                Throw New InvalidOperationException("This document does not contain order entry data.")
            End If

            'Grab the order data fields from the XML 
            Dim customerID = docXML.<CustomerID>.Value.Trim()
            Dim orderDate = docXML.<OrderDate>.Value.Trim()
            Dim shipper = docXML.<Shipper>.Value.Trim()

            If customerID <> "" AndAlso IsDate(orderDate) Then
                'Create and fill the DocumentOrderData  
                orderData = New DocumentOrderData(customerID, CDate(orderDate), shipper)

                For Each item In docXML.<OrderDetails>.<OrderDetail>
                    'Grab order details data fields
                    Dim product = item.<ProductName>.Value.Trim()
                    Dim quantity = item.<Quantity>.Value.Trim()

                    If product <> "" AndAlso IsNumeric(quantity) Then
                        'Add a new DocumentOrderData.Detail for each product found
                        orderData.Details.Add(New DocumentOrderData.Detail(product, CShort(quantity)))
                    End If

                Next
            End If
            wordDoc.Close()
        End Using

    Catch ex As Exception
        Throw New InvalidOperationException("Could not process this document.", ex)
    End Try

    Return orderData
End Function

Updating the Database through the Data Service

Now that we have our document parsed we're just left with adding the data through our data service. What we need to do is query the reference data (entities) that we'll need to properly associate on our Order. For instance Order will need a reference to the Customer, the Employee and the Shipper. Then each Order_Detail will need a reference to the Product entity. Notice that we're passing the employee email address into this method so that we can associate the sales rep with the order. If you recall we had to add this field to the Customer and Employee tables in Northwind. (For this test program I'm hard-coding the value but later we'll get this information from the Outlook client when it submits the order to SharePoint.)

Once we have these entities queried and returned from the service we can link them up properly and add our new Order and Order_Details to the data service. For more information on updating data and setting proper linkage to entities returned from an ADO.NET data service read this post and this one.

    ''' <summary>
    ''' Adds a new order through the ADO.NET Data service and sets up all the required
    ''' associations to related entities.
    ''' </summary>
    ''' <param name="docData">The order data</param>
    ''' <param name="employeeEmail">EmailAddress of sales representitve</param>
    ''' <remarks></remarks>
    Private Sub AddNewOrder(ByVal docData As DocumentOrderData, ByVal employeeEmail As String)

        Dim ctx As New NorthwindEntities(New Uri("http://localhost:1234/Northwind.svc/"))
        Dim cust As Customer
        Try
            'Try to retrieve the customer
            cust = (From c In ctx.Customers _
                     Where c.CustomerID = docData.CustomerID).FirstOrDefault()

        Catch ex As Exception
            Throw New InvalidOperationException("Invalid customer ID.")
        End Try

        If cust IsNot Nothing Then

            Dim ship = (From s In ctx.Shippers _
                        Where s.CompanyName = docData.Shipper).FirstOrDefault()

            'Email Address will come from our Outlook client/sales person 
            Dim emp = (From e In ctx.Employees _
                       Where e.EmailAddress = employeeEmail).FirstOrDefault()

            Dim o As New Order()

            o.OrderDate = docData.OrderDate
            o.RequiredDate = Now.AddDays(2)
            o.ShipAddress = cust.Address
            o.ShipCity = cust.City
            o.ShipCountry = cust.Country
            o.ShipName = cust.ContactName
            o.ShipPostalCode = cust.PostalCode
            o.ShipRegion = cust.Region
            o.Freight = 25

            ctx.AddToOrders(o)

            o.Customer = cust
            ctx.SetLink(o, "Customer", cust)

            If ship IsNot Nothing Then
                o.Shipper = ship
                ctx.SetLink(o, "Shipper", ship)
            End If

            If emp IsNot Nothing Then
                o.Employee = emp
                ctx.SetLink(o, "Employee", emp)
            End If

            o.Order_Details = New System.Collections.ObjectModel.Collection(Of Order_Detail)

            For Each item In docData.Details
                Dim productName = item.ProductName.ToLower()
                Dim product = (From p In ctx.Products _
                               Where p.ProductName.ToLower() = productName).FirstOrDefault()

                If product IsNot Nothing Then
                    'Create a detail for each product being ordered
                    Dim detail As New Order_Detail()
                    o.Order_Details.Add(detail)

                    detail.Quantity = item.Quantity
                    detail.UnitPrice = If(product.UnitPrice.HasValue, _
                                          product.UnitPrice.Value, 1D)

                    ctx.AddToOrder_Details(detail)

                    detail.Product = product
                    ctx.SetLink(detail, "Product", product)

                    detail.Order = o
                    ctx.SetLink(detail, "Order", o)

                    ctx.AddLink(o, "Order_Details", detail)
                End If
            Next
            'Saving in Batch mode will update the data inside a database transaction
            'This will throw an exception if the service can't save the Order
            ctx.SaveChanges(Services.Client.SaveChangesOptions.Batch)
        End If
    End Sub
End Module

When we run this program we will see that Customer ALFKI now has a new Order and 4 Order Details entered into the database. Since we're sending the updates in Batch mode this will cause our order data to be properly wrapped in a database transaction.

Next post we'll talk about how we can create a SharePoint workflow to run this code when order documents are added to a SharePoint list. However, if SharePoint is not a requirement of your system (maybe you have no need to collaborate on documents or store this unstructured data) you could easily add this code directly to the Outlook client we built in the previous post.

I updated the sample on Code Gallery with this project so have a look.

Enjoy!

WPF RSS Feed Aggregator on CodePlex

Beth Massi — Thu, 13 Nov 2008 03:30:15 GMT

Alessandro Del Sole, Visual Basic MVP, has been busy on CodePlex writing a neat WPF learning application that aggregates RSS feeds. In his words:

It's developed in Visual Basic 2008 and uses LINQ-to-Xml and XML Literals to read feeds and persist XML data. You'll learn a lot of things like:

WPF Styles and control templates;
WPF Data-binding;
WPF color animations;
Creating a Grid to show data in WPF;
LINQ-to-Xml query expressions and embedded expressions in Visual Basic 2008;
XML Literals in Visual Basic 2008;
Enabling IntelliSense for LINQ-to-XML with XML Schema Inference

I just started playing with it myself and it's pretty cool. I wrote a mini feed browser to search Sara's Visual Studio Tip of the Day posts using XML Literals that can cache the posts as well. I'll probably try to update it in WPF as well based on this. Thanks Alessandro!

Enjoy!

SDN Conference Day 2

Beth Massi — Wed, 08 Oct 2008 13:04:00 GMT

Today I woke up at the crack of dawn because I had an 8:30 AM session. Okay maybe not quite the crack, but for me it was early. Especially after a night of socializing. That's a really cool thing about conferences here, the attendees love to go out with you after dinner and uh.. socialize. ;-) There were a lot of great conversations about technology flying everywhere it was hard to keep up. I crashed about 1 AM (which everyone told me was early!) and woke up about an hour and a half before my talk, no problem.

This talk I've done many times before and it's one of my most favorite subjects -- XML Literals and LINQ to XML in Visual Basic. I've done variations of this talk at user groups, other conferences and webcasts. And I showed a lot of the techniques that I've written about here as well as this article and this one. This was my best session according to the ratings but it's so easy to do well with this talk because of the simple and powerful expressiveness of XML in VB. It doesn't take much code at all to start creating, querying and manipulating XML documents directly in the editor with this awesome feature. Check out the VB Team blog where Doug Rothaus is doing a series of posts on XML in VB.

I also attended Brian Noyes' session on WPF Data Binding. Since I've been speaking about this as well I thought I'd join him and compare notes. ;-). I also told him about what scenarios I was going to tackle next on my WPF Forms over Data video series and he validated where I was going with it. It's great to chat with experts building business applications because I've built many in my life as well and the challenges are always similar. Brian is one of my data binding heroes since he wrote his Data Binding in Windows Forms 2.0 (which I still highly recommend).

Although there were a ton of .NET sessions, there were also a lot of Delphi sessions as well as a co-conference DotNetNuke OpenForce at this venue. I met a lot of cool people in the software industry.

The final wrap up was a bunch of cool give-aways for the attendees including a Wii and a Blue-Ray disk player -- very cool! I took a few pictures of some of the speakers and organizers...some of them acting pretty goofy.

Tomorrow I head back to Amsterdam where the organizers are going to take the speakers on a Holland tour. I can't wait!

First Day at SDN Conference

Beth Massi — Tue, 07 Oct 2008 13:28:00 GMT

I'm here in the Netherlands in a town called Noordwijkerhout near Amsterdam at the SDN Conference with a lot of great speakers and sessions.

I took these shots while the attendees were in session. There's good food, great vendors and lots of entertainment -- XBoxes, bowling, pin-pong, and lots of bars ;-) We also had a really funny English comedian perform at the end of the night. The Dutch really know how to put on a great event.

I have a total of three sessions and two on the first day. First I did a session called LINQ to Everything where I walked through each of the LINQ providers in Visual Studio 2008 SP1 "box" including LINQ to SQL, LINQ to DataSet, LINQ to Entities and LINQ to XML. We discussed application architecture and considerations and I showed demos to introduce each of the technologies. The room was packed and I got great scores so I'd say it went well. :-)

Next session I did was a lot of fun. It was called Taking Advantage of LINQ and Open XML in Office 2007 and I showed how to manipulate Open XML document formats in Office 2007 Word, PowerPoint and Excel documents using the Open XML SDK version 2.0 and LINQ to XML. I think it sparked a lot of people's curiosity and creativity because there are a lot of possibilities. I showed how you can create, query and transform documents without having to have Office installed at all. I also had great reviews and chatted with many attendees afterwards who were building a lot of cool business applications.

I attached the presentation and demos so have a look.

Enjoy!

MSDN Magazine - Dynamic Data Entry With XML Literals

Beth Massi — Thu, 02 Oct 2008 04:49:38 GMT

Check out the latest news on the VB Dev Center. I'm finally headlining myself ;-)

I'm in the October issue of MSDN Magazine. I've been managing the content for the Basic Instincts column for a little over a year now where we rotate writers from the VB Team. This month is my birthday month so I decided to take this one on personally. :-)

Enjoy!

Channel 9 Interview: XML Schema Explorer in Visual Studio 2008 SP1

Beth Massi — Fri, 15 Aug 2008 22:18:24 GMT

I just posted an interview on Channel 9 with Yang Xiao, a tester on the VB IDE. In this interview Yang shows us the new XML Schema Explorer in Visual Studio 2008 Service Pack 1. This new window is invoked when you right-click on an XML literal element or namespace and select "Show in XML Schema Explorer" in Visual Basic programs. It's a nice way to visually display the structure of your schema sets which makes you even more productive when working with XML in Visual Basic.

XML Schema Explorer in Visual Studio 2008 SP1

Enjoy!