If you want to make sure changes to your source object are reflected in your view, your source object will need to implement INotifyPropertyChanged (see example). Yet just implementing this property will not necessarily update your bindings. If your source object includes collections, and you bind to properties in those collections, you can update the source property but will not get updates from the source property, even if it is of a type that implements INotifyPropertyChanged.

The above scenario is common with Linq to Sql when the entities are generated for you. Even tables with one-to-one mappings will be generated with lists–as SQL doesn’t have a way of representing one-to-one relationships–so be sure to edit your dbml accordingly in order to take advantage of binding to your source object’s properties. (You might also consider removing some relationships to remove issues with DataContext collisions when trying to set properties of one Linq entity to another.)

If you can’t fix the problem this way or want to display the collection and changes to the collection, you can always add an ObservableCollection to your PresentationModel or wrap the source object with another object that does use the ObservableCollection to display your collection.

Dan Crevier posted a series of excellent articles defining the pattern and giving examples of the implementation of MVVM in WPF. These were written several years ago, before development of the Composite WPF block, but they are simple to understand and can give added understanding to the objects included in Composite WPF. For example, his post on encapsulating commands is very similar to the DelegateCommand object provided with CompositeWPF, though the latter uses lambdas to define Execute and CanExecute methods, whereas the former uses a base class and inheritance to define the methods. Using Dan’s example, the equivalent DelegateCommand, contained within the DelegateCommand’s definition, would look something like this:

public DelegateCommand<object> MyCommand { get; private set; }

public Window1()
{
    InitializeComponent();
    MyCommand = new DelegateCommand<object>(
        p => {
                 string text = p as string;
                 // Do something with text
             },
        p => !string.IsNullOrEmpty(p as string));
}

Dan’s definitions of the Model, which he calls DataModel, View and ViewModel match very closely with Composite WPF’s PresentationModel pattern. In this case, the DataModel is a representative object that is fit for display within the View. Using the entities generated for Linq to SQL, you might add properties to the partial classes create the necessary properties to which to bind. These classes should also implement INotifyPropertyChanged so that other DataModels can respond to changes from another, related View and update their data accordingly.

The View should use bindings for everything. The beauty of WPF is truly in its DataBinding functionality. The observer pattern is built right into the Binding, so that whenever one view changes, other views are notified by their bindings to their DataModels. Even the actions to be performed on a user interaction with the UI can be removed to the ViewModel, DataModel, or in the case of Composite WPF, a controller, Shell, or App level, as appropriate. This leaves the View looking very passive, indeed, which greatly helps when unit testing.

The ViewModel is the actual PresentationModel. It hosts the DataModel, as well as the View’s commands. ViewModel should be the object used to bind to the View’s DataContext and should implement INotifyPropertyChanged if any of the properties could change. The QuickStarts and RIStockTrader examples provide excellent samples of the PresentationModel, though be warned that the examples often use different patterns, if for no other reason than to show other pattern implementations.

That covers the MVVM pattern. However, there’s one more aspect that needs to be covered: composite regions. Composite WPF provides regions for managing the display of different modules in the Shell, but what if you need to display multiple modules or views within a “summary” view that is already on the Shell? In this case, you can use a Controller to manage the child use cases. The UIComposition QuickStart shows a terrific example of creating a controller in a ViewModel for the purposes of managing child use cases. This removes the dependencies and depth of a View that includes a tab control containing a large number of child use cases. (The UIComposition QuickStart uses a Supervising Controller pattern instead of the PresentationModel/MVVM pattern, so you’ll have to adjust it accordingly, but it works beautifully.)

The MVVM pattern is a great solution for WPF applications by allowing WPF’s DataBinding and Commanding to remove much of the logic formerly found in the View layer out to a unit testable ViewModel. The architecture stays clean and also fairly shallow in that an additional Presenter class is unnecessary (as opposed to the Supervising Controller pattern.)

Additional Resources:

