@ Head : LINQ

PDC 2010 Sessions

bill — Wed, 03 Nov 2010 00:49:59 GMT

You can view PDC 2010 sessions online at microsoftpdc.com , but you can also download sessions to view later or copy over to your windows 7 phone

The sessions info is all online in one nice big XML file :
http://videoak.microsoftpdc.com/pdc_schedule/Schedule.xml

Just scroll down or search for <DownloadableContent>

Or if you want you can run some XLinq on it to make it into a nice html doc. Here’s my quick and dirty attempt:

 Dim doc = XDocument.Load("http://videoak.microsoftpdc.com/pdc_schedule/Schedule.xml")
 
 Dim sessions = doc...<Session>
 
 Dim output = <html><body>
                  <%= From sess In sessions Select
                     <div><strong><%= sess.@Code %><%= " " %><%= sess.<ShortTitle>.Value %></strong>
                        <blockquote>
                           <%= sess.<FullDescription>.Value %>
                           <ul>
                              <%= From content In sess...<Content> Select
                                 <a href=<%= content.@Url %>><li><%= content.@Title %></li></a>
                               %>
                            </ul>
                        </blockquote>
                      </div>
                   %>
              </body></html>
 
IO.File.WriteAllText(Environment.GetFolderPath(Environment.SpecialFolder.Desktop) & 
                           "\session.html", output.ToString)

ElementAtOrDefault

bill — Tue, 15 Dec 2009 01:40:17 GMT

VB 9 or later has a particular feature that can make life easier in some circumstances: the compiler allows you to access indexed items on non indexed enumerables. Let’s say you have code such as:

Dim items as IEnumerable(Of String)
. . . .
For i = 0 to items.Count - 1
Debug.Print items(i)
Next

VB will compile that for you. The Count is an extension method that loops through the list to determine the count; luckily VB calls that only once. The real killer though is items(i) is actually compiled as items.ElementAtOrDefault(i).

The ElementAtOrDefault extension tries to cast the IEnumerable(Of T) to an IList(Of T); if the IEnumerable isn’t actually an IList, it loops through the collection, returning at the given index. As you can imagine this would get extremely slow for large lists especially inside a loop.

The Good:
If your IEnumerable is in fact an IList, such as a List(Of T), then the compiler magically adding this extension call makes life a little easier as you don’t have to cast to IList yourself.

The BAD:
You have to be really careful when doing any code maintenance, especially if you change an IEnumerable source to a different collection base that doesn’t implement IList(Of T). You can end up writing really bad, slow code really easily.

I got bitten by the bad, but I caught it immediately as I was curious about the collection base I was using. In my particular case I had swapped an List(Of T) out with a ConcurrentBag(Of T). ConcurrentBag(Of T) basically uses linked lists where each item is stored as a node. Each node has a previous and next node; the list has a head and a tail. I thought it strange that ConcurrentBag would have an indexer given that would force walking through the nodes. I went to change the items(i) to items.Item(i) and BINGO it wouldn’t compile.

Possible best practices to avoid being bitten by this:

(1) Use For Each loops, not indexers. Your code will be far more flexible/manageable

(2) If you only want the first item, make it explicit by using First or FirstOrDefault extensions.

(3) Try to do the explicit cast to IList(Of T) yourself and work with an IList(Of T) instead of an IEnumerable(Of T)

(4) Consider explicitly using the Item property , eg: items.Item(0) instead of items(0)

I’m not really comfortable with having to use the Item property: hopefully practices 1 to 3 will alleviate the need for practice 4.

Iterators: a flag for simplification ?

bill — Tue, 21 Apr 2009 02:02:16 GMT

A couple of months ago I blogged about iterators in VB (or the lack there-of), and pointed folks to an article I wrote for Visual Studio magazine that provides snippets and templates to help with iterators in VB.

One of the things I talk about in that article is often the use of iterators in C# code that I have seen is superfulous, especially given the LINQ libraries. Yesterday I read another example of this where the developer(s) had written a custom iterator instead of using a LINQ query. Their code required the defining of a generic class:

