Question: I've been trying to get my head around XAML and it's namespaces and I just cannot seem to get the logics of things. For example, I'm trying to animate a gridrow's GridLength property following a tutorial. I can get the sample code to run just fine. But trying to actually port the features into my own code seems to be impossible. I always run into odd errors which doesn't occur in the source code. Animating the GridLength property isn't possible, so I need to create a new .vb file containing the code making it possible. 

But trying to actually reach what's in there I can't get to work.

In my Window.xaml file I have this at the top:

```
xmlns:gridanim="clr-namespace:HDI_WPF_GridAnimation_vb"

```

Which targets a GridLengthAnimation.vb file. In that file you have this:

```
Imports System.Windows.Media.Animation
Imports System.Windows

Public Class GridLengthAnimation
    Inherits AnimationTimeline

```

Back in the Window.xaml, getting contact with "GridLengthAnimation" is impossible:

```
<gridanim:GridLengthAnimation></gridanim:GridLengthAnimation>

```

I get an error message saying:

```
The name "GridLengthAnimation" does not exist in the namespace "clr-namespace:HDI_WPF_GridAnimation_vb".

```

What is causing the issue?

Answer: 
They are actually a type of design pattern - creational patterns. Wikipedia has a reasonable description of these pattern types - which originate from the GoF book:

<http://en.wikipedia.org/wiki/Creational_pattern>

* Abstract factory pattern
* Factory method pattern
* Builder pattern
* Lazy initialization pattern
* Object pool
* Prototype pattern
* Singleton pattern
Doesn't seem terribly complicated. You might want to look into how you are going to do your Unit Testing before you choose--factories can make it really hard to properly inject mocks.

Also I haven't seen anyone else list Dependency Injection--I'd look into a DI toolkit as well because it will solve the unit testing problem and a few others associated with common building patterns. It looks like some of your classes build on others (like you might combine them to solve a problem), and DI helps with that a lot.