• John Grossman - Tales from the Smart Client
• Pete Weissbrod - Model-View-ViewModel Pattern for WPF: Yet Another Approach

I read your comment before reading the article, and I originally agreed with your comment. Then I read the article, and I can’t help agreeing with almost every point. Almost. At the same time, I still agree with your comment. I know that probably sounds ridiculous, but it’s true. Everything you said is spot on target. Maybe explaining my thoughts, having read both, would help.

After reading the article, I can’t help thinking that RDF really doesn’t belong within (X)HTML. This is a pretty big deal for me, but I can’t get away from it. From a truly semantic pov, (X)HTML describes a document. I realize that it has been exploded to do all sorts of amazing things, but it is, at it’s roots, a document format. Why force even more into an almost back-broken format? (X)HTML’s own tags can provide a load of semantic information about the document, and that’s really all it should provide.

Microformats are a great way of recognizing that and staying fairly consistent to that nature, but they really aren’t a very good solution. Creating RDF using n3 is much easier than XML, though both are fine, and are much easier to create independent of (X)HTML. Building a tool to create RDF data to store at a specific URI would allow so much more data to be placed out on the SemWeb much faster. Then, using the rel and rev attributes already in (X)HTML, you could extract triples to relate web pages (HTML) to web resources (RDF, etc.) and complete the graph without trying to force in so much more information than necessary into (X)HTML.

Maybe I’m a bit naive, but that seems like a really workable solution. And if you must find a way to represent all RDF as a (X)HTML, XSLT and XQuery are great tools for doing just that, keeping in mind you are now creating a document to display data for the resource. Standard templates/queries should be able to go a long way–sort of a reverse GRDDL approach.

Or am I just missing something huge and obvious? (I tend to do that sometimes.)

If you read my previous post on the Future of Web Applications, you may think I already thought this. Well, I wish I had, but at the time I hadn’t quite reached this point. After all, I thought embedding resources within (X)HTML would make everything more maintainable. However, maintaining data on a person, event, etc. is much more easily done in one place and then linked by others. Why embed something that may already exist elsewhere? And why make your web page, which may only haphazardly relate to the embedded content, the responsible source for maintaining that embedded item?

Rather, I’d love to see tools like WordPress and others provide tools for creating and managing this content locally or link to resources elsewhere, such as in your Google Calendar.

At this point, I’ve likely lost most of my readers who are here for one thing or another, except those interested in the topics in the title. And that proves the point, in the end. A personal blog is basically a lot of thoughts, asides, commentaries, etc. about a variety of topics with only one common theme: they are all about the blogger. While that may appeal to some people in some cases, generally the only people who read this are close friends and family, and that happens only so often. (On rare occasions, I’m pleasantly surprised by new visitors and contacts… Thanks!) Please also note that I’m not directing this at corporate blogs or blogs about one or a few closely related concepts.

Instead of such a personal blog (this one is a case-in-point), I’ve been thinking that the only reason to post publicly is to share what I’ve got. If no one reads it, however, then what good was posting it? And if I’m inconsistent or post on certain ideas only infrequently, how will anyone know or care when I’ve posted exactly what they’ve needed for days–here I’m alluding to the difficulty of finding good SharePoint development resources–when it’s my second post on the topic in six months? If I post on MSDN or SitePoint forums, however, not only will a lot of people likely see it, but I may even be able to discuss other ways of doing what I’ve suggested or even learn ways to improve.

I’ve come full circle once again. Why have a blog? I really can’t think of a good reason. However, I can think of a really great reason for continuing to use WordPress and maintain a personal site: a personal site can act as a hub for all of my online activities and accounts, and at some point, potentially bring all the posts I contribute elsewhere back here for a central picture of what I do online. (Of course, sites like Twine and Facebook already do that on some level, but there’s nothing like having your own, decrufted domain name!)