public class EnumerableGeneric<TClass, TInterface> 
              : IEnumerable<TInterface> where TClass : TInterface
{
   private IList<TClass> list;

   public EnumerableGeneric(IList<TClass> list)
   {
      this.list = list;
   }

   public IEnumerator<TInterface> GetEnumerator()
   {
      foreach (TClass item in list)
      {
         yield return item;
      }
   }

   IEnumerator IEnumerable.GetEnumerator()
   {
      return this.GetEnumerator();
   }
}

And the example of using this required the calling code to instantiate an instance of this class:

MyMethod(new EnumerableGeneric<ClassA, IClassInterface>(caInstance));

A simpler alternative is to actually use LINQ, eg:

MyMethod(caInstance.Cast<IClassInterface>());

In VB talk I think it’s even more natural flowing:

MyMethod(caInstance.Cast(Of IClassInterface))

It is in places like that I like the (Of T) syntax of VB a lot better, but some folks prefer a Cup<T> to a Cup(Of T) . The key point here is the use of “yield return” in C# is a good indicator that the code can often be replaced with far simpler LINQ constructs that reduce your LOC’s, and hence reduce your debugging and maintenance loads. There will of course be times where there isn’t a simple LINQ replacement, but if you do ever come across custom iterators, do take pause to think about using LINQ.

Xelement : more Value in that Value !!

bill — Mon, 05 Jan 2009 00:56:32 GMT

XML is very flexible and somewhat permissive in what it allows. Consider this piece of XML:

      el = <item>some values<first>one</first><second>two</second></item>

The element named item can contain both child elements and a text value. Thankfully this kind of XML is rare: it poses a heap of whitespace formatting issues, and the value itself can reside in any combination of places between the elements, eg:

      el = <item>some values<first>one</first> are <second>two</second>in here</item>

How this is interpreted is questionable. You could argue that position needs to be preserved, in which case you’d work with the Nodes property, including both the nodes of type XElement and also XText. Each of the inline values, “some values”, “ are ” and “in here” are actually XText nodes.

If you’re just after the Text, you need to write a helper function. If you try to use the Value property you get the Value of all nested nodes. Calling el.Value with the last example will output:

some valuesone are twoin here

The extension I slapped together is :

   <Extension()> _
   Public Function GetText(ByVal el As XElement) As String
      If Not el.HasElements Then Return el.Value
      Dim sb As New StringBuilder
      For Each nd As XNode In el.Nodes
         If TypeOf nd Is XText Then sb.Append(nd.ToString)
      Next
      Return sb.ToString
   End Function

With this the output is :

some values are in here

Enjoy :)

What we have here is a failure to communicate

bill — Fri, 14 Nov 2008 02:33:49 GMT

you can tell from the title there’s a Friday rant coming can’t you ? Well yeh, sometimes what should be a simple task of writing code becomes painstakingly slow. Take for example this one line of code:

  Dim doc = XDocument.Load("abc.xml")

Now if you like to write robust code, somewhere in your mind there should be that voice saying, “ah but what if the file is not there or can’t be opened or isn’t valid xml “…etc, etc. So the first thing you probably think of doing is look at what exceptions the method can throw, or so you’d hope.

Problem 1. VB doesn’t display the exception information from any xml documentation. Our first failure to communicate that then leads us on a great chase.

Problem 2. Who ever wrote the XDocument.Load method actually failed to provide the exception documentation. The Load method calls external methods such as XMLReader.Create and the exceptions from that are unchecked, allowed to bubble through. The documentation should indicate an include statement to say the XMLReader.Create exceptions bubble up. The author(s) of XDocument.Load failed to communicate the exceptions that could be thrown.

Problem 3. If you like to keep current and have installed the SilverLight 2.0 SDK, F1 help will take you to a SilverLight topic even if you are writing a Console application. That little voice in your head that first said “what if …” is now screaming. There’s a failure to communicate between Visual Studio and MSDN help.

Problem 4. Your only resolve is to do the lookup in msdn help yourself, only to find the documentation has no exception information because it relies on the xml documentation (see Problem 2). The failure to communicate cascades.

Problem 5. As a last ditch desperate measure you use Reflector and walk through the code. Thankfully in this case the code is reasonably simple. The problem now is how do you get that information back into your code, so as you handle the correct exceptions ? This isn’t Relector’s fault as such, as the same problem exists if you do find the exception information in Visual Studio’s object browser. This is a failure to interact, but it can result in you not handling exceptions or documenting which exceptions bubble up from your methods, causing your code to fail to communicate. (see Problem 2.)

If religious wars were still in fashion, we’d be saying “hey what about checked exceptions al la Java ?”. The more I am frustrated at how hard it is to write robust code because of these often cascading failures to communicate, the more I want to sign up with the holly sect for checked exceptions.

An alternative is to provide rich tooling and analysis. Some years ago, myself and Geoff Appleby with some help from Mark Miller wrote a plug-in for refactor that did a look up based on the code you selected. It would match the method calls with their xml documentation, refine and sort the list based on inheritance rules (most specific first), and let you choose which ones to add to your code. It really was simple once you got the method info, which is where refactor (or more accurately DXCore) came in. Unfortunately we hosted that project on the now defunct GotDotNet site :(

Such a tool helps break the cycle here, but such a tool also needs to be used by Microsoft (see Problem 2 above), and there needs to be analysis to ensure exceptions are either handled or the documentation says what exceptions can be thrown. Writing robust code needs to be easier: we cannot just ignore exceptions.

VS 2008 SP1 Now available to MSDN subscribers

bill — Mon, 11 Aug 2008 15:10:23 GMT

Check out the msdn subscriber homepage. S

P1 for Visual Studio 2008 English is about 830 MB… downloading at present

Then I can install SQL 2008 :)

Generic Variance Part1 : Do you really need it ?

bill — Mon, 11 Aug 2008 03:21:25 GMT

Lucian has kicked off the conversation on generic variance in VB , so I thought I’d write a few posts outlining my perspectives on the subject… the first of which is this one, and what better place to start than to question whether or not it is really needed……

Generics came to .NET after the base framework and languages were implemented. It was very much a bolt-on approach. As such there was and still is an impedance mismatch between conventional concepts of polymorphism and generics. As I posted previously, I had raised this is issue with Anders and other language experts back at the 2003 PDC (at which time Anders suggested using a language other than VB or C# <g>). Fast forward to today, and this issue is now being looked at, but now I find myself questioning if it is really needed, or is the fault the mismatch of the original framework.

Let’s take Lucian’s example :

Dim args As New List(Of ConstantExpression)
args.Add(Expression.Constant(2))
args.Add(Expression.Constant(3))
Dim y = Expression.Call(instance, method, args)

This code fails because the Call method is defined as :

   Public Shared Function [Call](ByVal instance As Expression, _

                                 ByVal method As MethodInfo, _

                                 ByVal arguments As IEnumerable(Of Expression)) _

                                 As MethodCallExpression

But if it was defined as follows then the code would work:

   Public Shared Function [Call](Of T As Expression) _

                                (ByVal instance As Expression, _

                                 ByVal method As MethodInfo, _

                                 ByVal arguments As IEnumerable(Of T)) _

                                 As MethodCallExpression

So where exactly is the problem ? The simple rule is if you want polymorphism (read as “generic variance”) in your code, then you need to expose the types as generic parameters not as concrete types.

That is, the above is solved by better API design and some simple refactoring. This in fact solves 90% or more of all the cases I have seen. The one place where you can’t do this is when the type is late bound and defined only as Object (more on this in a future post no doubt ;))

Generic variance and List(Of T)

bill — Fri, 08 Aug 2008 04:55:36 GMT

This post has been sitting in my drafts for a while, so I thought I should post it, mainly because I want to talk about this and generic variance and arrays in more detail in the days ahead. The reason this post was put on hiatus was I was waiting for my article on arrays to appear in Visual Studio Magazine, as that deals with many of the details as to why this works ;)

Have you ever wanted to cast a List(Of Customer) to a List(Of BusinessBase), where Customer Inherits BusinessBase, only to find that you can't... well you can ;)