The only problem, at this point, is that WordPress does not tie into the Semantic Web at the moment. This is changing with goodies like BuddyPress, SparqlPress, wp-openid, etc. I’m most excited about SparqlPress, which will really tie WordPress into the Semantic Web by pulling user information from FOAF profiles using SPARQL queries (see the example).

However, even with these great steps forward, I’m still missing something. WordPress is a personal publishing platform, but it doesn’t publish semantic data in the form that can be used to link to data on other sites. What I want to do is create a plugin to allow WordPress to embed RDF metadata into every post, page and link on my site using standard rules. I’ve started evaluating which content type works best for various types of data (see my list of “Online Accounts” links in the sidebar). At some point I’ll figure out
how to pull my content elsewhere back into my personal feed (i.e. “blog”), but that’ll remain for a later task.

Anyway, I’ll probably keep posting some stuff here, but it’ll really be thoughts that don’t seem to be better posted elsewhere. Over time, this site will start really looking like a hub about me and less like a blog… but I’ve said similar things before…

The God Delusion

The movie starts by investigating the reason as to why some scientists and professors were fired for mentioning or publishing even references to intelligent design and shows Stein asking why they might consider intelligent design as science. He addresses the point of intelligent design as religion and shows that, while it need not be divorced from religion, it need not be married to religion either; the two can coexist. Several of his intelligent design interviewees are open to religion but not themselves religious.

He then heads to the Darwinists to get their take. They pretty well confess to outright attacking religion so as to remove it from academia (and possibly society). Comments range from religious being “stupid” and “ignorant” to “dangerous”. All flat out deny any possibility of intelligent design as a possibility, yet none can offer any sensible answer to “How did life begin?” without either sounding utterly ridiculous or starting with some form of life already in existence. The supposed explanatory film of Darwinian evolution even uses “something” as the method by which life came to be. Yes indeed; that’s some very scientific terminology.

I can see why the Darwinists would be upset by this movie. It doesn’t try to prove intelligent design only show that it should be allowed into the debate; yet it uncovers some extreme silliness and massive persecution in the scientific community. I wonder how a thinking person could seriously consider elitist Darwinism as an end-all answer.

A friend of mine is currently reading The God Delusion and commented that while Dawkins’ arguments are very sound on a case-by-case level, the whole book almost laughs at Dawkins in the questions that remain un-addressed in the overall themes of the cases. You might imagine that Dawkins, in an attempt to prove forests didn’t exist, walked toward a tree and, going tree by tree, showed that each tree did not prove he was in the forest while all the while forest animals stood looking at him strangely.

Of course, it gets worse. Stein is able to show the connection between Darwinism and an extreme to which it can lead: Naziism. Many of the Darwinists find this an appalling connection, but history shows this to be a case, though certainly not the only case. The connection is easy enough to deduce for anyone willing to actually think on it for a few moments, so I won’t belabor the point.

Finally, I must applaud Professor Provine of Cornell University for his forthcoming statements regarding Darwinism and nihilism. (He didn’t call it that, but nihilism is none-the-less what he described.) The descent to Darwinism and natural selection usually ends with the loss of religious faith, at least in those interviewed. It allows for rationalizing the murder of crippled, handicapped, poor, elderly and unwanted children (abortion). In the end, once one has lost religion, the only real option left (despite what some fools would tell you) is nihilism. And at the end of nihilism, the only real question, in the ideas of Nitzsche, is whether or not suicide is okay. After all, you are only alive to die, right? If such is the case, what does it matter if you kill? That’s the idea of Nitzsche’s “superman“. For anyone familiar with Doestoevsky’s Crime and Punishment, this idea is really not so pleasant.

But back to the movie–I think Ben Stein has created a wonderful and important film on the need to continue to question and seek truth. The established science community is suppressing what has always made science great: the quest for answers and truth. Ben Stein sees that as a suppression of freedom and a potential to lead our society in the direction of Naziism again. Intelligent design has just as much validity to be taught as Darwinism, and together may help us understand our world and our beliefs better. I pray that the message is heard.