This extension will return an IList of BusinessBase for an input of a List(Of Customer). Be aware it is the underlying array, so you will need to get the actual count from the original input.

   <Runtime.CompilerServices.Extension()> _

   Function ToIList(Of T, TBase)(ByVal list As List(Of T)) As IList(Of TBase)

      Dim fi = GetType(List(Of T)).GetField("_items", Reflection.BindingFlags.Instance Or _

                                                      Reflection.BindingFlags.GetField Or _

                                                      Reflection.BindingFlags.NonPublic)

      Return CType(fi.GetValue(list), IList(Of TBase))

   End Function

And a quick test:

Module Module1

   Sub Main()

      Dim myApples As New List(Of Apple)

      myApples.Add(New Apple With {.Name = "Golden Delicious"})

      myApples.Add(New Apple With {.Name = "Red Delicious"})

      myApples.Add(New Apple With {.Name = "Granny Smith"})

      Dim fruits As IList(Of Fruit) = myApples.ToIList(Of Fruit)()

      For i = 0 To myApples.Count - 1

         fruits(i).Name = "Fruit : " & fruits(i).Name

      Next

      For Each a In myApples

         Console.WriteLine(a.Name)

      Next

      Console.WriteLine("finished")

      Console.ReadLine()

   End Sub

   <Runtime.CompilerServices.Extension()> _

   Function ToIList(Of T, TBase)(ByVal list As List(Of T)) As IList(Of TBase)

      Dim fi = GetType(List(Of T)).GetField("_items", _

                                         Reflection.BindingFlags.Instance Or _

                                         Reflection.BindingFlags.GetField Or _

                                         Reflection.BindingFlags.NonPublic)

      Return CType(fi.GetValue(list), IList(Of TBase))

   End Function

End Module

Class Fruit

   Private _Name As String

   Public Property Name() As String

Get

         Return _Name

      End Get

      Set(ByVal value As String)

         _Name = value

      End Set

   End Property

End Class

Class Apple : Inherits Fruit

End Class

Are iterators fundamentally flawed ?

bill — Sat, 02 Aug 2008 02:14:22 GMT

It seems apparent that with computers as we currently know them, processors are now set to scale out not up.. that is, clock speeds aren’t rapidly growing, and certainly not doubling every year or two, instead the number of processors on a chip is. As a case in evidence, 2 or 3 years ago, my PC’s were all single CPU, then a bit over a year ago I bought my new desktop PC and it was a dual core. And as of a few days ago I swapped that dual core out for a quad core. For me, the number of cores/CPU’s is clearly doubling every year or two, but clock speed itself isn’t that much faster.

So what that means for computing is the emphasis is on parallel or concurrent computing. As such, we need to look at the fundamentals and see if they are designed for the task. Iterators don’t look like they are.

If you consider an iterator primary task of getting the next element, then look at how it does it, you should observe a major design flaw… the operation is not atomic. An iterator’s implementation is IEnumerator or IEnumerator(Of T), and IEnumerator require you to first call MoveNext then read the Current property. If you allow multiple threads to use the same IEnumerator, then you could get a call sequence such as MoveNext, MoveNext, Current, Current, which would skip one item and repeat the next one. So IEnumerator is not well designed for threading. This is a known design limitation, but rather than address that, languages like C# have implemented their iterators to be a different iterator per thread. That is they not only recognise the limitation but they also enforce it.

Going forward, perhaps we need a new IEnumerator class. In the good bad old days that would be called IEnumerator2(Of T). IEnumerator2 would make iterating a single method call that would return a Tuple(Of T, Boolean). It could extend IEnumerator, but it would be difficult to enforce thread safety to the IEnumerator interface. The problem that language like C# would then face is do they risk breaking existing code by returning the same enumerator to different threads ? Well no they would have to provide an IEnumerable2.GetEnumerator as well, so it would be possible to have the same class used for both single instance per thread and shared class across threads. As such, then the code that calls the iteration, the For Each loop, would then have to indicate whether it wants to do so using parallel or single threaded.. this would probably surface in the languages such as the For Parallel instruction on a loop.

So maybe iterators aren’t fundamentally flawed, they just currently have a lot of limitations which can and hopefully will be addressed as we venture more into the world of multi core :)

SQL Timestamps

bill — Tue, 08 Apr 2008 11:36:16 GMT

I was just reading a work around for timestamps with LINQ or WCF, and I must be stupid, but I just don't get it. In fact, ever since dotnet came out mapping timestamp to a byte array or SqlBinary, I never got why they did that. Timestamp is 8 bytes, so why not just map it to Int64 or UInt64 and for nullable timestamp columns map it to Int64? or UInt64?

Is there some reason why .NET maps it to a SQLBinary type even though we know it's a fixed size not a variable size ?

Stovell's Silverlight SyncLinq

bill — Mon, 07 Apr 2008 02:24:56 GMT

Obviously Paul thinks just because he used one of my photos and then said nice things about my photos, that I'll probably link to his demo of synclinq in silverlight. ;)

Can't get no VB Action ?

bill — Thu, 27 Mar 2008 05:30:01 GMT

Paul Stovell finally notices the lack of support for statement lambdas in VB9. Unfortunately Vb9 only supports lambda expressions such as can be expressed in today's expression trees. .NET 4.0 will most probably include support for lambda statements, and hopefully at the same time VB10 will have support for them too.

When support for multi statement lambdas was dropped from VB, I complained bitterly. It's a real pain, especially if you want to just add something benign like logging into a lambda: in VB9 you can't easily. Yes there are "work arounds", but if you need to capture surrounding variables, then it's a huge pain as you need to manually write the captures (promotion of local variables into fields in another class).

Of course fixing this feature, is on my VB10 wish lists. It's listed as item 6 in the first part of VB10 feature wishes.

The nice thing for VB in all of this though, is it will probably never have to separate what can and can't be expressed as an expression tree. C# has kind of made a mess around anonymous delegates and lambdas (I've even heard Anders admit to that !). ;)

Increment operators ?

bill — Tue, 25 Mar 2008 07:00:24 GMT

Does VB need prefix and postfix increment and decrement operators ? Here's an example I posted today for a question on adding an index with LINQ:

   Sub Main()
      Dim values() As String = {"aaa", "bbb", "ccc"}
      Dim index As Int32 = -1
 
      Dim view = From v In values _
                 Let x = increment(index) _
                 Select x, v
 
      For Each item In view
         Console.WriteLine(item.x & " : " & item.v)
      Next
      Console.ReadLine()
   End Sub
 
   Public Function increment(ByRef value As Int32) As Int32
      value += 1
      Return value
   End Function

And this is the same code in C#:

      static void Main(string[] args)
      {
 
         string[] values = { "aaa", "bbb", "ccc" };
         int index = -1;
 
         var view = from v in values 
                    let x = ++index 
                    select new{x, v};
 
         foreach (var item in view)
         {
            Console.WriteLine(item.x + " : " + item.v);
         }
         Console.ReadLine();
      }

Note in C# I didn't need to write the increment function.

Add As Link

bill — Wed, 16 Jan 2008 15:42:00 GMT

in VB 2008 you get a great intellisense experience when working with XML axis properties if you add the schema(s) to your project. You don't need to add the actual schema, you can just add a link. From the Project menu select Add Existing Item, browse to the xsd file then do NOT click Add, instead click the drop down arrow next to Add and select Add As Link.

One thing to be aware of is the path is stored in your project file (.vbproj) as a relative path. This can be problematic when distributing projects and the file is outside of the project directories, but works well when the path is a shared folder in a multi project solution.

What's new in VB 2008

bill — Fri, 21 Dec 2007 03:23:00 GMT

Visual Studio magazine's January On VB column, by your's truly, has a quick reference guide to what's new in VB 2008. The guide includes links to earlier articles that provide more in depth information on specific features.

Errata for my January column:

The web site fails to display & properly instead showing &. The relevant part of he article should read:

XML literals are, as the name implies, the literal representation of the XML as it would appear in a file (or close to it). For example, if you wanted to name a book "War & Peace" instead of "War and Peace," you'd need to encode the & to & inside the XML literal:
' won't compile
Dim el = _
   <book>War & Peace</book>

' will compile
Dim el = _
   <book>War &amp; Peace</book>

More on XML Namespaces in VB....

bill — Sun, 09 Dec 2007 13:20:24 GMT

A couple of weeks ago I wrote about XML Namespace issues in VB: one in particular was to do with namespace declarations being repeated in the output XML. In those cases we only looked at common namespaces for the entire document.

However the example of creating a word document I posted earlier today raises a similar issue, but this time it's with namespaces that are used in child elements not in the root element. Previously, one suggested workaround was to Import namespaces, and use expression placeholders, but as the word document shows, this does not produce what is often the desirable outcome.

The following simplified example demonstrates this:

- the goal of this exercise is to output the following XML:

<?xml version="1.0"?>
<a:root xmlns:a="url:a" xmlns:b="url:b">
    <b:x></b:x>
    <b:y></b:y>
</a:root>

The constraint is we want to create the x and y elements separately and insert them into the root element. .eg:

Imports <xmlns:a="url:a">
Imports <xmlns:b="url:b">
 
..... 
   Dim el1 = <b:x></b:x>
   Dim el2 = <b:y></b:y>
 
   Dim doc = <?xml version="1.0"?>
             <a:root>
                <%= el1 %>
                <%= el2 %>
             </a:root>

However that doesn't work. The output for that repeats the namespace of the b.

<a:root xmlns:a="url:a">
   <b:x xmlns:b="url:b"></b:x>
   <b:y xmlns:b="url:b"></b:y>
</a:root>

So I thought I would try declaring the b namespace in the root element:

      Dim doc = <?xml version="1.0"?>
               <a:root xmlns:b="url:b">
                  <%= el1 %>
                  <%= el2 %>
               </a:root>

Now that works. That gives the correct output of :

<a:root xmlns:a="url:a" xmlns:b="url:b">

<b:x></b:x>

<b:y></b:y>

</a:root>

But what is going on here you may ask ? Why does this work ? Well VB removes xmlns attributes from the added elements for any declarations that are used in the containing node. So the minimal fix to get my word document have the namespace declarations at the start requires the correct injection of namespaces to the parent they are added to. For example :

Dim thirdParagraph = <w:p

xmlns:dm="http://schemas.openxmlformats.org/drawingml/2006/main"

xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"

xmlns:dp="http://schemas.openxmlformats.org/drawingml/2006/picture"

xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">

<w:r><%= drawing %></w:r>

</w:p>

I also had to re-declare 2 xml namespaces in the drawing variables; for the document I had to add 5. And that is in just a simple example. What's really annoying is those namespaces were Imported at the module level in the first place. It would have been nice to write that XML literal using the imported namespaces, e.g:

Dim thirdParagraph = <w:p <%= dm %><%= wp %><%= dp %><%= r %>>

<w:r><%= drawing %></w:r>

</w:p>

Alas that doesn't work. Nor does and combination of GetXMLNamespace that I could think of.

In the need I decided it was a lot easier to just add the namespaces once to the root document and remove all of them from added elements, using a modified extension method.

 <Runtime.CompilerServices.Extension()> _
 Function RemoveAllNS(ByVal el As XElement, Optional ByVal includeChildNodes As Boolean = False) As XElement
      Dim current = el.LastAttribute
      Do While current IsNot Nothing
         Dim temp = current.PreviousAttribute
         If current.IsNamespaceDeclaration Then
            current.Remove()
         End If
         current = temp
      Loop
      If includeChildNodes Then
         For Each child In el.Descendants
            RemoveAllNS(child)
         Next
      End If
      Return el
   End Function

It's a shame this doesn't work easier than this :(

Right tool for the job ?

bill — Sun, 09 Dec 2007 03:33:15 GMT

I was catching up on reading some msdn blogs and stumbled across an entry from Yves Dolce. Yves was showing how to create a word document part including a graphic. Thing was, he was using C#, not VB. Here's an example :

var graphic = new XElement(dm.GetName("graphic"),

new XAttribute(XNamespace.Xmlns + "dm", dm.NamespaceName),

new XElement(dm.GetName("graphicData"),

new XAttribute("uri", dp.NamespaceName),

new XElement(dp.GetName("pic"),

new XAttribute(XNamespace.Xmlns + "dp", dp.NamespaceName),

new XElement(dp.GetName("nvPicPr"),

new XElement(dp.GetName("cNvPr"),

new XAttribute("id", 0),

new XAttribute("name", "openxmldeveloper.gif")),

new XElement(dp.GetName("cNvPicPr"))),

new XElement(dp.GetName("blipFill"),

new XElement(dm.GetName("blip"),

new XAttribute(r.GetName("embed"), "rId1")),

new XElement(dm.GetName("stretch"),

new XElement(dm.GetName("fillRect")))),

new XElement(dp.GetName("spPr"),

new XElement(dm.GetName("xfrm"),

new XElement(dm.GetName("off"),

new XAttribute("x", 0),

new XAttribute("y", 0)),

new XElement(dm.GetName("ext"),

new XAttribute("cx", 4448175),

new XAttribute("cy", 1181100))),

new XElement(dm.GetName("prstGeom"),

new XAttribute("prst", "rect"),

new XElement(dm.GetName("avLst")))))));

Okay here's the same bit in VB:

  
 Dim graphic = <dm:graphic>
                       <dm:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture">
                          <dp:pic>
                             <dp:nvPicPr>
                                <dp:cNvPr id="0" name="openxmldeveloper.gif"/>
                                <dp:cNvPicPr/>
                             </dp:nvPicPr>
                             <dp:blipFill>
                                <dm:blip r:embed="rId1"/>
                                <dm:stretch>
                                   <dm:fillRect/>
                                </dm:stretch>
                             </dp:blipFill>
                             <dp:spPr>
                                <dm:xfrm>
                                   <dm:off x="0" y="0"/>
                                   <dm:ext cx="4448175" cy="1181100"/>
                                </dm:xfrm>
                                <dm:prstGeom prst="rect">
                                   <dm:avLst/>
                                </dm:prstGeom>
                             </dp:spPr>
                          </dp:pic>
                       </dm:graphicData>
                    </dm:graphic>
 
 

And this is the complete example :

 
Imports <xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
Imports <xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing">
Imports <xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
Imports <xmlns:dm="http://schemas.openxmlformats.org/drawingml/2006/main">
Imports <xmlns:dp="http://schemas.openxmlformats.org/drawingml/2006/picture">
 
 
 
Module Module1
 
   Sub AddToDocToPackage(ByVal package As Package)
 
      Dim documentUri = New Uri("/word/document.xml", UriKind.Relative)
      Dim documentPart = package.CreatePart(documentUri, "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml")
 
      Dim firstParagraph = <w:p>
                              <w:r>
                                 <w:t>A paragraph</w:t>
                              </w:r>
                           </w:p>
 
 
      Dim secondPararaph = <w:p>
                              <w:r>
                                 <w:t xml:space="preserve">A</w:t>
                              </w:r>
                              <w:hyperlink r:id="rId2">
                                 <w:r>
                                    <w:rPr>
                                       <w:color w:val="0000FF" w:themeColor="hyperlink"/>
                                       <w:u w:val="single"/>
                                    </w:rPr>
                                    <w:t>hyperlink</w:t>
                                 </w:r>
                              </w:hyperlink>
                           </w:p>
 
 
 
      Dim graphic = <dm:graphic>
                       <dm:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture">
                          <dp:pic>
                             <dp:nvPicPr>
                                <dp:cNvPr id="0" name="openxmldeveloper.gif"/>
                                <dp:cNvPicPr/>
                             </dp:nvPicPr>
                             <dp:blipFill>
                                <dm:blip r:embed="rId1"/>
                                <dm:stretch>
                                   <dm:fillRect/>
                                </dm:stretch>
                             </dp:blipFill>
                             <dp:spPr>
                                <dm:xfrm>
                                   <dm:off x="0" y="0"/>
                                   <dm:ext cx="4448175" cy="1181100"/>
                                </dm:xfrm>
                                <dm:prstGeom prst="rect">
                                   <dm:avLst/>
                                </dm:prstGeom>
                             </dp:spPr>
                          </dp:pic>
                       </dm:graphicData>
                    </dm:graphic>
 
 
      Dim drawing = <w:drawing>
                       <wp:inline>
                          <wp:extent cx="4448175" cy="1181100"/>
                          <wp:docPr id="1" name="Picture 0" descr="openxmldeveloper.gif"/>
                          <wp:cNvGraphicFramePr>
                             <dm:graphicFrameLocks noChangeAspect="1"/>
                          </wp:cNvGraphicFramePr>
                          <%= graphic %>
                       </wp:inline>
                    </w:drawing>
 
 
 
      Dim thirdParagraph = <w:p><w:r><%= drawing %></w:r></w:p>
 
 
      Dim doc = <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
               <w:document>
                   <w:body>
                      <%= firstParagraph %>
                      <%= secondPararaph %>
                      <%= thirdParagraph %>
                   </body>
               </w:document>
 
 
 
      Using writer = Xml.XmlWriter.Create(documentPart.GetStream)
         doc.WriteTo(writer)
      End Using
 
 
 
   End Sub

Which is the right tool for the job ?

LINQ to XSD --> VB can do better !

bill — Wed, 05 Dec 2007 10:15:30 GMT

RJ posted an interesting entry about LINQ to XSD. The early LINQ to XSD bits that surfaced back in Orcas Beta 1 or thereabouts were basically an object layer of the underlying xml data. It was better than *just* an object model in that much of the XElement capabilities remained, but it was still just an object wrapper. I think VB can possibly do better ....

If you look at VB9 you'll see there's already basic intellisense support for schemas when working with XML axis properties. So the questions we should and could ask are can we make that better ? For example, let's say the compiler was to validate that. We could then enforce XSD constraints and give warnings or errors when they are broken.

One problem would be how would you specify what schema is being used. What if the XElement or XDocument has multiple schemas or you want to apply a different schema to a document ? One solution might be to have Schemas as a form of Interface, or more to the point as a Dynamic Interface.

Now if the constrain is only via dynamic Interfaces, you get all the flexibility of XML elsewhere, but if you cast the element to that dynamic interface you are constrained to that schema.

So if we had that, then why not let Dynamic Interfaces be schema fragments ? Then you could strongly type an element as a branch of a schema.

I don't think an object model is the best way of spanning that XML to general purpose programming divide. VB on the other hand has embraced XML and made the initial steps. Dynamic Interfaces seem like a logical extension to what VB9 already provides. And, speaking of extensions, if the schema or schema fragments are dynamic interfaces, then you could also provide extension methods typed to the dynamic interface.

There'd still be bits that would be more difficult such as interception of value setting, and eventing.. perhaps that would be the perfect opportunity for mixins ;)

Don't "p" on your XAttributes..

bill — Mon, 26 Nov 2007 10:26:43 GMT

If you programmatically add attributes with namespaces to an XElement, when the XElement is written out it will give each attribute a namespace prefix and then define a xmlns for that prefix. The way XElement does this is first it examines the namespaces already active and also those defined in the element for a match. If it doesn't find a match, it then creates a new prefix based on the count of the current namespaces in scope, e.g p1, p2, p3,....pn.

Now sadly, although it did first scan for namespaces, it appears it doesn't scan for prefixes in the current element *after* the current attribute. It does scan for previous declared prefixes, and will use one if the namespace matches. If the namespace doesn't match but a prefix clashes with the proposed prefix, the prefix is added a 0, e.g p10, p20, ... pn0. If that one also clashes then the number will be increased e.g p11, p21, ... pn1. And so forth.

The problem is it doesn't check for clashes inside the element it arbitrarily adds a namespace to. This code causes an exception due to the same attribute being named twice.

  
   Dim books = New XElement("books")
   books.Add(New XAttribute("{abc}attrib1", "one"))
   books.Add(New XAttribute(XNamespace.Xmlns.GetName("p1"), "zzz"))

The moral of the story is don't use "pn" for your namespace prefixes. (where n is any integer). You end up potentially "p"ing on your code ;)