Dutch TechEd 2005 Bloggers

LINQ to XML instead of XPath

Sander Gerz — Mon, 06 Oct 2008 12:13:00 GMT

Working on a new project, I needed to read some elements from an XML file. As a matter of habit, I used XPath, but later I figured this was a good opportunity to try it out using LINQ. So here goes.

The XML source is a file, stored as Resources.xml with the following contents.

<?xml version="1.0" encoding="utf-8" ?>

</culture>

</culture>

...

</culture>

</resources>

The relevant data is in the value-attribute. The input parameters is culture of type CultureInfo and resourceKey of type string. resourceFile holds the path to the XML file.

The XPath version of getting to that data is this:

XmlDocument resourceXml = new XmlDocument();

resourceXml.Load(resourceFile);

string xpathQuery = string.Format("//culture[@code='{0}']/resource[@key='{1}']", culture.Name, resourceKey);

XmlNode resourceElement = resourceXml.SelectSingleNode(xpathQuery);

if (resourceElement != null) resourceValue = resourceElement.Attributes["value"].InnerText;

Using LINQ to XML we can use the following snippet:

XDocument xdoc = XDocument.Load(resourceFile);

var q = from c in xdoc.Descendants("culture")

where c.Attribute("code").Value == culture.Name

from r in c.Descendants("resource")

where r.Attribute("key").Value == resourceKey

select r.Attribute("value").Value;

if (q.Count<string>() == 1) resourceValue = q.First<string>();

Either version works fine. The only issue is that LINQ is supposed to help the developer by IntelliSense and strong typing. Unfortunately, that doesn't happen here, at least not with the elements in the XML file.

October 2nd Links: ASP.NET, ASP.NET MVC, ASP.NET Dynamic Data

ScottGu — Thu, 02 Oct 2008 10:23:21 GMT

Here is the latest in my link-listing series. Also check out my ASP.NET Tips, Tricks and Tutorials page and Silverlight Tutorials page for links to popular articles I've done myself in the past.

ASP.NET

Amazon EC2 Support for Windows and ASP.NET: Big news announced this week: Amazon will be offering Windows Server 2008 as an option in their EC2 service. This enables you to use ASP.NET, IIS7 and SQL Server in the cloud.

Using ASP.NET WebForms, MVC and Dynamic Data in a Single Application: Scott Hanselman has a nice post that demonstrates how you can have a single ASP.NET application that uses ASP.NET WebForms, MVC, WebServices and Dynamic Data. You have the flexibility to mix and match them however you want, which allows you to always use the right tool depending on the specific job.

Modifying Data with the ListView's EditItemTemplate: Matt Berseth has a great post that talks about how to use the ASP.NET 3.5 ListView control to enable in-place editing scenarios - with total html markup control.

4 New Grouping Grid Skins: Vista, Bold, Win2k3 and Soft: Matt Berseth has another nice post that demonstrates how to skin the ASP.NET ListView control to enable some sweet data grouping scenarios.

Unlocking and Approving User Accounts: Scott Mitchell posts another in his great series of articles on ASP.NET security (click here for all the articles in the series). This article talks about how you can setup administration pages that allow admins to lock out and approve user accounts using the ASP.NET Membership system.

Adding OpenID to you website in conjunction to ASP.NET Membership: Dan Hounshell has a nice article that discusses how to add OpenID authentication support to your web-site, and use it in conjunction to ASP.NET's built-in membership system.

ASP.NET MVC

MVC Membership with Preview 5: Troy Goode posts an update of his popular MVC Membership template that works with ASP.NET MVC Preview 5. It provides a set of administration pages you can use for user/role management, as well as adds support for OpenID and Windows LiveID.

MVC Flickr Xplorer: Mehfuz Hossain has a cool ASP.NET MVC sample application posted that enables a nice picture explorer for FlickR photos.

ASP.NET Dynamic Data

Simple 5 Table Northwind Example: Matt Berseth kicks off his ASP.NET Dynamic Data tutorial series with a nice post that shows how to build a simple 5 table application using ASP.NET Dynamic Data with .NET 3.5 SP1.

Dynamic Data And Custom Metadata Providers: Matt continues the series and covers the MetadataType attribute, and how you can use it to annotate your entities with additional metadata.

Dynamic Menu for your Dynamic Data: Matt continues and covers how to add a data-driven menu to the site.

Customizing the Delete Confirmation Dialog: Matt continues and demonstrates how to build a nice UI experience when deleting records in a dynamic data application.

Experimenting with YUI's DataTable and DataSource Controls: Matt experiments with how to use client-side AJAX components together with dynamic data.

Hope this helps,

Scott

MVP Visual Developer C#, I feel great!

dvroegop — Thu, 02 Oct 2008 09:14:53 GMT

Gisteren, 1 oktober, was weer een spannende dag. De dag waarop ik te horen zou krijgen of ik me weer een vol jaar Microsoft Most Valuable Professional mocht noemen. En ja hoor, om 4 uur 's middags (wat kan zo'n dag lang duren zeg...) kreeg ik het verlossende mailtje: Congratulations!

Even een impressie van hoe ik de rest van de dag op kantoor rond liep: bekijk dit filmpje Nou ja, niet helemaal zo, maar toch wel een beetje.

Dat betekent dat ik weer een jaar lang aangewezen bent om je te helpen met alle vragen die je mocht hebben op gebied van .net ontwikkelingen!

jQuery and Microsoft

ScottGu — Sun, 28 Sep 2008 20:32:31 GMT

jQuery is a lightweight open source JavaScript library (only 15kb in size) that in a relatively short span of time has become one of the most popular libraries on the web.

A big part of the appeal of jQuery is that it allows you to elegantly (and efficiently) find and manipulate HTML elements with minimum lines of code. jQuery supports this via a nice "selector" API that allows developers to query for HTML elements, and then apply "commands" to them. One of the characteristics of jQuery commands is that they can be "chained" together - so that the result of one command can feed into another. jQuery also includes a built-in set of animation APIs that can be used as commands. The combination allows you to do some really cool things with only a few keystrokes.

For example, the below JavaScript uses jQuery to find all <div> elements within a page that have a CSS class of "product", and then animate them to slowly disappear:

As another example, the JavaScript below uses jQuery to find a specific <table> on the page with an id of "datagrid1", then retrieves every other <tr> row within the datagrid, and sets those <tr> elements to have a CSS class of "even" - which could be used to alternate the background color of each row:

[Note: both of these samples were adapted from code snippets in the excellent jQuery in Action book]

Providing the ability to perform selection and animation operations like above is something that a lot of developers have asked us to add to ASP.NET AJAX, and this support was something we listed as a proposed feature in the ASP.NET AJAX Roadmap we published a few months ago. As the team started to investigate building it, though, they quickly realized that the jQuery support for these scenarios is already excellent, and that there is a huge ecosystem and community built up around it already. The jQuery library also works well on the same page with ASP.NET AJAX and the ASP.NET AJAX Control Toolkit.

Rather than duplicate functionality, we thought, wouldn't it be great to just use jQuery as-is, and add it as a standard, supported, library in VS/ASP.NET, and then focus our energy building new features that took advantage of it? We sent mail the jQuery team to gauge their interest in this, and quickly heard back that they thought that it sounded like an interesting idea too.

Supporting jQuery

I'm excited today to announce that Microsoft will be shipping jQuery with Visual Studio going forward. We will distribute the jQuery JavaScript library as-is, and will not be forking or changing the source from the main jQuery branch. The files will continue to use and ship under the existing jQuery MIT license.

We will also distribute intellisense-annotated versions that provide great Visual Studio intellisense and help-integration at design-time. For example:

and with a chained command:

The jQuery intellisense annotation support will be available as a free web-download in a few weeks (and will work great with VS 2008 SP1 and the free Visual Web Developer 2008 Express SP1). The new ASP.NET MVC download will also distribute it, and add the jQuery library by default to all new projects.

We will also extend Microsoft product support to jQuery beginning later this year, which will enable developers and enterprises to call and open jQuery support cases 24x7 with Microsoft PSS.

Going forward we'll use jQuery as one of the libraries used to implement higher-level controls in the ASP.NET AJAX Control Toolkit, as well as to implement new Ajax server-side helper methods for ASP.NET MVC. New features we add to ASP.NET AJAX (like the new client template support) will be designed to integrate nicely with jQuery as well.

We also plan to contribute tests, bug fixes, and patches back to the jQuery open source project. These will all go through the standard jQuery patch review process.

Summary

We are really excited to be able to partner with the jQuery team on this. jQuery is a fantastic library, and something we think can really benefit ASP.NET and ASP.NET AJAX developers. We are looking forward to having it work great with Visual Studio and ASP.NET, and to help bring it to an even larger set of developers.

For more details on today's announcement, please check out John Resig's post on the jQuery team blog. Scott Hanselman is also about to post a nice tutorial that shows off integrating jQuery with ASP.NET AJAX (including the new client templating engine) as well as ADO.NET Data Services (which shipped in .NET 3.5 SP1 and was previously code-named "Astoria").

Hope this helps,

Scott

Silverlight 2 Release Candidate Now Available

ScottGu — Fri, 26 Sep 2008 06:54:32 GMT

This evening we published the first public release candidate of Silverlight 2.

There are still a small handful of bugs fixes that we plan to make before we finally ship. We are releasing today's build, though, so that developers can start to update their existing Silverlight Beta2 applications so that they'll work the day the final release ships, as well as to enable developers to report any last minute showstopper issues that we haven't found internally (please report any of these on the www.silverlight.net forums).

Important: We are releasing only the Silverlight Developer Runtime edition (as well as the VS and Blend tools to support it) today, and are not releasing the regular end-user edition of Silverlight. This is because we want to give existing developers a short amount of time to update their applications to work with the final Silverlight 2 APIs before sites are allowed to go live with it. There are some breaking changes between Beta2 and this RC, and we want to make sure that existing sites can update to the final release quickly once the final release is out. As such, you can only use the RC for development right now - you can't go live with the new APIs until the final release is shipped (which will be soon though).

You can download today's Silverlight Release Candidate and accompanying VS and Blend support for it here. Note that Expression Blend support for Silverlight 2 is now provided using Blend 2.0 SP1. You will need to install Blend 2.0 before applying the SP1 service pack that adds Silverlight 2 support. If you don't already have Blend 2.0 installed you can download a free trial of it here.

Beta2->RC API Updates

Today's release candidate includes a ton of bug fix and some significant performance optimization work.

Today's release candidate also includes a number of final API tweaks designed to fix differences between Silverlight and the full .NET Framework. Most of these changes are relatively small (order of parameters, renames of methods/properties, movement of types across namespaces, etc) although there are a number of them. You can read this blog post and download this document to get a listing of the known API breaking changes made from the Beta2 release.

We have updated the styles of the controls shipped with Silverlight, and have also modified some of the state groups and control template names they use. When upgrading from Beta2 you might find it useful to temporarily remove any custom style templates you've defined, and get your application functionality working using the RC first - and then after that works add back in the styles one style definition at a time to catch any rename/behavior change issues with them.

If you find yourself stuck with an question/issue moving from Beta2 to the RC, please report it on the www.silverlight.net forums (Silverlight team members will be on there helping folks). If after a day or two you aren't getting an answer please send me email (scottgu@microsoft.com) and I can help or connect you with someone who knows the answer.

New Controls

Today's release candidate includes a bunch of feature additions and tweaks across Silverlight 2, as well as in the VS and Blend tools targeting it. In general you'll find a number of nice improvements across the controls, networking, data caching, layout, rendering, media stack, and other components and sub-systems.

Over the next few months we will be releasing a lot of new Silverlight 2 controls (more details on these soon). Today's release candidate includes three new core controls - ComboBox, ProgressBar, and PasswordBox - that we are adding directly to the core Silverlight runtime download (which is still only 4.6MB in size, and only takes a few seconds to install):

At runtime these controls by default look like:

The ComboBox in Silverlight 2 supports standard DropDownList semantics. In addition to statically defining items like above, you can also use databinding with it. For example, we could define a "Person" class like below:

And the add a ComboBox to a page like so:

And then write the below code to databind a collection of Person objects to the ComboBox (by setting its ItemSource property):

At runtime our simple app will then display the data-bound Person names (note that we set the DisplayMemberPath property on the ComboBox above to display the "Name" value from our Person objects):

We could then implement a SelectionChanged event handler like below to run code when a person is selected from the ComboBox:

Notice above how we can retrieve a reference to the selected "Person" object from the databound ComboBox using the ComboBox's "SelectedItem" property.

We can then call the MessageBox.Show() helper method (new in the RC) to display a modal dialog box that displays some details about our selected person:

New Control Skins

The final release of Silverlight 2 will have a much more polished set of default control template skins than those that were in Beta1 and Beta2. Our goal with the default control templates is to have a look that is professional and attractive, can be used in the majority of applications as-is (without requiring you to author custom style templates), and which is also easily tweakable using Expression Blend.

Today's RC build has skins that are close to the final look we plan to ship (there are a few final tweaks we are doing post RC on the focus color of controls, as well as to tighten up and tweak a few issues in some of the control templates). Below is the default look for the DataGrid, RadioButton, CheckBoxes, and the DatePicker controls with today's RC build:

Note that the DatePicker control above allows users to type in a date (with a masked edit to ensure it is a valid date), or they can click the calendar icon to the right of the textbox and select the date using a popup Calendar control:

One of the most powerful features of Silverlight and WPF, of course, is the ability for designers and developers to completely customize the look and feel of any control. This goes beyond simple styling of colors and fonts - you can literally completely change the visual UI of a control, as well as customize its behavior (for example: add animation) without writing any code.

Within Expression Blend, simply right-click on any Silverlight control and choose the "Edit Control Parts" sub-menu to open and edit its control template:

When in control template editing mode, you can manipulate any sub-element of a control (for example: a checkbox's inner content), as well as customize each "state" its in (notice the states pane circled in red below). This allows designers to customize what the control looks like in individual states (for example: checked, unchecked, mouseover, etc). Silverlight will then automatically handle animating the control from state to state depending on the user action:

You can learn more about how Silverlight's Visual State Model works from my previous blog post here.

Previous releases of Silverlight often rendered graphics on sub-pixel locations - which could cause lines and shapes to sometimes appear "fuzzy". The RC of Silverlight has a new features called "layout rounding" that causes the layout system to round the final measure of a control to an integer ("pixel snapping"), which results in crisper lines and fewer rendering artifacts. This feature is now on by default, and helps make applications look nicer.

Summary

The final release of Silverlight is not that far off now. It has been a pretty amazing project that has come a long way in a pretty short amount of time.

If you have existing Beta2 applications, please start getting them ready for the final release - as once we release Silverlight 2, users that have existing beta releases installed will automatically be upgraded to use the final version. Testing your application out with the release candidate will ensure that you can easily update your applications and have them ready within hours of the final release.

Let us know if you find issues with today's release candidate, and please make sure to post them on the forums on http://www.silverlight.net.

Hope this helps,

Scott

Donderdag 25 september: TFS bij Detrio!

dvroegop — Fri, 12 Sep 2008 11:53:35 GMT

Team Foundation Server is een enorm complex product. Er zitten heel veel haken en ogen aan, voor je het goed aan de praat heb ben je een tijd verder. Maar als het dan ook draait heb je een enorm waardevol stuk gereedschap in handen!

Nu hebben we bij dotNed al vaker over TFS gesproken, we hebben echter gekozen voor de 'bottom-up' aanpak: we hebben een aantal sessies gehad over bepaalde onderwerpen. Het wordt tijd om nu eens te gaan kijken hoe het overal plaatje er uit ziet. Wat kan TFS? Wat is de toegevoegde waarde voor mijn organisatie? Hoe regel ik mijn projecten nu in? Welke problemen kan ik verwachten als we TFS gaan implementeren?

Dit soort vragen, en vele anderen zullen worden beantwoord op de dotNed meeting van 25 september. Hassan Fadili, senior developer bij Detrio en bestuurslid van dotNed zal ons een overview geven van TFS met alle mogelijkheden en problemen die er bij horen.

Hassan is een van de mensen die vanaf het begin met TFS zijn gaan werken. Er zijn maar weinig mensen in Nederland die zijn kennisniveau op dit product hebben, dus als er iemand is die je vragen kan beantwoorden, dan is het Hassan wel.

Deze avond wordt gesponsord door Detrio Consultancy, een organisatie die 3D rapportage systemen in WPF bouwt. Uiteraard staan al haar projecten in TFS waardoor ze veel hands-on ervaring heeft opgedaan met deze producten.

Mocht je dus denken over de implementatie van een TFS server, of heb je er al een draaien en heb je vragen, of wil je gewoon meer weten, dan ben je van harte welkom op 25 september in Utrecht bij deze gratis bijeenkomst!

We zien je graag op de 25e te Utrecht!

dotNed meeting 4 september 2008: Project Velocity

dvroegop — Fri, 05 Sep 2008 08:39:14 GMT

Voor iedereen die bij de meeting van 4 september 2008 aanwezig waren, hier staat de presentatie van Dennis over Project Velocity.

Uiteraard mogen ook diegene die er niet bij waren dit downloaden, maar of je er veel aan hebt zonder het bijbehorende verhaal gelezen te hebben is nog maar de vraag.

Het was een uiterst geslaagde avond. Dennis is een erg goede spreker met enorm veel kennis over het onderwerp. Zeker gezien de beperkte hoeveelheid documentatie over Project Velocity was het indrukwekkend om te zien hoeveel hij er nog van af weet!

Project Velocity is duidelijk nog niet af, maar als ze kunnen waarmaken wat ze beloven, heeft dit Distributed Cache framework alles in zich om erg handig en eigenlijk ook onmisbaar te worden.

We bedanken Class-A voor het hosten van een geslaagde avond!

3D Graphics in WPF, deel 9 (Materialen)

dvroegop — Wed, 03 Sep 2008 11:17:02 GMT

Tot nu toe hebben we twee kubussen en vlakken gezien: een zwarte (in het begin, voordat er licht was) en een blauwe. Als je naar mijn eerste post over dit onderwerp kijkt, zie je dat ik daar iets meer kleuren en textures gebruik. Hoe werkt dat dan?

Het geheim zit in het gebruik van materialen, oftewel Materials. Dat is waar we nu naar gaan kijken.

Ik heb een beetje uitgelegd hoe de renderer van WPF werkt: voor ieder punt wordt gekeken hoeveel licht er op valt en dan wordt aan de hand van dat percentage licht berekend hoe zichtbaar iets is. Maar in het echte leven (je weet wel, die wereld BUITEN je computer) is de hoeveelheid en kleur van het licht maar een deel van de reden dat we de dingen zien zoals we ze zien: als je een geel papiertje naast een rood papiertje legt, dan krijgen ze allebei exact dezelfde hoeveelheid licht maar toch zie je twee kleuren. Dat ligt uiteraard aan de kleur van het papier. En niet alleen de kleur, maar ook de textuur en de bedrukking van het papier draagt bij aan het beeld dat we hebben van het papiertje.

In WPF kunnen we dat gedrag simuleren door het gebruik van de verschillende materials. Je moet een material zien als een soort behang dat je over je objecten plakt. Hoe dat in code werkt hebben we al gezien, maar ik zal het nog even herhalen:

   1:          <detrio:Box LeftBottomCorner="0 0 0" Width="1" Height="1" Depth="1">

   2:              <detrio:Box.Material>

   3:                  <DiffuseMaterial Brush="Blue"/>

   4:              </detrio:Box.Material>

   5:          </detrio:Box>

6:

   7:          <detrio:Box LeftBottomCorner="1 0 -2" Width="0.5" Height="1.0" Depth="0.5">

   8:              <detrio:Box.Material>

   9:                  <DiffuseMaterial Brush="Yellow"/>

  10:              </detrio:Box.Material>

  11:          </detrio:Box>

In regel 1 en in regel 7 maak ik twee boxen aan, met behulp van de code uit post 8a. In regel 2-4 en 8-10 geef ik ze een kleurtje. De eerste wordt blauw, de tweede geel (mits je het licht wit hebt gemaakt uiteraard). Maar eigenlijk klopt dat niet: we schilderen de box niet blauw en geel, maar we geven ze een Material mee die blauw of geel is. En dat maakt een groot verschil!

In dit voorbeeld gebruik ik de DiffuseMaterial. Deze zul je waarschijnlijk het meest gebruiken: dit is een Material die het licht dat er op valt in alle richtingen weerkaatst. Het is te vergelijken met het vel papier dat ik eerder noemde. Een vel papier weerkaatst licht heel anders dan een glimmend stuk plastic, een gelakt tafelblad of een stuk glas (al dan niet matglas). De keuze van het materiaal bepaalt dus hoe je je objecten ziet.

In WPF hebben we de keuze uit de volgende materialen, allen afgeleid van de class Material:

DiffuseMaterial, die hebben we net besproken
SpecularMaterial, een material die licht 'weerkaatst' (het werkt niet als een spiegel,maar lijkt er wel een beetje op)
EmmisiveMaterial, deze straalt meer licht uit dan dat er op komt. Let op: dit is geen light object, dus andere objecten worden hier niet mee verlicht. Dit houdt in dat als je twee objecten zou hebben in je scene, een met een DiffuseMaterial en een met een EmmisiveMaterial, maar je hebt geen lights in je scene, dan zie je het object met de DiffuseMaterial als een zwart object, en de EmmisiveMaterial zie je met de kleur die je het gegeven hebt
MaterialGroup. Dit is geen echt material, maar hiermee kun je verschillende materials combineren in een object (de DependencyProperty Material van GeometryModel3D heeft een content, wat maar een object kan bevatten: door hier een MaterialGroup in te stoppen kun je materialen combineren).

Hieronder zie je een voorbeeld van een scene met 2 objecten en geen lampen: het voorste object heeft een DiffuseMaterial, het achterste heeft een EmmisiveMaterial, beiden hebben als Brush 'Blue'.

Je ziet dat de voorste gewoon zwart wordt (er valt immers geen licht op), terwijl bij de achterste alles gelijkmatig blauw is: er valt immers geen licht op dus er is geen verschil in de belichting per kant. Dat hij toch zichtbaar is, komt omdat hij zelf licht uitstraalt (maar zoals je aan de voorste box ziet straalt hij niet echt licht uit naar andere objecten).

Het wordt pas leuk als we materials gaan combineren. Ik heb twee cylinders genomen (het effect is sterker bij gebogen oppervlaktes) en die naast elkaar geplaatst:

De material voor de linker cylinder is als volgt gedefinieerd:

<detrioCL:Cylinder.Material>
    <MaterialGroup>
        <DiffuseMaterial Brush="Blue"/>
        <SpecularMaterial Brush="White" SpecularPower="0.8"/>
    </MaterialGroup>
</detrioCL:Cylinder.Material>

Hier combineer ik twee materialen, een DiffuseMaterial met een blauwe brush, en een SpecularMaterial. Deze laatste weerkaatst wit licht, met een intensiteit van 80%. Dus 80% van de hoeveelheid licht die er opvalt wordt wit teruggegeven. De rechter cylinder heeft alleen een DiffuseMaterial met een blauwe brush. Je ziet het verschil.

Naast de keuze voor de Material soort moet je ook een bepaalde brush kiezen. Tot nu toe hebben we steeds een standaard Brush genomen, uit de Enum Brushes (die heel veel kleuren in zich heeft). Je bent echter niet gebonden aan een brush met een kleur: je kunt heel veel brushes toepassen.

Brushes zijn afgeleid van System.Windows.Media.Brush, een abstract class (gebruik niet de oude System.Drawing.Brush, die werkt niet in 3D WPF!). We hebben de volgende brushes tot onze beschikking:

SolidColorBrush. De standaard die we al gezien hebben, deze tekent met 1 kleur
LinearGradientBrush. Een verloop die van een kleur naar een ander loopt, in een rechthoek (bijvoorbeeld van linksboven naar rechtsonder)
RadialGradientBrush. Een verloop in een cirkel, dus van binnen naar buiten.
ImageBrush. Deze kan een image bevatten die getekend wordt. Hier kun je dus een jpg, png, gif enz. gebruiken als brush
DrawingBrush. Een brush die een 2D drawing bevat. Hier teken je zelf de inhoud van de brush
VisualBrush. Deze bevat een visual als tekenobject.

We gaan even terug naar onze begin applicatie:

<Window x:Class="WpfApplication11.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300">
    <Viewport3D>
        <!-- Te tekenen objecten -->
        <ModelVisual3D>            
            <ModelVisual3D.Content>
                <GeometryModel3D>
                    <GeometryModel3D.Geometry>
                        <MeshGeometry3D Positions="0 0 0, 1 0 0, 1 1 0, 0 1 0"
                                        TriangleIndices="0 1 2 0 2 3"
                                        />
                    </GeometryModel3D.Geometry>
                    <GeometryModel3D.Material>
                        <!-- Hier gaan we met de material spelen -->
                        <DiffuseMaterial Brush="Blue"/>
                    </GeometryModel3D.Material>
                </GeometryModel3D>
            </ModelVisual3D.Content>
        </ModelVisual3D>

        <!-- Lampjes! -->
        <ModelVisual3D>
            <ModelVisual3D.Content>
                <Model3DGroup>
                    <AmbientLight Color="#404040"/>
                    <DirectionalLight Color="#BFBFBF" Direction="1 -1 -1"/>
                </Model3DGroup>
            </ModelVisual3D.Content>
        </ModelVisual3D>

        <!-- Camera -->
        <Viewport3D.Camera>
            <PerspectiveCamera Position="1.5 1.0 2.0" 
                           LookDirection="-0.5 -0.3 -1" 
                           UpDirection="0 1 0" 
                           FieldOfView="45.0" 
                           />
        </Viewport3D.Camera>
    </Viewport3D>
</Window>

Dit is onze standaard applicatie, met een vierkant in het midden, wat verlichting en een camera. Als we de regel <DiffuseMaterial Brush="Blue"/> vervangen door de volgende code:

<!-- Hier gaan we met de material spelen -->
<DiffuseMaterial>
    <DiffuseMaterial.Brush>
        <SolidColorBrush Color="Blue"/>
    </DiffuseMaterial.Brush>
</DiffuseMaterial>

krijgen we precies hetzelfde effect. Dit is eigenlijk wat de standaard Brushes collectie doet: het maakt een SolidColorBrush aan. Dit ziet er dus als volgt uit:

Als we de Brush nu eens vervangen door een LinearGradientBrush, krijgen we de volgende code en het volgende resultaat:

<!-- Hier gaan we met de material spelen -->
<DiffuseMaterial>
    <DiffuseMaterial.Brush>
        <LinearGradientBrush>
            <LinearGradientBrush.GradientStops>
                <GradientStop Color="Blue" Offset="0.0"/>
                <GradientStop Color="White" Offset="0.5"/>
                <GradientStop Color="Red" Offset="1.0"/>
            </LinearGradientBrush.GradientStops>
        </LinearGradientBrush>
    </DiffuseMaterial.Brush>
</DiffuseMaterial>

Geef toe: dit is niet het effect wat je verwacht had.

Dit ga ik zo oplossen. Laten we eens naar de ImageBrush kijken. Voeg aan je applicatie een plaatje toe, bijvoorbeeld een jpeg of een png. Gewoon toevoegen aan je solution:

Ik heb ons logo genomen en die gesleept naar de solution. Standaard staan de properties al goed: het wordt een resource die meegelinkt wordt in onze applicatie.

De code ziet er dan als volgt uit:

<!-- Hier gaan we met de material spelen -->
<DiffuseMaterial>
    <DiffuseMaterial.Brush>
        <ImageBrush ImageSource="DETRIO-logo.png"/>
    </DiffuseMaterial.Brush>
</DiffuseMaterial>

Run de applicatie en zie het resultaat: niets...

De reden hiervoor is dezelfde als dat we in het vorige voorbeeld een rood vlak zagen. We hebben nog iets extras te doen om het aan de praat te krijgen.

Ik zei al dat je een Material moet zien als een behang dat je op je objecten plakt. Dat zei ik niet zomaar, die analogie gaat verder dan je misschien dacht. Als je gaat behangen en je hebt simpel, eenkleurig behang, maakt het eigenlijk niet uit hoe je de banen plakt (de naadjes tussen de banen even daargelaten). Of je ze nu van boven naar beneden, van beneden naar boven of voor mijn part van links naar rechts plakt: het is allemaal hetzelfde. Maar als je behang met een print hebt, is de richting waarin je plakt wel belangrijk! Bij Materials is dat precies hetzelfde: WPF moet weten in welke richting je materials op je objecten geplaats moeten worden.

Om dat aan te geven moeten we een mapping maken van onze 2D materialen naar de 3D coordinaten van onze objecten.

Neem even onze referentie tekening met een kubus. Ik heb hierin de coordinaten gezet van de hoekpunten. Ook zie je een blauwe material op het voorvlak. In het rood zie je de 2D coordinaten van ons plaatje (het blauwe vierkant)

Vergeet niet: in 3D is een positieve Y waarde een richting naar boven, in 2D is dat naar beneden! Dus de linkeronderhoek van onze kubus heeft als coordinaten (0,0,0) maar van onze material plaatje is dat (0,1)! Ik heb al gewaarschuwd dat we hier nog last mee gaan krijgen, dit is waar dat gebeurdt!

We moeten voor ieder punt in onze kubus aangeven hoe de mapping met onze toekomstige material is. Dit is een property van de MeshGeometry3D, en heet TextureCoordinates.

We moeten dus aan WPF zeggen dat op punt (0,0,0) van onze kubus het punt (0,1) van de brush geplaatst moet worden, op punt (1,0,0) moet brush coordinaat (1,1) komen, enzovoorts. (ik ga er even vanuit dat je wilt dat het plaatje rechtop staat en niet op zijn kop). We krijgen dus nu de volgende definitie van onze MeshGeometry3D

<MeshGeometry3D Positions="0 0 0, 1 0 0, 1 1 0, 0 1 0"
                TriangleIndices="0 1 2 0 2 3"
                TextureCoordinates="0 1, 1 1, 1 0, 0 0"
                />

We gebruiken relatieve coordinaten, we normaliseren de coordinaten van onze texture naar waardes tussen 0 en 1. Als je dus alleen de bovenste helft wilt laten zien, dan gebruik je als TextureCoordinates 0 0.5, 1 0.5, 1 0, 0 0.

Nu krijgen we dit plaatje:

Als je nu bij het voorbeeld van de LinearGradientBrush ook de TextureCoordinates plaatst, zul je zien dat het daar ook werkt.

Volgende keer meer over de DrawingBrush en de VisualBrush. Die laatste is echt leuk, hiermee kunnen we bijvoorbeeld een video afspelen op onze kubus!

ASP.NET MVC Preview 5 and Form Posting Scenarios

ScottGu — Tue, 02 Sep 2008 14:22:52 GMT

This past Thursday the ASP.NET MVC feature team published a new "Preview 5" release of the ASP.NET MVC framework. You can download the new release here. This "Preview 5" release works with both .NET 3.5 and the recently released .NET 3.5 SP1. It can also now be used with both Visual Studio 2008 as well as (the free) Visual Web Developer 2008 Express SP1 edition (which now supports both class library and web application projects).

Preview 5 includes a bunch of new features and refinements (these build on the additions in "Preview 4"). You can read detailed "Preview 5" release notes that cover changes/additions here. In this blog post I'm going to cover one of the biggest areas of focus with this release: form posting scenarios. You can download a completed version of the application I'll build below here.

Basic Form Post with a Web MVC Pattern

Let's look at a simple form post scenario - adding a new product to a products database:

The page above is returned when a user navigates to the "/Products/Create" URL in our application. The HTML form markup for this page looks like below:

The markup above is standard HTML. We have two <input type="text"/> textboxes within a <form> element. We then have an HTML submit button at the bottom of the form. When pressed it will cause the form it is nested within to post the form inputs to the server. The form will post the contents to the URL indicated by its "action" attribute - in this case "/Products/Save".

Using the previous "Preview 4" release of ASP.NET we might have implemented the above scenario using a ProductsController class like below that implements two action methods - "Create" and "Save":

The "Create" action method above is responsible for returning an html view that displays our initial empty form. The "Save" action method then handles the scenario when the form is posted back to the server. The ASP.NET MVC framework automatically maps the "ProductName" and "UnitPrice" form post values to the method parameters on the Save method with the same names. The Save action then uses LINQ to SQL to create a new Product object, assigns its ProductName and UnitPrice values with the values posted by the end-user, and then attempts to save the new product in the database. If the product is successfully saved, the user is redirected to a "/ProductsAdded" URL that will display a success message. If there is an error we redisplay our "Create" html view again so that the user can fix the issue and retry.

We could then implement a "Create" HTML view template like below that would work with the above ProductsController to generate the appropriate HTML. Note below that we are using the Html.TextBox helper methods to generate the <input type="text"/> elements for us (and automatically populate their value from the appropriate property in our Product model object that we passed to the view):

Form Post Improvements with Preview 5

The above code works with the previous "Preview 4" release, and continues to work fine with "Preview 5". The "Preview 5" release, though, adds several additional features that will allow us to make this scenario even better.

These new features include:

The ability to publish a single action URL and dispatch it differently depending on the HTTP Verb

Model Binders that allow rich parameter objects to be constructed from form input values and passed to action methods

Helper methods that enable incoming form input values to be mapped to existing model object instances within action methods

Improved support for handling input and validation errors (for example: automatically highlighting bad fields and preserving end-user entered form values when the form is redisplayed to the user)

I'll use the remainder of this blog post to drill into each of these scenarios.

[AcceptVerbs] and [ActionName] attributes

In our sample above we implemented our product add scenario across two action methods: "Create" and "Save". One motivation for partitioning the implementation like this is that it makes our Controller code cleaner and easier to read.

The downside to using two actions in this scenario, though, is that we end up publishing two URLs from our site: "/Products/Create" and "/Products/Save". This gets problematic in scenarios where we need to redisplay the HTML form because of an input error - since the URL of the redisplayed form in the error scenario will end up being "/Products/Save" instead of "/Products/Create" (because "Save" that was the URL the form was posted to). If an end-user adds this redisplayed page to their browser favorites, or copy/pastes the URL and emails it to a friend, they will end up saving the wrong URL - and will likely have an error when they try and access it later. Publishing two URLs can also cause problems with some search engines if your site is crawled and they attempt to automatically traverse your action attributes.

One way to work around these issues is to publish a single "/Products/Create" URL, and then have different server logic depending on whether it is a GET or POST request. One common approach used to-do this with other web MVC frameworks is to simply have a giant if/else statement within the action method and branch accordingly:

The downside with the above approach, though, is that it can make the action implementation harder to read, as well as harder to test.

ASP.NET MVC "Preview 5" now offers a better option to handle this scenario. You can create overloaded implementations of action methods, and use a new [AcceptVerbs] attribute to have ASP.NET MVC filter how they are dispatched. For example, below we can declare two Create action methods - one that will be called in GET scenarios, and one that will be called in POST scenarios:

This approach avoids the need for giant "if/else" statement within your action methods, and enables a cleaner structuring of your action logic. It also eliminates the need to mock the Request object in order to test these two different scenarios.

You can also optionally now use a new [ActionName] attribute to allow the method name implementation on your controller class to be different than that from the published URL. For example, if rather than having two overloaded Create methods in your controller you instead wanted to have the POST method be named "Save", you could apply the [ActionName] attribute to it like so:

Above we have the same controller method signature (Create and Save) that we had in our initial form post sample. The difference, though, is that we are now publishing a single URL (/Products/Create) and are automatically varying the handling based on the incoming HTTP verb (and so are browser favorites and search engine friendly).

Model Binders

In our sample above the signature of the Controller action method that handles the form-post takes a String and a Decimal as method arguments. The action method then creates a new Product object, assigns these input values to it, and then attempts to insert it into the database:

One of the new capabilities in "Preview 5" that can make this scenario cleaner is its "Model Binder" support. Model Binders provide a way for complex types to be de-serialized from the incoming HTTP input, and passed to a Controller action method as arguments. They also provide support for handling input exceptions, and make it easier to redisplay forms when errors occur (without requiring the end-user to have to re-enter all their data again - more on this later in this blog post).

For example, using the model binder support we could re-factor the above action method to instead take a Product object as an argument like so:

This makes the code a little more terse and clean. It also allows us to avoid having repetitive form-parsing code scattered across multiple controllers/actions (allowing us to maintain the DRY principle: "don't repeat yourself").

Registering Model Binders

Model Binders in ASP.NET MVC are classes that implement the IModelBinder interface, and can be used to help manage the binding of types to input parameters. A model binder can be written to work against a specific object type, or can alternatively be used to handle a broad range of types. The IModelBinder interface allows you to unit test binders independent of the web-server or any specific controller implementation.

Model Binders can be registered at 4 different levels within an ASP.NET MVC application, which enables a great deal of flexibility in how you use them:

1) ASP.NET MVC first looks for the presence of a model binder declared as a parameter attribute on an action method. For example, we could indicate that we wanted to use a hypothetical "Bind" binder by annotating our product parameter using an attribute like below (note how we are indicating that only two properties should be bound using a parameter on the attribute):

Note: "Preview 5" doesn't have a built-in [Bind] attribute like above just yet (although we are considering adding it as a built-in feature of ASP.NET MVC in the future). However all of the framework infrastructure necessary to implement a [Bind] attribute like above is now implemented in preview 5. The open source MVCContrib project also has a DataBind attribute like above that you can use today.

2) If no binder attribute is present on the action parameter, ASP.NET MVC then looks for the presence of a binder registered as an attribute on the type of the parameter being passed to the action method. For example, we could register an explicit "ProductBinder" binder for our LINQ to SQL "Product" object by adding code like below to our Product partial class:

3) ASP.NET MVC also supports the ability to register binders at application startup using the ModelBinders.Binders collection. This is useful when you want to use a type written by a third party (that you can't annotate) or if you don't want to add a binder attribute annotation on your model object directly. The below code demonstrates how to register two type-specific binders at application startup in your global.asax:

4) In addition to registering type-specific global binders, you can use the ModelBinders.DefaultBinder property to register a default binder that will be used when a type-specific binder isn't found. Included in the MVCFutures assembly (which is currently referenced by default with the mvc preview builds) is a ComplexModelBinder implementation that uses reflection to set properties based on incoming form post names/values. You could register it to be used as the fallback for all complex types passed as Controller action arguments using the code below:

Note: the MVC team plans to tweak the IModelBinder interface further for the next drop (they recently discovered a few scenarios that necessitate a few changes). So if you build a custom model binder with preview 5 expect to have to make a few tweaks when the next drop comes out (probably nothing too major - but just a heads up that we know a few arguments will change on its methods).

UpdateModel and TryUpdateModel Methods

The ModelBinder support above is great for scenarios where you want to instantiate new objects and pass them in as arguments to a controller action method. There are also scenarios, though, when you want to be able to bind input values to existing object instances that you own retrieving/creating yourself within the action method. For example, when enabling an edit scenario for an existing product in the database, you might want to use an ORM to retrieve an existing product instance from the database first within your action method, then bind the new input values to the retrieved product instance, and then save the changes back to the database.

"Preview 5" adds two new methods on the Controller base class to help enable this - UpdateModel() and TryUpdateModel(). Both allow you to pass in an existing object instance as the first argument, and then as a second argument you pass in a security white-list of properties you want to update on them using the form post values. For example, below I'm retrieving a Product object using LINQ to SQL, and then using the UpdateModel method to update the product's name and price properties with form data.

The UpdateModel methods will attempt to update all of the properties you list (even if there is an error on an early one in the list). If it encounters an error for a property (for example: you entered bogus string data for a UnitPrice property which is of type Decimal), it will store the exception object raised as well the original form posted value in a new "ModelState" collection added with "Preview 5". We'll cover this new ModelState collection in a little bit - but in a nutshell it provides an easy way for us to redisplay forms with the user-entered values automatically populated for them to fix when there is an error.

After attempting to update all of the indicated properties, the UpdateModel method will raise an exception if any of them failed. The TryUpdateModel method works the same way - except that instead of raising an exception it will return a boolean true/false value which indicates whether there were any errors. You can choose whichever method works best with your error handling preferences.

Product Edit Example

To see an example of using the UpdateModel method in use, let's implement a simple product editing form. We'll use a URL format of /Products/Edit/{ProductId} to indicate which product we want to edit. For example, below the URL is /Products/Edit/4 - which means we are going to edit the product whose ProductId is 4:

Users can change the product name or unit price, and then click the Save button. When they do our post action method will update the database and then show the user a "Product Updated!" message if it was successful:

We can implement the above functionality using the two Controller actions methods below. Notice how we are using the [AcceptVerbs] attribute to differentiate the Edit action that displays the initial form, and the one that handles the form post submission:

Our POST action method above uses LINQ to SQL to retrieve an instance of the product object we are editing from the database, then uses UpdateModel to attempt to update the product's ProductName and UnitPrice values using the form post values. It then calls SubmitChanges() on the LINQ to SQL datacontext to save the updates back to the database. If that was successful, we then store a success message string in the TempData collection and redirect the user back to the GET action method using a client-side redirect (which will cause the newly saved product to be redisplayed - along with our TempData message string indicating it was updated). If there is an error either with the form posted values, or with updating the database, an exception will be raised and caught in our catch block - and we will redisplay the form view again to the user for them to fix.

You might wonder - what is up with this redirect when we are successful? Why not just redisplay the form again and show the success message? The reason for the client-redirect is to ensure that if the user hits the refresh button after successfully pressing the save button, they don't resubmit the form again and get hit with a browser prompt like this:

Doing the redirect back to the GET version of the action method ensures that a user hitting refresh will simply reload the page again and not post back. This approach is called the "Post/Redirect/Get" (aka PRG) pattern. Tim Barcz has a nice article here that talks about this more with ASP.NET MVC.

The above two controller action methods are all we need to implement in order to handle editing and updating a Product object. Below is the "Edit" view to go with the above Controller:

Useful Tip: In the past once you started added parameters to URLs (for example: /Products/Edit/4) you had to write code in your view to update the form's action attribute to include the parameters in the post URL. "Preview 5" includes a Html.Form() helper method that can make this easier. Html.Form() has many overloaded versions that allow you to specify a variety of parameter options. A new overloaded Html.Form() method that takes with no parameters has been added that will now output the same URL as the current request.

For example, if the incoming URL to the Controller that rendered the above view was "/Products/Edit/5", calling Html.Form() like above would automatically output <form action="/Products/Edit/5" method="post"> as the markup output. If the incoming URL to the Controller that rendered the above view was "/Products/Edit/55", calling Html.Form() like above would automatically output <form action="/Products/Edit/55" method="post"> as the markup output. This provides a nifty way to avoid having to write any custom code yourself to construct the URL or indicate parameters.

Unit Testing and UpdateModel

In this week's Preview 5 drop the UpdateModel methods always work against the Request object's Form post collection to retrieve values. This means that to test the above form post action method you'd need to mock the request object in your unit test.

With the next MVC drop we'll also add an overloaded UpdateModel method that allows you to pass in your own collection of values to use instead. For example, we would be able to use the new FormCollection type in preview 5 (which has a ModelBuilder that automatically populates it with all form post values) and pass it to the UpdateModel method as an argument like so:

Using an approach like above will allow us to unit test our form-post scenario without having to use any mocking. Below is an example unit test we could write that tests that a POST scenario successfully updates with new values and redirects back to the GET version of our action method. Notice that we do not need to mock anything (nor do we have to rely on any special helper methods) in order to unit test all the functionality in our controller:

Handling Error Scenarios - Redisplaying Forms with Error Messages

One of the important things to take care of when handling form post scenarios are error conditions. These includes cases where an end-user posts incorrect input (for example: a string instead of a number for a Decimal unit-price), as well as cases where the input format is valid, but the business rules behind the application disallow something from being created/updated/saved (for example: making a new order for a discontinued product).

If a user makes a mistake when filling out a form, the form should be redisplayed with informative error messages that guide them towards fixing it. The form should also preserve the input data the user originally entered - so that they don't have to refill this manually. This process should repeat as many times as necessary until the form successfully completes.

Basic Form Entry Error Handling and Input Validation with ASP.NET MVC

In our product edit sample above we haven't written much error handling code in either our Controller or our View. Our Edit post action simply wraps a try/catch error handling block around the UpdateModel() input mapping call, as well as the database save SubmitChanges() call. If an error occurs, the controller saves an output message in the TempData collection, and then returns our edit view to be redisplayed:

With earlier preview releases of ASP.NET MVC the above code wouldn't be enough to deliver a good end-user experience (since it wouldn't highlight the problem, nor preserve user input if there was an error).

However, with "Preview 5" you'll find that you now get a decent end-user error experience out of the box with just the above code. Specifically, you'll find that when our edit view is redisplayed because of an input error it now highlights all input controls that have problems, and preserves their input for us to fix:

How, you might ask, did the Unit Price textbox highlight itself in red and know to output the originally entered user value?

"Preview 5" introduces a new "ModelState" collection that is passed as part of the "ViewData" sent from the Controller to the View when it renders. The ModelState collection provides a way for Controllers to indicate that an error exists with a model object or model property being passed to the View, and allows a human friendly error message to be specified that describes the issue, as well as the original value entered by the end-user.

Developers can explicitly write code to add items into the ModelState collection within their Controller actions. ASP.NET MVC's ModelBinders and UpdateModel() helper methods also automatically populate this collection by default when they encounter input errors. Because we were using the UpdateModel() helper method in our Edit action above, when it failed in its attempt to map the UnitPrice TextBox's "gfgff23.02" input to the Product.UnitPrice property (which is of type Decimal) it automatically added an entry to the ModelState collection.

Html helper methods inside the View by default now check the ModelState collection when rendering output. If an error for an item they are rendering exists, they will now render the originally entered user value as well as a CSS error class to the HTML input element. For example, for our "Edit" View above we are using the Html.TextBox() helper method to render the UnitPrice of our Product object:

When the view was rendered during the error scenario above the Html.TextBox() method checked the ViewData.ModelState collection to see if there were any issues with the "UnitPrice" property of our Product object, and when it saw that there was rendered the originally entered user input ("gfgff23.02") and added a css class to the <input type="textbox"/> it output:

You can customize the appearance of the the error css classes to look however you want. The default CSS error rule for input elements in the stylesheet created in new ASP.NET MVC projects looks like below:

Adding Additional Validation Messages

The built-in HTML form helpers provide basic visual identification of input fields with issues. Let's now add some more descriptive error messages to the page as well. To-do this we can use the new Html.ValidationMessage() helper method in "Preview 5". This method will output the error message in the ModelState collection that is associated with a given Model or Model property.

For example: we could update our view to use the Html.ValidationMessage() helper to the right of the textboxes like so:

Now when the page renders with an error, an error message will be displayed next to the fields with problems:

There is an overloaded version of the Html.ValidationMessage() method that takes a second parameter that allows the view to specify an alternative text to display:

One common use case is to output the * character next to the input fields, and then add the new Html.ValidationSummary() helper method (new in "Preview 5") near the top of the page to list all the error messages:

The Html.ValidationSummary() helper method will then render a <ul><li></ul> list of all the error messages our ModelState collection, and a * and red border will indicate each input element that has a problem:

Note that we haven't had to change our ProductsController class at all to achieve this.

Supporting Business Rules Validation

Supporting input validation scenarios like above is useful, but rarely sufficient for most applications. In most scenarios you also want to be able to enforce business rules, and have your application UI cleanly integrate with them.

ASP.NET MVC supports any data layer abstraction (both ORM and non-ORM based), and allows you to structure your domain model, as well as associated rules/constraints, however you want. Capabilities like Model Binders, the UpdateModel helper method, and all of the error display and validation message support are explicitly designed so that you can use whatever preferred data access story you want within your MVC applications (including LINQ to SQL, LINQ to Entities, NHibernate, SubSonic, CSLA.NET, LLBLGen Pro, WilsonORMapper, DataSets, ActiveRecord, and any other).

Adding Business Rules to a LINQ to SQL Entity

In the sample above I've been using LINQ to SQL to define my Product entity and perform my data access. So far, the only level of domain rules/validation that I am using on my Product entity are those inferred by LINQ to SQL from the SQL Server metadata (nulls, data type and length, etc). This will catch scenarios like above (where we are trying to assign bogus input to a Decimal). However, they won't be able to model business issues that can't be easily declared using SQL metadata. For example: disallowing the reorder level of a product to be greater than zero if it has been discontinued, or disallowing a product to be sold for less than what our supplier price is, etc. For scenarios like these we need to add code to our model to express and integrate these business rules.

The wrong place to add this business rule logic is in the UI layer of our application. Adding them there is bad for many reasons. Among others it will almost certainly lead to duplicated code - since you'll end up copying the rules around from UI to UI and from form to form. In addition to being time-consuming, there is an excellent chance doing so will lead to bugs when you change your business rule logic, and you forget to update it everywhere.

A much better place to incorporate these business rules is at your model or domain level. That way they can be used and applied regardless of what type of UI or form or service works with it. Changes to the rules can be made once, and picked up everywhere without having to duplicate any logic.

There are several patterns and approaches we could take to integrate richer business rules to the Product model object we've been using above: we could define the rules within the object, or external from the object. We could use declarative rules, a re-usable rules engine framework, or imperative code. The key point is that ASP.NET MVC allows us to use any or all of these approaches (there aren't a bunch of features that require you to always do it one way - you instead have the flexibility to reflect them however you want, and the MVC features are extensible enough to integrate with almost anything).

For this blog post I'm going to use a relatively simple rules approach. First I'm going to define a "RuleViolation" class like below that we can use to capture information about a business rule that is being violated within our model. This class will expose an ErrorMessage string with details about the error, as well as expose the primary property name and property value associated with it that is causing the violation:

(note: For simplicity sake I'm only going to store only one property - in more complex applications this might instead be a list so that multiple properties could be specified).

I will then define an IRuleEntity interface that has a single method - GetRuleViolations() - which returns back a list of all current business rule violations with that entity:

I can then have my Product class implement this interface. To keep the sample simple I'm embedding the rule definition and evaluation logic inside the method. There are better patterns that you can use to enable reusable rules, as well as to handle more complex rules. If this sample grew I'd refactor the method so that the rules and their evaluation where defined elsewhere, but for now to keep this simple we'll just evaluate three business rules below like so:

Our application can now query the Product (or any other IRuleEntity) instance to check its current validation status, as well as retrieve back RuleViolation objects that can be used to help present UI that can guide an end-user of the application to help fix them. It also allows us to easily unit test our business rules independent of the application UI.

For this particular sample I am going to choose to enforce that our Product object is never saved in the database in an invalid state (meaning all RuleViolations must be fixed before the Product object can be saved in the database). We can do this with LINQ to SQL by adding an OnValidate partial method to the Product partial class. This method will get called automatically by LINQ to SQL any time database persistence occurs. Below I'm calling the GetRuleViolations() method we added above, and am raising an exception if there are unresolved errors. This will abort the transaction and prevent the database from being updated:

And now in addition to having a friendly helper method that allows us to retrieve RuleViolations from a Product, we have enforcement that those RuleViolations must be fixed before our database is ever updated.

Integrating the above Rules into our ASP.NET MVC UI

Once we've implemented our business rules, and exposed our RuleViolations like above, it will be relatively easy to integrate it into our ASP.NET MVC sample.

Because we added the OnValidate partial method to our Product class, calling northwind.SubmitChanges() will raise an exception if there are any business rule validation issues with a Product object that we are trying to save. This exception will abort any database transactions, and will be caught in our catch block below:

The one extra line of code we'll then add to our error catch block is some logic to call a UpdateModelStateWithViolations() helper method defined below. This method retrieves a list of all rule violations from an entity, and then updates a ModelState collection with appropriate model errors (including references to the properties on our entity object that caused them):

Once we do this, we can re-run our application. Now, in addition to seeing input format related error messages, ASP.NET MVC's validation helpers will also display our business rule violations as well.

For example, we could set the unit price to be less than a $1, and try to set the Reorder level to be -1 (both values are legal from an input format perspective - but both violate our business rules). When we do this and hit save we'll see the errors show up in our Html.ValidationSummary() list, and the corresponding textboxes will be flagged:

Our business rules can span multiple Product properties. For example: you might have noticed above that I added a rule that said that the reorder level can't be greater than zero if the product is discontinued:

The only changes we needed to make to our "Edit" view template throughout this entire business rules process has been to add two more Product properties (Reorder and Discontinued) to the file:

Now we can add any number of additional business validation rules we want to our Product entity, and we do not need to update the Edit view nor the ProductsController in order to have our UI support them.

We can also unit-test our model and business rules separately from our Controller and View. We can unit-test our URL routing separately from our Controller, Views and Models. And we can unit test our Controller separately from our Views. All of the scenarios shown in this blog post will support unit testing without requiring any mocking or stubbing to be used. The end result are applications that are easily testable, and which can support a nice TDD workflow.

Summary

This post has provided a quick look at how form post scenarios work with ASP.NET MVC Preview 5. Hopefully after reading it you have a better sense of how you handle form and input entry scenarios using a MVC model. You can download a completed C# version of the application I built above here. I will post a VB version a little later this week (it is unfortunately 4:30am while I'm typing this and I need to hop on a plane in a few short hours and have not started packing yet).

Important: If you don't like the MVC model or don't find it natural to your style of development, you definitely don't have to use it. It is a totally optional offering - and does not replace the existing WebForms model. Both WebForms and MVC will be fully supported and enhanced going forward (the next release of ASP.NET WebForms will add richer URL routing features, better HTML markup/client-side ID/CSS support, and more). So if after reading the above post you think "hmm - that doesn't feel natural to me", then both don't worry, and don't feel like you should or need to use it (you don't).

In my next post on MVC I'll cover how to integrate AJAX into your ASP.NET MVC applications.

Hope this helps,

Scott

Quick Update

ScottGu — Tue, 02 Sep 2008 14:21:59 GMT

I've received a number of (very nice) emails recently asking if I was ok - since my blog has been silent the last few weeks (and much of the summer).

Just to address people's concerns - I'm alive and well. :-) I've just been on vacation the last 6 weeks, and have unfortunately not had free time to post (I've been changing a lot of diapers).

I am still on vacation another week before I officially return to work. I did get a chance to write up a quick post this weekend that covers some of the new ASP.NET MVC Preview 5 features, though, that will hopefully provide some interim reading until I can resume a more regular posting schedule over the next month when I get back into the office.

Thanks,

Scott

6 september: de 2e Nederlandse CodeCamp!

dvroegop — Thu, 28 Aug 2008 20:20:47 GMT

Op zaterdag 6 september is het weer zo ver: we hebben weer een codecamp! Voor diegene die niet weten wat het is, zal ik je niet vermoeien met een lang verhaal (er zijn hele websites vol over geschreven). Het komt neer op het volgende: een dag van code, code sharing, freaking en gezellig samenzijn. Een evenement door ontwikkelaars, voor ontwikkelaars. De regie ligt voor een belangrijk deel bij de deelnemers! Het aantal plaatsen voor deelnemers is wel beperkt tot maximaal 120. Wacht dus niet te lang met beslissen want voor je het weet is er geen plaats meer.
Een Code Camp is volledig gratis voor alle deelnemers, en dat is inclusief koffie, lunch en andere noodzakelijke randvoorwaarden. De reden dat we het gratis kunnen organiseren is dat Microsoft onze hoofdsponsor is en Class-A onze silversponsor (ja, inderdaad: hetzelfde Class-A waar we 2 dagen eerder, dus 4 september een dotNed meeting hebben: heb je je al ingeschreven? )

Het enige wat we van je verlangen is dat je je even inschrijft op http://www.codecamp.nl

We hebben er voor gezorgd dat we een indrukwekkende lijst met onderwerpen hebben. Ook de sprekerslijst mag er zijn: het is een mix van sprekers uit de community en professionele sprekers die regelmatig op events als TechEd staan. En dat allemaal voor niets!

Kijk voor meer informatie en natuurlijk om je in te schrijven op http://www.codecamp.nl

Graag zie ik je op zaterdag 6 september!

3D Graphics in WPF, deel 8a (de source code)

dvroegop — Thu, 28 Aug 2008 11:10:04 GMT

Ik heb alle source code even in een projectje geplaatst, zodat je er mee kunt spelen. Je vindt de sources hier.

3D Graphics in WPF, deel 8 (het tekenen van de box in code)

dvroegop — Thu, 28 Aug 2008 10:24:00 GMT

We hebben bijna alle elementen op hun plaats staan voor onze Box class. Het enige wat we nu nog moeten doen is het daadwerkelijke tekenen. Hier is de code

private void DrawIt()

{

�� // Maak een kopie

�� var positions = _mesh.Positions;

�� var indices = _mesh.TriangleIndices;

�� var normals = _mesh.Normals;

�� var textures = _mesh.TextureCoordinates;

�

�� _mesh.Positions = null;

�� _mesh.TriangleIndices = null;

�� _mesh.Normals = null;

�� _mesh.TextureCoordinates = null;

�

�� positions.Clear();

�� indices.Clear();

�� normals.Clear();

�� textures.Clear();

�

�� // Definieer de punten

�� Point3D pointA = LeftBottomCorner;

�� Point3D pointB = new Point3D(LeftBottomCorner.X + Width, LeftBottomCorner.Y, LeftBottomCorner.Z);

�� Point3D pointC = new Point3D(LeftBottomCorner.X + Width, LeftBottomCorner.Y, LeftBottomCorner.Z - Depth);

�� Point3D pointD = new Point3D(LeftBottomCorner.X, LeftBottomCorner.Y, LeftBottomCorner.Z - Depth);

�� Point3D pointE = new Point3D(LeftBottomCorner.X, LeftBottomCorner.Y + Height, LeftBottomCorner.Z);

�� Point3D pointF = new Point3D(LeftBottomCorner.X + Width, LeftBottomCorner.Y + Height, LeftBottomCorner.Z);

�� Point3D pointG = new Point3D(LeftBottomCorner.X + Width, LeftBottomCorner.Y + Height, LeftBottomCorner.Z - Depth);

�� Point3D pointH = new Point3D(LeftBottomCorner.X, LeftBottomCorner.Y + Height, LeftBottomCorner.Z - Depth);

�

�� // Voeg de punten toe

�� // Grond vlak

�� positions.Add(pointD);

�� positions.Add(pointC);

�� positions.Add(pointB);

�� positions.Add(pointA);

�� // Voor vlak

�� positions.Add(pointA);

�� positions.Add(pointB);

�� positions.Add(pointF);

�� positions.Add(pointE);

�� // Rechtervlak

�� positions.Add(pointB);

�� positions.Add(pointC);

�� positions.Add(pointG);

�� positions.Add(pointF);

�� // Achter vlak

�� positions.Add(pointC);

�� positions.Add(pointD);

�� positions.Add(pointH);

�� positions.Add(pointG);

�� // Linker vlak

�� positions.Add(pointD);

�� positions.Add(pointA);

�� positions.Add(pointE);

�� positions.Add(pointH);

�� // Boven vlak

�� positions.Add(pointE);

�� positions.Add(pointF);

�� positions.Add(pointG);

�� positions.Add(pointH);

�

�� // Voeg de TriangleIndices toe.

�� for (int i = 0; i

�� {

�� indices.Add((i * 4) + 0);

�� indices.Add((i * 4) + 1);

�� indices.Add((i * 4) + 2);

�� indices.Add((i * 4) + 0);

�� indices.Add((i * 4) + 2);

�� indices.Add((i * 4) + 3);

�� }

�

�� // Zet de collections terug in de mesh

�� _mesh.TextureCoordinates = textures;

�� _mesh.Normals = normals;

�� _mesh.TriangleIndices = indices;

�� _mesh.Positions = positions;

}

Het lijkt veel maar echt ingewikkeld is het niet. Er is echter een klein dingetje dat wel erg belangrijk is: de properties Positions, TriangleIndices, Normals en TextureCoordinates (die laaste is nieuw, daar kom ik op terug als we het over materialen gaan hebben) zijn DependencyProperties. Als we iets wijzigigen in deze collections, zal er een PropertyChanged even afgevuurd worden in onze _mesh member (van het type MeshGeometry3D) en wordt de boel opnieuw getekend. Voor ieder punt dat we toevoegen zal hij opnieuw berekend worden. Ook voor iedere TriangleIndex die we toevoegen gaan WPF opnieuw rekenen. Hetzelfde geldt voor de Normals en TextureCoordinates collections. Aangezien we een hoop punten en zo toevoegen zal er een hoop nodeloze berekeningen plaats gaan vinden!

Om dat te voorkomen maken we eerst een kopie van de collections. Vervolgens zetten we de properties van de _mesh op null. Als we nu iets doen met de kopie van de collections heeft dat geen enkele invloed op de _mesh. Aan het einde van de method plaatsen we de gewijzigde collecties weer terug in de _mesh waarna WPF alles opnieuw gaat berekenen. Dit scheelt enorm veel tijd!

Nu we een kopie hebben van de collecties, wissen we de inhoud. Immers: we gaan alles opnieuw maken!

Ik definieer eerst de 8 hoekpunten. Dat hoef ik maar een maal te doen, we hergebruiken de gemaakte punten later bij het toevoegen aan de positions collectie. Je ziet dat de punten gelijk op de goede plaats staan: ik tel de linkeronder hoek er bij op en zorg ervoor dat de Width, Height en Depth gelijk meegenomen worden.

Nu definieren we de zes vlakken. Let er op dat je het wel in de goede volgorde doet, alle punten worden tegen de klok in gedefinieerd.

Als we alle punten toegevoegd hebben, wordt het tijd om de TriangleIndices berekent. Dit is hetzelfde als wat je gezien hebt in mijn vorige post, nu alleen voor alle vlakken. Als dat gebeurdt is, plaatsen we de collecties terug en we zijn klaar!

Nou ja.. we moeten nog een aanroep naar DrawIt() plaatsen in de constructor (aan het einde) en belangrijker: in de PropertyChanged:

///

/// Initializes a new instance of the class.

///

public Box()

{

�� _model = new GeometryModel3D();

�� _mesh = new MeshGeometry3D();

�� _model.Geometry = _mesh;

�� this.Content = _model;

�

�� DrawIt();

}

en...

///

/// Handles the Property Changed event (static)

///

/// The

/// instance containing the event data.

private void PropertyChanged(DependencyPropertyChangedEventArgs args)

{

�� // opnieuw tekenen!

�� DrawIt();

}

Om dit nu zichtbaar te maken in onze XAML file, moeten we een referentie naar deze code in de header van de file maken.

De XAML ziet er nu als volgt uit:

<Window x:Class="WpfApplication11.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:detrio="clr-namespace:WpfApplication11"
    Title="Window1" Height="300" Width="300">
    <Viewport3D>
        <detrio:Box LeftBottomCorner="0 0 0" Width="1" Height="1" Depth="1">
            <detrio:Box.Material>
                <DiffuseMaterial Brush="Blue"/>
            </detrio:Box.Material>
        </detrio:Box>

        <!-- Lampjes! -->
        <ModelVisual3D>
            <ModelVisual3D.Content>
                <Model3DGroup>
                    <AmbientLight Color="#404040"/>
                    <DirectionalLight Color="#BFBFBF" Direction="1 -1 -1"/>
                </Model3DGroup>
            </ModelVisual3D.Content>
        </ModelVisual3D>

        <!-- Camera -->
        <Viewport3D.Camera>
            <PerspectiveCamera Position="2.1 2 2" 
                           LookDirection="-0.5 -0.7 -1" 
                           UpDirection="0 1 0" 
                           FieldOfView="60.0" 
                           />
        </Viewport3D.Camera>
    </Viewport3D>
</Window>

En meer hebben we niet nodig!

Ik weet niet hoe het met jou zit, maar ik ben dat blauwe blokje een beetje zat. Laten we de volgende keer eens kijken of we die niet mooier kunnen maken, laten we het eens over Materials gaan hebben!

3D Graphics in WPF, deel 7 (de box in code)

dvroegop — Wed, 27 Aug 2008 17:18:28 GMT

Ik ben MVP voor C#, dus het wordt tijd dat ik terug ga naar mijn roots en wat C# code laat zien.

In mijn vorige post heb ik laten zien hoe je een kubus definieert. Het kwam neer op veel punten berekenen en vervolgens aangeven hoe je die punten met elkaar verbindt. Nu hebben we allemaal een computer voor onze neus staan en als er iets is waar computers goed in zijn, is het wel in rekenen. Waarom zouden we dat dan handmatig doen? Laten we de punten voor de kubussen in code berekenen!

Nu is het natuurlijk erg eenvoudig om een stuk code te schrijven die een paar parameters krijgt (een positie en de afmetingen) en die dan XAML code uitspuugt die je kunt plakken in je XAML bestand, maar dat is niet wat we willen.

We willen dat we in onze XAML code de volgende code op kunnen nemen met als resultaat dat er een mooi kubusje op het scherm staat:

<detrio:Box LeftBottomCorner="0 0 0"
            Width="2.0"
            Height="1.0"
            Depth="1.5"
            >
    <detrio:Box.Material>
        <DiffuseMaterial Brush="Blue"/>
    </detrio:Box.Material>
</detrio:Box>

Dat gaan we dan ook doen.

We moeten onze Box class kunnen toevoegen aan onze Viewport3D. We hebben gezien hoe we dat in XAML doen: we maken een GeometryModel3D, zetten de punten en triangleindices goed en klaar. Het lijkt voor de hand liggend om onze Box class af te leiden van GeometryModel3D ware het niet dat dat niet kan: bijna alles in WPF is sealed en kan dus niet als base-class gebruikt worden.

Een van de weinige classes die dat niet hebben is ModelVisual3D. Nu is dit gelukkig ook de class die in de Children collection van een Viewport3D geplaatst kan worden, dus laten we die maar gebruiken.

Definieer de volgende class:

//-----------------------------------------------------------------------

// <copyright file="Box.cs" company="Detrio Consultancy b.v.">

// </copyright>

// <author>Dennis Vroegop</author>

//-----------------------------------------------------------------------

namespace WpfApplication11

{

#region Using statements

using System;

using System.Windows.Media.Media3D;

#endregion

/// <summary>

/// Een rechthoekig ding voor op het scherm

/// </summary>

internal class Box : ModelVisual3D

{

}

We hebben nu een Box class welke afgeleid is van ModelVisual3D. Hier kunnen we in de Content dan onze GeometryModel3D maken, en in de GeometryModel3D onze MeshGeometry3D. Aangezien we dat altijd moeten doen kunnen we daar gelijk even een paar private fields van maken:

internal class Box : ModelVisual3D

{

private GeometryModel3D _model;

private MeshGeometry3D _mesh;

/// <summary>

/// Initializes a new instance of the <see cref="Box"/> class.

/// </summary>

public Box()

{

_model = new GeometryModel3D();

_mesh = new MeshGeometry3D();

_model.Geometry = _mesh;

this.Content = _model;

}

Die hebben we maar alvast!

Om een object zichtbaar te maken moeten we ook Materials kunnen toevoegen. Dus daar maken we gelijk maar even een property van. Of liever gezegd: een DependencyProperty. Voor diegene die niet weten wat een DependencyProperty is, raad ik je aan om deze post eens te bekijken. Ik wacht wel even....

Voeg de volgende code toe:

1 /// <summary>

2 /// De material property die het uiterlijk bepaalt

3 /// </summary>

4 private static readonly DependencyProperty MaterialProperty =

5 GeometryModel3D.MaterialProperty.AddOwner(

6 typeof(Box),

7 new PropertyMetadata(MaterialPropertyChanged));

10 /// <summary>

11 /// Gets or sets the material.

12 /// </summary>

13 /// <value>The material.</value>

14 public Material Material

15 {

16 get { return (Material)GetValue(MaterialProperty); }

17 set { SetValue(MaterialProperty, value); }

18 }

20 /// <summary>

21 /// Wordt aangeroepen als de MaterialProperty van inhoud wijzigt

22 /// (static).

23 /// </summary>

24 /// <param name="obj">The obj.</param>

25 /// <param name="args">The <see cref="System.Windows.DependencyPropertyChangedEventArgs"/>

26 /// instance containing the event data.</param>

27 private static void MaterialPropertyChanged(

28 DependencyObject obj,

29 DependencyPropertyChangedEventArgs args)

30 {

31 (obj as Box).MaterialPropertyChanged(args);

32 }

34 /// <summary>

35 /// Wordt aangeroepen als de MaterialProperty van inhoud wijzigt

36 /// (van deze instance)

37 /// </summary>

38 /// <param name="args">The <see cref="System.Windows.DependencyPropertyChangedEventArgs"/>

39 /// instance containing the event data.</param>

40 private void MaterialPropertyChanged(DependencyPropertyChangedEventArgs args)

41 {

42 _model.Material = args.NewValue as Material;

43 }

Dit is nogal wat. Ik zal uitleggen wat er hier gebeurt.

In regels 1 tot en met 7 maken we de nieuwe DependencyProperty. Of liever gezegd, we vertellen de Material property van _model (die heeft immers de Material property al) dat er een nieuwe owner bij gekomen is: onze Box! Als er nu iets gebeurt met de Material property op de _model, dan krijgen wij daar ook een notificatie van. En andersom uiteraard ook: als wij iets met Material doen, komt dat uiteindelijk bij de GeometryModel3D _model aan.

In regels 10 tot en met 18 maken we de normale CLR property aan, die niets anders doet dan de waardes doorgeven naar en van de DependencyProperty.

In regels 20 tot en met 32 hebben we de static method die aangeroepen wordt als er iets met de Material gebeurd. Het enige wat we hier doen is het aanroepen van de instance method MaterialPropertyChanged zodat de juiste instance actie kan ondernemen. Dit gebeurdt in regels 34 tot en met 43. We geven hier de nieuwe material door aan onze _model.

Laten we gelijk een paar andere DependencyProperties toevoegen:

1. Een Point3D voor de LeftBottomCorner waar de box in de scene geplaatst moet worden

2. Een double die de Width aangeeft

3. Een double die de Height aangeeft

4. Een double die de Depth aangeeft.

Komt 'ie:

1 /// <summary>

2 /// Left bottom corner

3 /// </summary>

4 private static readonly DependencyProperty LeftBottomCornerProperty =

5 DependencyProperty.Register("LeftBottomCorner",

6 typeof(Point3D),

7 typeof(Box),

8 new PropertyMetadata(new Point3D(0.0, 0.0, 0.0), PropertyChanged));

10 /// <summary>

11 /// Width

12 /// </summary>

13 private static readonly DependencyProperty WidthProperty =

14 DependencyProperty.Register("Width",

15 typeof(double),

16 typeof(Box),

17 new PropertyMetadata(1.0, PropertyChanged));

19 /// <summary>

20 /// Height

21 /// </summary>

22 private static readonly DependencyProperty HeightProperty =

23 DependencyProperty.Register("Height",

24 typeof(double),

25 typeof(Box),

26 new PropertyMetadata(1.0, PropertyChanged));

28 /// <summary>

29 /// Depth

30 /// </summary>

31 private static readonly DependencyProperty DepthProperty =

32 DependencyProperty.Register("Depth",

33 typeof(double),

34 typeof(Box),

35 new PropertyMetadata(1.0, PropertyChanged));

37 /// <summary>

38 /// Gets or sets the left bottom corner.

39 /// </summary>

40 /// <value>The left bottom corner.</value>

41 public Point3D LeftBottomCorner

42 {

43 get { return (Point3D)GetValue(LeftBottomCornerProperty); }

44 set { SetValue(LeftBottomCornerProperty, value); }

45 }

47 /// <summary>

48 /// Gets or sets the width.

49 /// </summary>

50 /// <value>The width.</value>

51 public double Width

52 {

53 get { return (double)GetValue(WidthProperty); }

54 set { SetValue(WidthProperty, value); }

55 }

57 /// <summary>

58 /// Gets or sets the height.

59 /// </summary>

60 /// <value>The height.</value>

61 public double Height

62 {

63 get { return (double)GetValue(HeightProperty); }

64 set { SetValue(HeightProperty, value); }

65 }

67 /// <summary>

68 /// Gets or sets the depth.

69 /// </summary>

70 /// <value>The depth.</value>

71 public double Depth

72 {

73 get { return (double)GetValue(DepthProperty); }

74 set { SetValue(DepthProperty, value); }

75 }

77 /// <summary>

78 /// Handles the Property Changed event (static)

79 /// </summary>

80 /// <param name="obj">The sender.</param>

81 /// <param name="args">The <see cref="System.Windows.DependencyPropertyChangedEventArgs"/>

82 /// instance containing the event data.</param>

83 private static void PropertyChanged(

84 DependencyObject obj,

85 DependencyPropertyChangedEventArgs args)

86 {

87 (obj as Box).PropertyChanged(args);

88 }

89 /// <summary>

90 /// Handles the Property Changed event (static)

91 /// </summary>

92 /// <param name="args">The <see cref="System.Windows.DependencyPropertyChangedEventArgs"/>

93 /// instance containing the event data.</param>

94 private void PropertyChanged(DependencyPropertyChangedEventArgs args)

95 {

96 // opnieuw tekenen!

97 }

Een hele lap, maar het meeste moet duidelijk zijn.

We definieren een aantal DependencyProperties, maken de CLR properties en zorgen ervoor dat ze allemaal de PropertyChanged method aanroepen.

Als er een wijziging komt in een van deze properties moeten we de box opnieuw gaan tekenen. Dat is wat we de volgende keer gaan doen!

3D Graphics in WPF, deel 6 (de box)

dvroegop — Wed, 27 Aug 2008 16:35:29 GMT

In de vorige posting liet ik je zien hoe je een vierkant definieert. Ik sloot af met de opmerking dat als je een kubus wilt tekenen, je vooral je gang moest gaan maar ik zou de code niet voor je intypen. De reden daarvoor is dat het heel veel saai werk is (waar heel makkelijk fouten insluipen!). Nou is het altijd aan te raden om mensen zelf aan het werk te zetten als ze iets willen leren, daar leren ze immers het meest van. Toch vond ik het een beetje flauw van me. Vandaar dat ik de code hier alsnog plaats. Let op: hier komt 'ie:

<GeometryModel3D>
    <GeometryModel3D.Geometry>
        <MeshGeometry3D 
            Positions="0 0 0, 1 0 0, 1 0 -1, 0 0 -1,
                       0 1 0, 1 1 0, 1 1 -1, 0 1 -1"
            TriangleIndices="0 1 5, 0 5 4,
                             1 2 6, 1 6 5,
                             2 3 7, 2 7 6,
                             3 0 4, 3 4 7,
                             4 5 6, 4 6 7,
                             0 3 2, 0 2 1"
            />
    </GeometryModel3D.Geometry>
    <GeometryModel3D.Material>
        <DiffuseMaterial Brush="Blue"/>
    </GeometryModel3D.Material>
    <GeometryModel3D.BackMaterial>
        <DiffuseMaterial Brush="HotPink"/> 
    </GeometryModel3D.BackMaterial>
</GeometryModel3D>

Tja. Zoals ik al zei: niet echt spannend, maar wel veel werk en vooral saai. Ik definieer eerst de punten voor het grondvlak, daarna de punten voor het bovenste vlak. Dan in de TriangleIndices verbind ik alle punten met elkaar, tegen de klok in. Als je nu met je camera gaat draaien zal er een box uitkomen. Maar... hij ziet er een beetje raar uit:

(ik gebruik voor de camera als Position (2.1, 2.0, 2.0) en als LookDirection (-0.5, -0.7, -1.0) )

Geen mooie vlakken, maar wel een mooi verloop in de kleuren. Niet helemaal zoals mijn box er in deel 3 er uit zag. Hoe kan dat nou?

Het antwoord heeft te maken met de belichting en hoe WPF die berekent. In deel 3 vertelde ik je dat de DirectionalLight voor ieder punt berekend hoeveel licht er op valt. Dat doet hij door naar de vector van de DirectionalLight.Direction te kijken en dan te berekenen hoe die zich verhoudt tot de normalvectors van onze vlakken. Als de direction vector het tegenovergestelde is van de normalvector van ons vlak, is de lichtinval 100%. Als hij er haaks op staat (of zelfs enigzins de zelfde richting opgaat) dan is de lichtinval 0%. En voor vectoren daar tussen in is de lichtinval een percentage van de totale hoeveelheid licht.

Dit doet WPF echter niet voor iedere normalvector per driehoek maar voor iedere normalvector op een punt.... Dus: WPF berekent voor ieder punt in onze objecten een normal vector en vermenigvuldigt die met de direction vector van het licht. Maar hoe berekent hij nu de normalvector van een punt? Een punt is namelijk geen vlak (daar heb je minstens 3 punten voor nodig) dus hoe doet hij dat nu? Het antwoord is simpel. WPF kijkt naar de vlakken waar dit punt deel uit van maakt, berekent voor die vlakken de normalvector en dat is dat de normalvector van de punten die bij dat vlak horen.

In theorie is dat simpel, in de praktijk is dat wat lastiger. Kijk bijvoorbeeld eens naar ons punt met de coordinaten (0,0,0). Bij welk vlak hoort dat? Volgens mij hoort dat bij 3 vlakken: het voorste vlak, het linkervlak en het onderste vlak. Dus hoe ziet de normalvector er dan uit? Tja: dat moet er wel uitzien als in het volgende plaatje. Ik heb gelijk de vectoren voor de andere punten erbij geplaatst.

Als de lichtinval op het grondvlak 100% zou moeten zijn, zou dat alleen gebeuren als de normaalvectoren loodrecht op dat vlak staan. Maar aangezien de verschillende hoekpunten onderdeel van meerdere vlakken zijn, wordt de normaalvectoren van die punten het gemiddelde van de normaalvectoren van de drie vlakken waar ieder punt bij hoort.

Erger nog: de kleur tussen de punten A en E wordt voor iedere pixel tussen die punten berekend: aangezien A en E totaal verschillende normaalvectoren en dus lichtintensiteiten hebben, zal het resultaat een verloop zijn. WPF gaat de kleuren mooi in elkaar over laten lopen.

Dit effect kan heel handig zijn. Als je een gebogen oppervlakte wilt tekenen zonder al te veel driehoeken te moeten tekenen, is dit precies het effect dat je wilt: door de gradients lijken de oppervlaktes gebogen te zijn. Maar in het geval van een box is dat helemaal niet handig!

We kunnen dit oplossen door het probleem bij de wortel aan te pakken. Als de oorzaak van het probleem ligt bij het delen van punten door verschillende vlakken, moeten we eenvoudigweg voor ieder vlak een eigen set punten definieren.

We krijgen dus in plaats van 8 punten 6 vlakken maal 4 punten per vlak = 24 punten (we delen per vierkant wel een paar punten maar aangezien die in hetzelfde vlak liggen geeft het niet: ze hebben toch al dezelfde normaalvector). Dat er van die 24 punten veel hetzelfde zijn is iets dat we dan maar voor lief moeten nemen.

De code ziet er nu als volgt uit:

<GeometryModel3D>
    <GeometryModel3D.Geometry>
        <MeshGeometry3D 
            Positions="0 0 0, 1 0 0, 1 1 0, 0 1 0,
                       1 0 0, 1 0 -1, 1 1 -1, 1 1 0,
                       1 0 -1, 0 0 -1, 0 1 -1, 1 1 -1,
                       0 0 -1, 0 0 0, 0 1 0, 0 1 -1,
                       0 1 0, 1 1 0, 1 1 -1, 0 1 -1,
                       0 0 0, 0 0 -1, 1 0 -1, 1 0 0"
            TriangleIndices="0 1 2 0 2 3
                             4 5 6 4 6 7
                             8 9 10 8 10 11
                             12 13 14 12 14 15
                             16 17 18 16 18 19
                             20 21 22 20 22 23"
            />
    </GeometryModel3D.Geometry>

Meer punten maar maak je daar geen zorgen om: WPF is erg efficient met het geheugengebruik en dit zal geen noemenswaardige effecten op je performance hebben.

Het resultaat is een stuk beter:

Dit lijkt tenminste op een kubus!

Maar nu willen we niet 1 kubus hebben, maar een paar honderd. En allemaal op verschillende plekken, en uiteraard van verschillende afmetingen! Dat wordt een hoop rekenwerk ben ik bang. Of toch niet? Kunnen we dit niet op de een of andere manier in code vatten?

Ik zou die vraag niet stellen als het antwoord niet "ja" zou zijn. En dat is precies wat ik in de volgende post ga doen! We maken een C# class die dit voor ons doet zodat we in XAML de volgende code kunnen plakken:

<detrio:Box LeftBottomCorner="0 0 0"
            Width="2.0"
            Height="1.0"
            Depth="1.5"
            >
    <detrio:Box.Material>
        <DiffuseMaterial Brush="Blue"/>
    </detrio:Box.Material>
</detrio:Box>

En dat is een stuk beter leesbaar dan dat gedoe met die Positions toch?

PS We hadden het probleem ook anders op kunnen lossen: we hadden zelf de normals kunnen berekenen en dan toch de punten kunnen hergebruiken. Ik wilde je echter laten zien hoe hergebruik van punten rare effecten op kan leveren. Daarnaast is het berekenen van Normals vrij ingewikkeld als je verder gaat dan een simpel kubusje, waardoor het veel eenvoudiger is om de punten te herdefinieren. Het zelf berekenen van normals kan wel een performance winst opleveren...

3D Graphics in WPF, deel 5 (GeometryModel3D)

dvroegop — Wed, 27 Aug 2008 14:49:42 GMT

Eindelijk: we gaan dingen tekenen! Na alle noodzakelijk gepraat over camera's, lampen, punten en vectoren gaan we eindelijk aan de slag met iets dat zichtbaar op het scherm komt!

In het eerste voorbeeld gaf ik al een vierkantje weer, zodat we in ieder geval iets op het scherm zagen. Ik geef toe: echt indrukwekkend is het niet maar het was een begin!

Als je denkt: waarom liet hij de code voor een vierkantje zien en in de screenshots liet hij kubusjes zien, dan is het antwoord: omdat dat eenvoudiger was.

In WPF is er helaas geen enkele class met de naam Cube. Of Cylinder. Of Sphere, Torus, Teapot of wat voor fraais dan ook. WPF kent alleen maar verzamelingen van punten. Een vierkant is voor WPF niets anders dan een set met 4 punten die op een bepaalde plek in de 3D scene staan en de volgorde waarin die punten getekend moeten worden. Nu is een vierkant niet zo ingewikkeld: het zijn maar 4 punten verbonden door 4 lijnen. Een kubus is al ingewikkelder, die bestaat immers uit 8 punten verbonden door 12 lijnen.

Het wordt nog ingewikkelder als je je realiseert dat WPF eigenlijk alleen maar driehoeken kan tekenen.... Een vierkant bestaat uit 2 driehoeken, een kubus uit 12 driehoeken. Uit hoeveel driehoeken een bol bestaat ligt er maar net aan hoe je hem definieert, maar het aantal driehoeken loopt al gauw in de honderden of zelfs duizenden.

Nu is dat niets om je zorgen over te maken: grafische kaarten tegenwoordig zijn helemaal geoptimaliseerd in het tekenen van heel, heel erg veel driehoeken. Iets anders kennen ze niet maar driehoeken: daar zijn ze dol op!

Laten we even kijken naar ons vierkantje. Deze bestaat uit 4 punten (A, B, C, en D) en 2 driehoeken ( (A,B,C) en (A,C,D)). We vertellen WPF dus dat we een driehoek willen tekenen. We geven eerst de punten mee (de volgorde maakt eigenlijk niet uit). In ons geval dus de punten A, B en C. Dan vertellen we WPF dat hij de punten in een bepaalde volgorde moet verbinden. Vanuit punt A naar punt B, vanuit B naar punt C. Aangezien we met driehoeken werken en een driehoek altijd 3 zijdes heeft, 'weet' WPF dat het laaste punt dus vanuit C naar A gaat: hij sluit hem zelf wel af.

De volgorde van de lijnen is wel belangrijk: dit moet altijd tegen de klok in! Waarom is dat nou weer? Een vlak (zoals onze driehoek) heeft twee kanten: een voorkant en een achterkant. Wat precies de voorkant is en wat de achterkant, weet WPF niet: dat hangt af van de plaats, de rotatie en van de plek van de camera. Om te bepalen wat nou de voorkant is berekent WPF de normaal vector uit. De drie opgeven punten A, B en C liggen in 1 vlak (in ons geval liggen ze allemaal op het vlak dat recht voor ons is: langs de Y as recht omhoog of omlaag). De normaal vector is een vector die daar haaks op staat. Als we ons vlak zouden neerleggen zie je dat de normaalvector haaks op onze driehoek staat en uit het scherm wijst: De voorkant van ons driehoekje is het punt vanuit waar de normaal vector wijst. WPF berekent dat door de 3 punten te nemen en daar een vector haaks op te zetten. Nu is de volgorde van belang. Omdat we aangegeven hebben dat we vanuit A naar B, vanuit B naar C (en automatisch vanuit C naar A) gaan, is de normaal vector een Vector3D (0,0,1). Als we nu de punten aangegeven hadden als vanuit A naar C, vanuit C naar B en vanuit B naar A (dus met de klok mee) dan had de normaal vector precies de andere kant opgegaan (0,0,-1). Dat betekent dus dat de achterkant van het driehoekje naar de kijker toe had gestaan!

Geloof me: deze fout ga je nog regelmatig maken.... Gelukkig is er een hulpmiddel die je hier bij helpt, daar kom ik later nog op.

Ok. We hebben dus drie punten gegeven en verteld in welke volgorde die aan elkaar geknoopt moeten worden. Maar nu zijn we er nog niet: dit is pas de helft van ons vierkantje! We hebben nog een driehoek te tekenen. Nu kunnen we aan WPF de punten A, C en D geven en vertellen dat ze in die volgorde aan elkaar moeten worden geknoopt. Als we dat gedaan hebben zijn we in principe klaar!

Laten we eens wat code bekijken. Onze vierkantje staat, zoals alles in 3D WPF, in een ModelVisual3D (of liever: in de Content van een ModelVisual3D). We voegen dus deze code toe aan onze WPF applicatie. Het resultaat (inclusief lampen en camera) is dan:

<Window x:Class="WpfApplication11.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300">
    <Viewport3D>
        <ModelVisual3D>
            <ModelVisual3D.Content>
                <!-- Hier komt ons vierkantje en later onze kubus -->
            </ModelVisual3D.Content>
        </ModelVisual3D>

        <!-- Lampjes! -->
        <ModelVisual3D>
            <ModelVisual3D.Content>
                <Model3DGroup>
                    <AmbientLight Color="#404040"/>
                    <DirectionalLight Color="#BFBFBF" Direction="1 -1 -1"/>
                </Model3DGroup>
            </ModelVisual3D.Content>
        </ModelVisual3D>

        <!-- Camera -->
        <Viewport3D.Camera>
            <PerspectiveCamera Position="0 0 5" 
                           LookDirection="0 0 -1" 
                           UpDirection="0 1 0" 
                           FieldOfView="60.0" 
                           />
        </Viewport3D.Camera>
    </Viewport3D>
</Window>

Deze code compileert niet: de content mag niet leeg zijn. Dit gaan we zo oplossen.

Ik ga vanaf nu niet meer de hele code plakken (ik word niet per blogregel betaald :-) ) maar ik hou me alleen bezig met het stuk dat in de plaats van de commentaar regel  komt. Dat houdt het allemaal wat leesbaarder.

We kunnen behalve lampjes maar 1 ding toevoegen op deze plaats: een GeometryModel3D. Deze class bevat alles wat WPF nodig heeft om te tekenen (in een volgende versie van WPF hoop ik dat er naast de GeometryModel3D ook een Cube3D, Cylinder3D enzovoorts komen...) Deze GeometryModel3D heeft 4 belangrijke dependency properties: Geometry, Material, BackMaterial en Transform.

In Geometry plaatsen we de punten en de verbindingen tussen de punten. In Material en BackMaterial geven we aan hoe de driehoeken er uit moeten gaan zien en in Transform kunnen we de boel draaien, vergroten, verkleinen en/of verplaatsen.

In Geometry kan maar 1 class geplaatst worden: de MeshGeometry3D. Een MeshGeometry3D is een verzameling van driehoeken.... Deze heeft (onder andere) de volgende properties: Positions en TriangleIndices. De Positions is een collection van Point3D structs, dus alle punten van onze driehoek, terwijl de TriangleIndices een collection van Int32 waardes zijn die aangeven in welke volgorde de punten verbonden moeten worden. Meer hebben we niet nodig!

De code ziet er als volgt uit:

<GeometryModel3D>
    <GeometryModel3D.Geometry>
        <MeshGeometry3D Positions="0 0 0, 1 0 0, 1 1 0"
                        TriangleIndices="0 1 2"
            />
    </GeometryModel3D.Geometry>
</GeometryModel3D>

Dit is de definitie van onze eerste driehoek. We geven de positions op in 3 Point3D structs, te weten (0 0 0), (1 0 0) en (1 1 0) oftewel punt A, B en C in mijn eerste tekening. Daarna geven we in TriangleIndices aan in welke volgorde ze moeten worden verbonden: begin bij punt 0 (0 0 0), dan naar punt 1 (1 0 0) en als laatste naar punt 2 (1 1 0) in het lijst met positions. Van punt 2 naar punt 0 hoeven we niet aan te geven, zoals ik al eerder zei doet WPF dat zelf wel.

En de andere driehoek? Die kunnen we als volgt doen:

<GeometryModel3D.Geometry>
    <MeshGeometry3D Positions="0 0 0, 1 0 0, 1 1 0, 0 0 0, 1 1 0, 0 1 0"
    TriangleIndices="0 1 2 3 4 5"
                    />
</GeometryModel3D.Geometry>

We definieren nu de punten A (0 0 0), C (1 1 0) en D (0 1 0) en de lijnen vanuit het 3e punt (dus de tweede keer dat we punt A definieren) naar het 4e punt (dus de tweede keer dat we punt C definieren) naar het 5e punt (dat is punt D). Mmmm.. dubbel definieren van punten? Niet handig! Dat vinden ze bij het WPF team ook, dus we hoeven de punten maar een keer te definieren en dan de TriangleIndices aan te passen:

<GeometryModel3D.Geometry>
    <MeshGeometry3D Positions="0 0 0, 1 0 0, 1 1 0, 0 1 0"
    TriangleIndices="0 1 2 0 2 3"
                    />
</GeometryModel3D.Geometry>

Dat ziet er al veel beter uit. We definieren in Positions de punten A, B, C en D en vervolgens geven we in de TriangleIndices aan dat we vanuit 0 naar 1, vanuit 1 naar 2 (en dan automatisch vanuit 2 naar 0 gaan!). Dan zeggen we vanuit 0 naar 2 en vanuit 2 naar 3 (en automatisch vanuit 3 naar 0) en daarmee is ons vierkant genoeg gedefinieerd!

Overigens is WPF heel erg makkelijk als het gaat om het formatten van dit soort constructies. De volgende code is ook goed en een stuk leesbaarder:

<GeometryModel3D.Geometry>
    <MeshGeometry3D 
        Positions= "0 0 0, 
                    1 0 0, 
                    1 1 0, 
                    0 1 0"
        TriangleIndices="0 1 2 
                         0 2 3"
    />

Het is een kwestie van smaak maar ik denk dat deze versie beter is: je ziet beter waar de definitie van 1 punt ophoudt en de volgende begint (namelijk op de volgende regel), ook de driehoeken zijn duidelijker :van 0 naar 1 naar 2, vervolgens een nieuwe driehoek van 0 naar 2 naar 3. Ook het plaatsen van de komma's om de elementen te scheiden kan heel anders, maar ik vind dit een mooie layout.

Als je je code nu gaat draaien, zie je.... niets. Waarom niet? Omdat we geen Material hebt gedefinieerd. Over Materials wil ik het later uitgebreid hebben, maar om je toch iets te geven om mee te spelen even kort dit:

Een material kun je zien als het behangtje dat je op je objecten plak om ze zichtbaar te maken. GeometryModel3D heeft, zoals je al zag, een Material en een BackMaterial property. Deze gaan we nu zetten:

                <GeometryModel3D>
                    <GeometryModel3D.Geometry>
                        <MeshGeometry3D 
                            Positions= "0 0 0, 
                                        1 0 0, 
                                        1 1 0, 
                                        0 1 0"
                            TriangleIndices="0 1 2 
                                             0 2 3"
                        />
                    </GeometryModel3D.Geometry>
                    <GeometryModel3D.Material>
                        <DiffuseMaterial Brush="Blue"/>
                    </GeometryModel3D.Material>
                </GeometryModel3D>

We hebben een blauw materiaal gemaakt zodat er in ieder geval iets zichtbaar is.

Oh ja; ik had het over het hulpmiddel om je te helpen voorkomen dat je de TriangleIndices in de verkeerde volgorde zet (zodat je tegen de achterkant aankijkt): ik definieer als ik in XAML objecten maak altijd de BackMaterial. Dit is het material dat aan de achterkant van onze object komt. Ik geef deze altijd een mooi opvallend kleurtje die ik niet gauw zou gebruiken in mijn applicatie. Op die manier valt een fout direct op. In de volgende code heb ik bewust de tweede driehoek verkeerd getekend maar aangezien ik ook een BackMaterial heb ingesteld is het meteen zichtbaar:

<GeometryModel3D>
    <GeometryModel3D.Geometry>
        <MeshGeometry3D 
            Positions= "0 0 0, 
                        1 0 0, 
                        1 1 0, 
                        0 1 0"
            TriangleIndices="0 3 2 
                             0 2 1" 
        />
    </GeometryModel3D.Geometry>
    <GeometryModel3D.Material>
        <DiffuseMaterial Brush="Blue"/>
    </GeometryModel3D.Material>
    <GeometryModel3D.BackMaterial>
        <DiffuseMaterial Brush="HotPink"/> 
    </GeometryModel3D.BackMaterial>
</GeometryModel3D>

Dat levert dit mooie plaatje op:

Ik heb dus TriangleIndices hier even met de klok meegeven om het effect weer te geven. Zet ze weer terug in de juiste plek om een mooi blauw vierkantje weer te geven.

Goed. De kubus.

Tja, die is niet echt ingewikkeld: een kubus bestaat uit 8 Point3D structures, 12 driehoeken en dus 12 TriangleIndices entries. Het is alleen een hoop werk om in te typen: ik laat het graag aan je zelf over om dat te doen :-)

Overigens: mocht je die kubus gaan maken: let er dan op dat je in ons voorbeeld recht van voren naar de kubus kijkt en dus de zijkanten en onder- en bovenkant niet ziet. Je zult met de camera positie en LookDirection moeten spelen om hem helemaal zichtbaar te maken!

3D Graphics in WPF, deel 4 (intermezzo 2 over vectors, punten en andere wiskunde)

dvroegop — Wed, 27 Aug 2008 13:26:04 GMT

Laat de titel je niet afschrikken: we gaan niet samen je hele middelbare school wiskunde herhalen. Toch zal je, als je serieus met WPF 3D bezig wilt zijn, iets van vector berekeningen moeten weten. In deze post geen mooie plaatjes van vierkantjes en kubussen, maar we gaan rekenen! Geloof me: je zult het nodig hebben.

Als eerste: wat is een punt? Deze is eenvoudig te beantwoorden. In computer graphics worden punten op het scherm weergegeven als pixels (samenvoeging van picture element). Deze hebben een X en een Y waarde waarbij X=0 en Y=0 het punt links boven het scherm is. Als je de X waarde positief laat oplopen ga je meer naar rechts, terwijl je als je Y waarde positief laat oplopen je naar beneden op het scherm gaat. Een punt op je scherm kun je dus weergeven door het getallen paar X en Y. Op mijn scherm hier is het punt (X=0, Y=0) links boven, (X=1440, Y=0) rechtsboven, (X=0, Y=900) links onder en (X=1440, Y=900) rechts onder. Meestal laten we de X en Y weg in getallenparen en geven we deze vier punten weer als (0,0), (1440,0), (0,900) en (1440, 900).

Als we het over pixels hebben zijn de getallen meestal integers: je kunt immers niet een halve pixel tekenen.

In 3D WPF is dat iets anders. Zoals ik al eerder opmerkte kunnen we niet over pixels praten omdat we niet weten hoe groot een object gerenderd wordt: dit hangt af van de positie van het object, de positie van de camera, het type camera en de instellingen van de camera. In plaats daarvan praten we over logische eenheden. Of 1 unit nu 1 milimeter, 1 kilometer, 1 lichtjaar of 1 micrometer voorstelt hangt af van wat JIJ vindt dat het voorstelt: voor WPF maakt het niets uit. Deze werkt gewoon met eenheden. Deze eenheden zijn altijd doubles: we werken dus met waardes achter de komma.

Uiteraard hebben we niet genoeg aan een X en Y waarde om iets in een 3D ruimte aan te duiden. We hebben ook de Z waarde nodig. X en Y hebben dezelfde betekenis als in de 2D wereld (behalve dat Y oplopend naar boven gaat in plaats van naar beneden, iets waar we later nog last mee gaan krijgen!) maar we hebben ook een Z waarde. Deze Z-waarde geeft aan of iets meer in de diepte ligt of juist meer naar de voorgrond. Met de Z-waarde gaan we dus het scherm in, of juist er uit!

Als we nu even voorstellen dat ons 3D wereldje een grootte heeft van 1 eenheid bij 1 eenheid bij 1 eenheid (nogmaals: we weten niet hoe groot dat is op het scherm) dan is de hoek linksboven vooraan (X=0, Y=1, Z=0), rechtsboven vooraan (X=1, Y=1, Z=0), links onder vooraan (X=0, Y=0, Z=0), rechts onder vooraan (X=1, Y=0, Z=0). Uiteraard laten we hier ook de X,Y en Z weg, dus dat wordt (0,1,0), (1,1,0), (0,0,0) en (1,0,0).

Dit zijn alle punten die voor aan in onze wereld liggen. De punten aan de achterkant hebben als coordinaten, linksboven achter (0, 1, -1), rechtsboven achter (1, 1, -1), linksonder achter (0, 0, -1) en rechtsonder achter (1, 0, -1). Je ziet dat de Z waarde negatief wordt als we naar achter gaan. Je kunt besluiten om dat niet te doen, maar ik garandeer je dat je dan later enorm in de moelijkheden komt. Hou deze conventie maar vast: naar achter in het scherm is negatief voor Z. En nogmaals: Y naar beneden is richting 0, precies omgekeerd ten opzichte van standaard 2D grafieken).

We kunnen in WPF coordinaten vast leggen met de structure Point3D. Deze heeft als properties X, Y en Z: allen zijn double.

Als tweede: wat is een vector?

Een vector is een eenheid die grootte en richting heeft. In de natuurkunde gebruiken we vectoren om bijvoorbeeld krachten weer te geven. Er zijn enorm veel wiskundige boeken verschenen over het onderwerp vectoren, met name hoe je berekeningen met ze uitvoert. Je kunt vectoren bij elkaar optellen, vermenigvuldigen (met elkaar en met normale waardes) enzovoorts. Het slechte nieuws is dat we dat ook moeten gaan doen in WPF. Het goede nieuws is dat we heel veel details kunnen overlaten aan WPF.

Stel je voor dat je in de kubus die je hier ziet staan met je 3D mousepointer (als die zou bestaan) op de linkeronderhoek vooraan zou staan, oftewel op punt (0,0,0). Als we de mousepointer zouden willen vertellen dat die naar de linker beneden hoek achter (0,0,-1) moet gaan, dan zouden we hem moeten vertellen dat hij zijn X waarde niet moet wijzigen, ook zijn Y waarde blijft gelijk maar de Z waarde moet met 1 verminderd worden. Dat geven we aan met een vector, om precies te zijn de Vector (0,0,-1). Dit zegt dus: ga 0 stappen naar rechts, 0 stappen naar boven en -1 stappen naar de voorkant van het scherm (oftewel 1 stap naar achteren...).

Als we vanuit dat punt naar rechtsboven vooraan willen gaan, dus vanuit (0,0,-1) naar (1,1,0) dan moet hij de vector (1,1,1) mee krijgen: ga 1 stap naar rechts, 1 stap omhoog en 1 stap naar voren.

Je ziet dat de wiskunde van het optellen van vectors bij punten niet zo moelijk is: Point3d(0,0,-1) + Vector3D (1,1,1) levert Point3D (1,1,0) op: we tellen bij de X waarde van de punt de X waarde van de vector op, bij de Y waarde van de punt de Y waarde van de vector en bij de Z waarde van de punt de Z waarde van de vector. Het resultaat is dus (0 + 1, 0 + 1, -1 + 1) = (1, 1, 0).

Zoals je al zag is in WPF een vector weergegeven met de struct Vector3D. Deze heeft dezelfde X, Y en Z properties als de Point3D. Maar vergeet niet dat een vector een richting en grootte aangeeft en niet een punt!

Kijk nog eens naar de code voor onze PerspectiveCamera. Deze had als positie (0,0,5) en een LookDirection van (0,0,-1). De position is een Point3D (de camera 'staat' immers op een punt in onze scene) maar de LookDirection is een Vector3D: deze wijst in de richting waarnaar de camera kijkt: 0,0,-1 oftewel recht het scherm in (en niet naar links, rechts, beneden of boven). Wat had er nu gebeurdt als we als LookDirection (0,0,-5) hadden opgegeven? Het antwoord is: niets. De vector hier is een richting. Als je een pijl tekent om iemand te laten zien waar hij heen moet rijden, is het niet van belang hoe lang die pijl is: of deze nu 1 cm of 1 meter lang is: de richting is hier waar het om gaat.

Maar wat als we nu als LookDirection (0.5, 0, -1) hadden gezet? Dan had de camera het scherm en en schuin naar rechts gekeken. Ook dit kunnen we veranderen in (1,0, -2), dat maakt niets uit: het gaat niet om de lengte van de pijl (de tweede is twee keer zo lang als de eerste) maar om de richting.

Als we nog eens nadenken over ons voorbeeld van de mousepointer die we willen verplaatsen: daar is het wel van belang hoe lang de pijl is! Als we die waardes niet goed maken komt de muis op de verkeerde plek uit.

Onthoudt dus: soms is de richting van de Vector van belang, soms de grootte, soms allebei....

De reden dat we als lookdirection (0,0,-1) opgeven en niet (0,0,-5242) is dat de eerste een zogenaamde genormaliseerde vector is: dit is een vector met waardes als fracties van 1. WPF probeert dit soort vectoren zoveel mogelijk te gebruiken waar het kan (dus wanneer alleen de richting van belang is) en zal altijd dit soort vectoren omrekenen. Dit kost rekentijd, wat we in dit geval makkelijk zelf hadden kunnen doen door (0,0,-1) te gebruiken.

Hetzelfde geldt voor de UpDirection van onze camera: die is (0,1,0) oftewel recht naar boven.

Mocht je nu een vector willen normalizeren, dan is dat niet zo moeilijk: de struct heeft als method Normalize. Kijk eens naar de volgende code:

Vector3D myVector = new Vector3D(0.0, 0.0, -515423.243);

myVector.Normalize( );

MessageBox.Show(myVector.Z.ToString( )) ;

Als resultaat krijg je een messagebox met de waarde -1.

De struct Vector3D heeft nog meer handigheidjes in zich, bekijk de help eens.

Naast punten en vectoren zijn ook matrixen erg belangrijk in WPF 3D. Dit is echter iets wat vele malen ingewikkelder is dan dit stukje dus dat zal ik je nu besparen. We zien die wel verschijnen als het over transformaties (roteren, schalen en verplaatsten!) gaan hebben.

Goed. We weten nu wat punten en wat vectoren zijn. Dank je dat je je door dit toch wat saaie stuk heen gelezen hebt. Ik zal het de volgende keer goed maken: we gaan ons vierkantje vervangen door een kubus! En uiteraard komen we daar heel veel Point3D en Vector3D tegen zodat je dit niet voor niets gelezen hebt!

3D Graphics in WPF, deel 3 (intermezzo 1 over lampjes)

dvroegop — Wed, 27 Aug 2008 12:34:41 GMT

Ik moet iets bekenen: ik heb valsgespeeld in mijn vorige post. Ik heb als laatste een vierkant getekend en die de kleur zwart gegeven. De waarheid is dat het niet uitmaakt welke kleur ik hem had gegeven, hij zou altijd zwart worden weergegeven. Probeer maar eens om de de kleur Brush="Black" bij de DiffuseMaterial te vervangen door Brush="White". Je krijgt nog steeds een saai zwart vierkantje.

De reden daarvoor is simpel. Denk maar eens na: wat gebeurdt er als je een foto neemt in een ruimte zonder licht? Het antwoord: alles wordt zwart. De reden dat bij ons alleen het vierkant zwart is en niet het hele scherm is dat de default achtergrond kleur (die niet door de camera gerenderd wordt!) wit is. Dus we krijgen een zwart vierkant op een witte achtergrond.

Hoe los je dat op? Wel, net als in het echte leven: als je in een ruimte niets kunt zien doe je het licht aan. In WPF is dat niet anders. In tegenstelling tot de 2D graphics in WPF (of welk ander framework dan ook) zul je moeten aangeven wat voor licht er is.

En nu wordt het ingewikkeld. Licht is een enorm complex iets, zowel in het echte leven als in onze gesimuleerde computer omgeving. Er zijn heel veel verschillende soorten licht, ieder met een eigen gedrag. Zo moet je aangeven wat voor kleur licht je hebt (met een rode lamp op een wit oppervlak schijnen levert een rood vlak op) maar ook wat voor soort lampen je hebt.

WPF heeft 4 soorten licht. Je kunt deze classes zien als lampen (waarbij er een is, AmbientLight die geen echte lamp voorstelt). Deze zijn: AmbientLight, DirectionalLight, PointLight en SpotLight. De eerste twee zul je het meeste gebruiken.

Alle light objecten bij elkaar leveren licht op. Je moet er op letten dat je niet teveel lampen in je scene zet: je loopt anders het risico dat je scene overbelicht raakt en je geen details meer kunt zien.

Bij het renderen berekent WPF hoeveel licht er op een object valt en wat voor kleur er dan zichtbaar is. Een object kan niet helderder zijn dan puur wit (RGB waarde 255, 255, 255). Meer licht erop levert niet witter wit op: het blijft RGB(255,255,255).

Als eerste kijken we even naar AmbientLight. AmbientLight is het licht dat er altijd is. Dit is vergelijkbaar met wat je ziet op een grijze, bewolkte dag: alles is zichtbaar maar mist diepte. Schaduwen zie je eigenlijk niet, alles wordt vanuit alle kanten gelijkmatig verlicht. Door AmbientLight te gebruiken geef je een basis belichting op.

DirectionalLight is hetzelfde als AmbientLight behalve dat het een richting heeft. Een DirectionalLight heeft geen duidelijke oorsprong, maar het licht gaat wel duidelijk een kant op. Objecten die geraakt worden door de DirectionalLight zijn zichtbaar, objecten die in de "schaduw" liggen zijn zwart (WPF heeft geen schaduw berekening, maar het heeft wel ongeveer hetzelfde effect). Een screenshot maakt dit duidelijker.

In het eerste plaatje zie je een box die 45 graden gedraaid is over de X,Y en Z as. Ik heb er alleen een puur witte AmbientLight bijgezet. Je ziet dat alle vlakken dezelfde hoeveelheid licht ontvangen en dat er dus geen enkel verschil zichtbaar is in de kanten.

Niet echt realistisch lijkt mij.

Als we de AmbientLight nu vervangen door een DirectionalLight die vanaf links boven achter naar rechts beneden voor schijnt, krijgen we een ander effect.

Hier zie je dat het bovenste vlak goed uitgelicht wordt: deze staat volop in het zonnetje. Het vlak aan de linkerkant is een stuk donkerder: het licht komt immers van schuin boven dus dit is minder zichtbaar. Het vlak aan de voorkant is zwart: hier valt geen licht op.

In het echte leven zien we dit niet: er is immers vrijwel altijd wel wat omgevingslicht (= ambientlight) beschikbaar dus we kunnen altijd wel details zien.

Als we nu een klein beetje AmbientLight nemen (RGB kleur 64, 64, 64 dus donker grijs) en een lichte DirectionalLight (RGB 191, 191, 191 dus licht grijs) dan krijgen we het volgende effect:

Het verschil is subtiel, maar de kleuren komen nu wel beter uit: je kunt zien dat het voorvlak inderdaad blauw is (en het linkervlak is nu ook beter zichtbaar). Overigens: de totale lichtwaarde (RGB (64,64,64) + RGB(191, 191, 191)) is puur wit: we komen niet boven RGB (255,255,255) uit.

Het is in de praktijk erg lastig om je belichting goed te krijgen. Je moet er op letten dat je niet boven de totale waarde van wit uitkomt (meer heeft geen zin, dat doet niets) en je moet er goed opletten dat alle kanten van de objecten genoeg licht krijgen om zichtbaar te zien, zonder het 3D effect te niet te doen zoals in het eerste plaatje met alleen AmbientLight.

Naast de AmbientLight en DirectionalLight hebben we ook nog de PointLight en SpotLight. Deze kun je gebruiken om nog realistischer effecten te krijgen. Let echter op: dit soort geavanceerde technieken zorgen ervoor dat WPF veel meer tijd nodig heeft om je scene te berekenen. Als je met animaties gaat werken merk je dat door het gebruik van SpotLight en PointLight het aantal frames per seconde die je kunt halen erg naar beneden gaat (wij gebruiken ze dan ook niet in onze Business Visualization oplossingen).

Een PointLight begint al op een echt lampje te lijken. Je geeft hem een plaats in je 3D wereld, en de hoeveelheid licht die het verspreid neemt af naarmate de objecten verder weg liggen van de lamp (dit is allemaal instelbaar). Een SpotLight is een gespecialiseerde vorm van de PointLight (die in alle richtingen schijnt): deze schijnt in een bepaalde richting en heeft een duidelijke 'cone', dwz een gebied waar het licht duidelijk zichtbaar is en een gebied waar het licht minder zichtbaar is en dus in sterkte afneemt.

Een spotlight heeft een innercone, waar het licht 100% is, en een outercone, waarin de lichtsterkte afneemt naarmate je meer naar de buitenkant gaat. De cones worden ingesteld door de hoeken op te geven. Zo kun je dus een dunne, felle bundel licht maken of een brede waaier van licht.

Tot zover de theorie: laten we de lampjes eens in onze scene plaatsen.

Nog een keer de code van vorige keer (maar dan met een vierkant die blauw moet worden):

<Window x:Class="WpfApplication11.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300">
    <Viewport3D>
        <ModelVisual3D>
            <ModelVisual3D.Content>
                <GeometryModel3D>
                    <GeometryModel3D.Geometry>
                        <MeshGeometry3D Positions="0 0 0 1 0 0 1 1 0 0 1 0"
                                        TriangleIndices="0 1 2 0 2 3"/>
                    </GeometryModel3D.Geometry>
                    <GeometryModel3D.Material>
                        <DiffuseMaterial Brush="Blue"/>
                    </GeometryModel3D.Material>
                </GeometryModel3D>                
            </ModelVisual3D.Content>                       
        </ModelVisual3D>
        
        <Viewport3D.Camera>
            <PerspectiveCamera Position="0 0 5" 
                           LookDirection="0 0 -1" 
                           UpDirection="0 1 0" 
                           FieldOfView="60.0" 
                           />
        </Viewport3D.Camera>
    </Viewport3D>
</Window>

Dit levert dus een zwart vierkantje op...

Tussen de </ModelVisual3D> en de <Viewport3D.Camera> plaatsen we nu de volgende code:

        <!-- Lampjes! -->
        <ModelVisual3D>
            <ModelVisual3D.Content>
                <AmbientLight Color="White"/> 
            </ModelVisual3D.Content>
        </ModelVisual3D>

We maken een ModelVisual3D aan (die bevat alles wat getekend moet worden, wat ook voor lampen geldt), in de content daarvan plaatsen we een AmbientLight. Deze geeft wit licht. Run je applicatie en voila: een blauw vierkantje!

Mocht je nu een DirectionalLight willen plaatsen dan vervang je de AmbientLight regel door

<DirectionalLight Color="White" Direction="1 -1 -1"/>

... en je hebt een DirectionalLight. Het vierkantje wordt nu een stuk donkerder: ons lampje schijnt van linksboven voor naar rechtsonder beneden (Vector: 1, -1, -1)) en dus 'strijkt' het licht langs ons vierkantje.

Wat als je nu zowel een Ambient als een DirectionalLight wil hebben? Dan moet je even een trucje uithalen: De ModelVisual3D.Content kan maar 1 item bevatten... Dat is niet zo moelijk op te lossen. We voegen als Content een Model3DGroup toe (dat is precies 1 item) en die Model3DGroup bevat op zijn (haar?) beurt weer andere items:

<!-- Lampjes! -->
<ModelVisual3D>
    <ModelVisual3D.Content>
        <Model3DGroup>
            <AmbientLight Color="#404040"/>
            <DirectionalLight Color="#BFBFBF" Direction="1 -1 -1"/>
        </Model3DGroup>
    </ModelVisual3D.Content>
</ModelVisual3D>

Probleem opgelost! Je ziet dat ik hier met RGB waardes werk (in hexadecimale waardes) in plaats van de named colors: op deze manier heb ik precieze controle over de totale hoeveelheid licht in mijn scene.

Speel eens met deze code, verander het licht (de kleuren bijvoorbeeld) en voeg een spotlight toe. Kijk eens wat er gebeurd als je je vierkant wit maakt en je met andere kleuren licht werk!

Volgende post wordt weer een intermezzo waar ik dieper in ga op de Vector3D en Point3D: we hebben ze al voorbij zien komen maar we hebben het er eigenlijk niet over gehad. Daarna gaan we dan echt kijken naar andere figuurtjes behalve dit nuttige maar toch wel saaie vierkantje!

3D Graphics in WPF, deel 2

dvroegop — Wed, 27 Aug 2008 11:27:34 GMT

In mijn vorige post liet ik zien hoe we bij Detrio Excel grafieken vervangen door 3D interactieve grafieken. Het wordt tijd om te kijken hoe we dit soort applicaties nu maken. Hoe kun je nu 3D plaatjes maken in WPF?

WPF heeft een enorm rijke ondersteuning voor 3D. In de eerste versies van onze 3D toolkit, waar we dit soort systemen mee maken, was helemaal van de grond af aan geschreven in Delphi en C++, waarbij we gebruik maakten van OpenGL om de 3D plaatjes te maken. Veel van het werk dat we gedaan hebben in die library hebben we weggegooid: alle low-level code zit nu standaard in WPF (zodat wij ons kunnen orienteren op de dingen die echt belangrijk zijn).

Maar laten we beginnen bij het begin.

In Visual Studio (Express, Professional of hoger: maakt niet uit welke versie je hebt) maak je een nieuw WPF project aan. Je krijgt een XAML bestand met daarin de volgende code:

<Window x:Class="WpfApplication10.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300">
    <Grid>
    </Grid>
</Window>

Dit is onze basis. We krijgen een Window met daarin een Grid. Die Grid kan weg, die hebben we nu niet nodig.

Om 3D plaatjes te tekenen moeten we als eerste een soort van Canvas hebben. Een canvas is het stuk waarop getekend kan gaan worden. WPF heeft daarvoor de Viewport3D class: dit is ons tekengebied. Onze code ziet er nu als volgt uit:

<Window x:Class="WpfApplication10.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300">
    <!-- De Viewport3D is ons tekengebied -->
    <Viewport3D>
        
    </Viewport3D>
</Window>

Tot zover is het niet echt spannend. Als je dit runt krijg je een leeg, wit scherm. Had je anders verwacht?

Laten we eens iets toevoegen. Er zijn een paar dingen die je altijd moet doen. Alles wat je in 3D WPF tekent wordt geplaatst in een soort virtuele wereld. Deze wereld bestaat alleen in het geheugen van je computer: dit wordt niet weergegeven op je scherm. Om te laten zien wat je getekend hebt zul je een camera moeten toevoegen: deze camera zorgt ervoor dat alles wat in het bereik van deze camera is ook daadwerkelijk op het scherm geplaatst wordt. Je kunt dus meerdere camera's maken en in je applicatie tussen camera's switchen!

WPF heeft twee soorten camera's: de OrthographicCamera en de PerspectiveCamera. De eerste is een camera waarbij geen rekening gehouden wordt met perspectief, de tweede doet dat wel. In de praktijk komt het neer op het volgende: als je twee blokken van dezelfde grootte hebt, waar er een dicht bij de camera staat en de tweede staat ver weg, dan zal bij de OrthographicCamera het tweede blok net zo groot getekend worden als de eerste. Bij de PerspectiveCamera zal de tweede kleiner worden getekend dan de eerste (wat meer overeenkomt hoe wij mensen de wereld zien).

De OrthographicCamera wordt voornamelijk gebruikt voor architectuur toepassingen: daar is het belangrijk dat alle objecten weergegeven worden op het formaat dat ze ook echt zijn. Natuurlijk zien wij het anders: wij zien twee blokken waarbij er een groter lijkt dan de ander. Kijk eens naar het volgende voorbeeld. Als eerste zie je een scene met twee blokken en een PerspectiveCamera. Daarnaast zie je dezelfde scene maar met de OrthographicCamera.

Ik heb hier alleen de camera verandert: je ziet dat het hele perspectief vertekend wordt (en het 'bovenste' blok lijkt groter!).

Voor realistische weergave is het beter om een PerspectiveCamera te gebruiken: OrthographicCamera wordt niet al te vaak toegepast.

We voegen deze camera toe aan onze ViewPort3D:

<Window x:Class="WpfApplication10.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300">
    <Viewport3D>
        <Viewport3D.Camera>
            <PerspectiveCamera Position="0 0 5" 
                           LookDirection="0 0 -1" 
                           UpDirection="0 1 0" 
                           FieldOfView="60.0" 
                           />
        </Viewport3D.Camera>
    </Viewport3D>
</Window>

De camera heeft een aantal properties die je moet zetten. Als eerste de position. Zoals ik al zei worden alle object in het geheugen van je computer geplaatst, dit geldt ook voor de camera. Je moet wel leren om in 3 dimensies te denken: er is een z-positie bijgekomen. Als je gewend bent aan het tekenen in een 2D omgeving is er nog iets wat je moet weten: de coordinaten zijn anders dan je gewend bent. Ten eerste is bij een 2D applicatie het punt (0,0) linksboven in je tekening, bij 3D is (0,0,0) linksonder. Daarnaast is er dus de 3e dimensie bijgekomen, dit is de z-as. Hoe je die definieert is eigenlijk iets wat je zelf kunt bepalen, maar meestal zie je dat de z-as naar je toe een positieve waarde geeft en van je af (dus de diepte in) een negatieve. Dit is even wennen, maar als snel weet je niet beter. Als laatste moet je weten dat bij 2D applicaties je de coordinaten meestal in pixels opgeeft: bij 3D in WPF is dat niet zo. Als we zeggen dat we een box hebben met een breedte van 1, dan zegt dat eigenlijk niets over de grootte op het scherm. Hoeveel pixels hij op het scherm in gebruik heeft is afhankelijk van de locatie van de box in de 3D wereld, van de plaatsing van de camera en van het type camera. Alle locaties en punten in WPF 3D zijn dan ook doubles. In de tekeningen hierboven zijn de boxen 1 logische unit hoog, breed en diep. Ze staan 4 units van elkaar. Zoals je ziet heeft dat niets met pixels te maken!

Goed. Onze camera staat dus op locatie 0, 0, 5, oftewel op de X en Y as, maar 5 punten naar ons toe. Als we dat bepaalt hebben moeten we ook opgeven waar de camera naar kijkt. Hier geven we een vector op: we zeggen dat de LookDirection recht langs de z-as naar achteren kijkt (dus vooruit gezien vanuit ons: negatieve z-waardes gaan de diepte in!): LookDirection is 0,0,-1. Als we een andere waarde voor X opgeven dan kijkt de camera meer naar links of rechts, bij andere waardes van Y omhoog of omlaag.

Dan kunnen we ook nog aangeven wat de bovenkant van de camera is: we kunnen de camera immers ook op z'n kop houden! In ons geval is de UpDirection (0,1,0) oftewel rechtomhoog langs de Y-as.

Bij de PerspectiveCamera geven we als laatste ook nog de FieldOfView op: dit geeft aan hoe groot de hoek is waarmee we kijken (60 graden in ons geval). Eigenlijk bepalen we hier of we een groothoek of zoomlens gebruiken. Ook kun je door deze waarde te varieren een zoom-effect bereiken (verkleinen van de FieldOfView haalt objecten dichterbij).

Als we nu onze applicatie runnen zien we.... niets.

Nee, natuurlijk niet: met een virtuele camera een lege ruimte fotograferen levert een foto van een lege ruimte op.

Ik ga in een volgende post in op de objecten die daadwerkelijk zichtbaar zijn, maar om je alvast iets te geven om mee te spelen, moet je even de volgende code toevoegen aan je applicatie:

<Window x:Class="WpfApplication10.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300">
    <Viewport3D>
        <ModelVisual3D>
            <ModelVisual3D.Content>
                <GeometryModel3D>
                    <GeometryModel3D.Geometry>
                        <MeshGeometry3D Positions="0 0 0 1 0 0 1 1 0 0 1 0"
                                        TriangleIndices="0 1 2 0 2 3"/>
                    </GeometryModel3D.Geometry>
                    <GeometryModel3D.Material>
                        <DiffuseMaterial Brush="Black"/>
                    </GeometryModel3D.Material>
                </GeometryModel3D>
            </ModelVisual3D.Content>
        </ModelVisual3D>
        <Viewport3D.Camera>
            <PerspectiveCamera Position="0 0 5" 
                           LookDirection="0 0 -1" 
                           UpDirection="0 1 0" 
                           FieldOfView="60.0" 
                           />
        </Viewport3D.Camera>
    </Viewport3D>
</Window>

We tekenen hier een vierkant, die als het goed is op het scherm verschijnt.

Speel eens met verschillende waardes in de PerspectiveCamera en kijk wat er gebeurt! De volgende post gaat meer in op de Geometry die je hier in de code ziet.

3D Business Visualization in WPF: de intro (deel 1 van de heel veel)

dvroegop — Tue, 26 Aug 2008 17:02:59 GMT

Ik vind dat ik de mooiste baan ter wereld heb: bij Detrio maken we virtual reality achtige systemen voor het bedrijfsleven. We onderschrijven het cliche dat "een plaatje meer zegt dat 1000 woorden" en vinden het dan ook vreemd dat organisaties hier niet meer mee doen: wij hebben daar een hele goede oplossing voor (ondertussen beginnen de bedrijven dit ook in te zien: mensen willen graag gebruik maken van onze oplossingen :-) ) En ik mag dat soort oplossingen bedenken, en implementeren (samen met mijn collega's, en ja: we zoeken nog meer mensen die bij ons in Alkmaar dit willen bouwen ;-))

Wat we doen is het volgende: we nemen de bestaande databases van de klant, kijken welke data zij gebruiken om beslissingen te nemen en bouwen daar een 3D grafiek voor. Nou is de term 3D grafiek een beetje misleidend. Immers: in Excel kun je ook 3D grafieken maken. Kijk eens naar het volgende voorbeeld.

Stel je voor dat je in een organisatie werkzaam bent die spullen verkoopt. Je hebt 4 produktgroepen: Groep A, Groep B, Groep C en hoe kan het ook anders: Groep D.

Deze produkten verkoop je door het hele land (we zijn nog niet internationaal). Om precies te zijn: je verkoopt ze in de regios Noord Holland, Zuid Holland, Limburg, Groningen en Friesland. Mocht jij nu in een provincie wonen die ik hier niet noem: dat is niet persoonlijk, ik wil het voorbeeld simpel houden....

Hieronder zie je de verkoopcijfers over het afgelopen jaar.

Regio	Omzet A	Omzet B	Omzet C	Omzet D
NH	1000	1100	1400	500
ZH	1100	1300	900	300
LI	800	600	900	400
GR	500	450	600	800
FR	650	700	800	900

We hebben studies uit laten voeren waaruit blijkt dat mensen dit soort staatje niet kunnen lezen. Je kunt niet in een oogopslag zien waar je nu veel verkoopt en waar weinig. Het is beter om dit in een grafiek weer te geven. Gelukkig hebben we Excel waar we dat heel eenvoudig kunnen doen:

Tot zover is er niets aan de hand. Maar.... Kunnen we nu goed zien wat produktgroep D doet? Hoeveel er van verkocht is in laten we zeggen Zuid Holland? Nee: de andere produktgroepen verkopen meer dus die staan in de weg....

Daarnaast willen veel managers weten hoe deze cijfers tot stand zijn gekomen. Het zou mooi zijn als ze op 1 van deze kolommen kunnen klikken waarna ze een andere grafiek zien die detail informatie weergeeft. En dat tot uiteindelijk de transactie aan toe.

Bij Detrio maken we dat soort applicaties. Hoewel we bovenstaand plaatje best mooi vinden geeft dit niet de informatie die een manager nodig heeft. Het is een mooi plaatje met relatief weinig toegevoegde waarde (behalve dat het heel mooi staat in een lijvig rapport dat iedere 2 weken geproduceerd wordt). De systemen die wij bouwen hebben interactie: je kunt er op klikken. Ook kun je de grafiek roteren zodat je alles van alle kanten kunt bekijken. Desnoods bekijk je de data terwijl deze op z'n kop staat: als jij daar gelukkig van wordt vinden wij het best! Ook ondersteunen we het doorklikken, wat wij dan drill-down noemen (die term hebben we uit Analysis Services geleend).

Bij ons ziet dat er allemaal heel anders uit.

Nu vertelde ik net dat het bij ons veel mooier is omdat je daar de boel kunt bewegen. Kijk eens op http://www.dotned.nl/flash/firstDemo.htm

Zoals je ziet hoef je niet te lezen om welke regio het gaat: dat zie je direct: de grafiekjes voor Noord Holland staan in Noord Holland, die voor Limburg in Limburg, enzovoorts.

Alles wat je hier ziet is gemaakt in native WPF. Hoe doen we dat? Daar gaan de volgende artikelen over!

4 september 2008: Project Velocity bij Class-A

dvroegop — Mon, 25 Aug 2008 10:15:20 GMT

De vakantie is weer voorbij, we beginnen weer met onze reguliere meetings! We beginnen het nieuwe seizoen met een bijeenkomst bij Class-A. Dennis van der Stelt zal deze avond spreken over Project Velocity.

Project Velocity is een nieuw framework om het gebruik van caching veel eenvoudiger te maken. Zoals Microsoft het zelf stelt: "Velocity is a distributed in-memory application cache platform for developing scalable, available, and high-performance applications."

Tja. High-performance, scalable en available: wie wil dit nou niet?

Dus als je meer wilt weten over Velocity ben je van harte uitgenodigd om je in te schrijven voor deze gratis bijeenkomst en te luisteren wat Dennis vd Stelt over dit onderwerp te vertellen heeft! De avond begint zoals gewoonlijk om 6 uur 's avonds met wat te eten, waarna om 7 uur de sessie zal gaan beginnen.

We zien je graag op de 4e te Woerden!

Passed 70-642

Sander Gerz — Fri, 18 Jul 2008 16:41:00 GMT

Just took exam 70-642 - Windows Server 2008 Network Infrastructure, Configuring. I was a little bit worried about this exam because manually calculating subnets and figuring out routing options was never my strength. That's what we have subnet calculators for, right?

Nonetheless, I passed with a 1000/1000 score. Admittedly, there was some luck involved here, because I had the feeling a lot of questions were about DNS and DHCP, and that was just the topic of the chapter I'm was recently working on for my Windows Server 2008 book.

Next on the todo-list: 70-640 - Windows Server 2008 Active Directory, Configuring.

ASP.NET MVC Preview 4 Release (Part 1)

ScottGu — Mon, 14 Jul 2008 11:18:31 GMT

The ASP.NET MVC team is in the final stages of finishing up a new "Preview 4" release that they hope to ship later this week. The Preview 3 release focused on finishing up a lot of the underlying core APIs and extensibility points in ASP.NET MVC. Starting with Preview 4 this week you'll start to see more and more higher level features begin to appear that build on top of the core foundation and add nice productivity.

There are a bunch of new features and capabilities in this new build - so much in fact that I decided I needed two posts to cover them all. This first post will cover the new Caching, Error Handling and Security features in Preview 4, as well as some testing improvements it brings. My next post will cover the new AJAX features being added with this release as well.

Understanding Filter Interceptors

Action Filter Attributes are a useful extensibility capability in ASP.NET MVC that was first added with the "Preview 2" release. These enable you to inject code interceptors into the request of a MVC controller that can execute before and after a Controller or its Action methods execute. This enables some nice encapsulation scenarios where you can easily package-up and re-use functionality in a clean declarative way.

Below is an example of a super simple "ScottGuLog" filter that I could use to log details about exceptions raised during the execution of a request. Implementing a custom filter class is easy - just subclass the "ActionFilterAttribute" type and override the appropriate methods to run code before or after an Action method on the Controller is invoked, and/or before or after an ActionResult is processed into a response.

Using a filter within a ASP.NET MVC Controller is easy - just declare it as an attribute on an Action method, or alternatively on the Controller class itself (in which case it will apply to all Action methods within the Controller):

Above you can see an example of two filters being applied. I've indicated that I want my "ScottGuLog" to be applied to the "About" action method, and that I want the "HandleError" filter to be applied to all Action methods on the HomeController.

Previous preview releases of ASP.NET MVC enabled this filter extensibility, but didn't ship with pre-built filters. ASP.NET Preview 4 now includes several useful filters for handling output caching, error handling and security scenarios.

OutputCache Filter

The [OutputCache] filter provides an easy way to integrate ASP.NET MVC with the output caching features of ASP.NET (with ASP.NET MVC Preview 3 you had to write code to achieve this).

To try this out, modify the "Message" value set within the "Index" action method of the HomeController (created by the VS ASP.NET MVC project template) to display the current time:

When you run your application you'll see that a timestamp updates each time you refresh the page:

We can enable output caching for this URL by adding the [OutputCache] attribute to the our Action method. We'll configure it to cache the response for a 10 second duration using the declaration below:

Now when you hit refresh on the page you'll see that the timestamp only updates every 10 seconds. This is because the action method is only being called once every 10 seconds - all requests between those time intervals are served out of the ASP.NET output cache (meaning no code needs to run - which makes it super fast).

In addition to supporting time duration, the OutputCache attribute also supports the standard ASP.NET output cache vary options (vary by params, headers, content encoding, and custom logic). For example, the sample below would save different cached versions of the page depending on the value of an optional "PageIndex" QueryString parameter, and automatically render the correct version depending on the incoming URL's querystring value:

You can also integrate with the ASP.NET Database Cache Invalidation feature - which allows you to automatically invalidate the cache when a database the URL depends on is modified (tip: the best way to-do this is to setup a CacheProfile section in your web.config and then point to it in the OutputCache attribute).

HandleError Filter

The [HandleError] filter provides a way to declaratively indicate on a Controller or Action method that a friendly error response should be displayed if an error occurs during the processing of a ASP.NET MVC request.

To try this out, add a new "TestController" to a project and implement an action method that raise an exception like below:

By default when you point your browser at this URL, it will display a default ASP.NET error page to remote users (unless you've gone in and configured a <customErrors> section in your web.config file):

We can change the HTML error displayed to be a more friendly end-user message by adding a [HandleError] attribute to either our Controller or to an Action method on our Controller:

The HandleError filter will catch all exceptions (including errors raised when processing View templates), and display a custom Error view response when they occur. By default it attempts to resolve a View template in your project called "Error" to generate the response. You can place the "Error" view either in the same directory as your other Controller specific views (for example: \Views\Test for the TestController above), or within the \Views\Shared folder (it will look first for a controller specific error view, and then if it doesn't find one it will look in the shared folder - which contains views that are shared across all controllers).

Visual Studio now automatically adds a default "Error" view template for you inside the \Views\Shared folder when you create new ASP.NET MVC Projects starting with Preview 4:

When we add a [HandleError] attribute to our TestController, this will by default show remote users an html error page like below (note that it picks up the master page template from the project so that the error message is integrated into the site). You can obviously go in and customize the Error view template to display whatever HTML and/or friendlier customer error message you want - below is simply what you get out of the box:

To help developers, the default Error view template provided by the new project template in Visual Studio is written to display additional error stack trace information when you are browsing the application locally:

You can turn this off either by deleting the code from the Error view template, or by setting <customErrors> to "off" inside your web.config file.

By default the [HandleError] filter will catch and handle all exceptions that get raised during the request. You can alternatively specify specific exception types you are interested in catching, and specify custom error views for them by specifying the "ExceptionType" and "View" properties on [HandleError] attributes:

In the code above I'm choosing to display custom error views for SqlExceptions and NullReferenceExceptions. All other exceptions will then use the default "Error" view template.

Authorize Filter

The [Authorize] filter provides a way to declaratively control security access on a Controller or Action method. It allows you to indicate that a user must be logged in, and optionally require that they are a specific user or in a specific security role in order to gain access. The filter works with all types of authentication (including Windows as well as Forms based authentication), and provides support for automatically redirecting anonymous users to a login form as needed.

To try this out, add an [Authorize] filter to the "About" action in the HomeController created by default with Visual Studio:

Declaring an [Authorize] attribute like above indicates that a user must be logged into the site in order for them to request the "About" action. When non-logged-in users attempt to hit the /Home/About URL, they will be blocked from gaining access. If the web application is configured to use Windows based authentication, ASP.NET will automatically authenticate the user using their Windows login identity, and if successful allow them to proceed. If the web application is configured to use Forms based authentication, the [Authorize] attribute will automatically redirect the user to a login page in order to authenticate (after which they'll have access):

The [Authorize] attribute optionally allows you to grant access only to specific users and/or roles. For example, if I wanted to limit access to the "About" action to just myself and Bill Gates I could write:

Typically for all but trivial applications you don't want to hard-code user names within your code. Instead you usually want to use a higher-level concept like "roles" to define permissions, and then map users into roles separately (for example: using active directory or a database to store the mappings). The [Authorize] attribute makes it easy to control access to Controllers and Actions using a "Roles" property:

The [Authorize] attribute does not have a dependency on any specific user identity or role management mechanism. Instead it works against the ASP.NET "User" object - which is extensible and allows any identity system to be used.

AccountController Class

I mentioned above that the [Authorize] attribute can be used with any authentication or user identity management system. You can write or use any custom login UI and/or username/password management system you want with it.

To help you get started, though, the ASP.NET MVC Project Template in Visual Studio now includes a pre-built "AccountController" and associated login views that implement a forms-authentication membership system with support for logging in, logging out, registering new users, and changing passwords. All of the views templates and UI can be easily customized independent of the AccountController class or implementation:

The Site.master template also now includes UI at the top-right that provides login/logout functionality. When using forms-based authentication it will prompt you to login if you are not currently authenticated:

And it displays a welcome message along with a logout link if you are authenticated on the site:

Clicking the Login link above takes users to a Login screen like below that they can use to authenticate:

New users can click the register link to create new accounts:

Error handing and error display is also built-in:

The AccountController class that is added to new projects uses the built-in ASP.NET Membership API to store and manage user credentials (the Membership system uses a provider API allowing any back-end storage to be plugged-in, and ASP.NET includes built-in providers for Active Directory and SQL Server). If you don't want to use the built-in Membership system you can keep the same AccountController action method signatures, View templates, and Forms Authentication ticket logic, and just replace the user account logic within the AccountController class. For the next ASP.NET MVC preview release we are planning to encapsulate the interaction logic between the AccountController and the user identity system behind an interface - which will make it easier to plug-in your own user storage system (without having to implement a full membership provider) as well as to easily unit test both it and the AccountController.

Our hope is that this provides a nice way for people to quickly get started, and enable them to have a working end to end security system as soon as they create a new project.

Testing TempData

One last improvement to touch on in this first preview 4 post is some improvements being made on the Controller class that allow you to more easily unit test the TempData collection. The TempData property allows you to store data that you want to persist for a future request from a user. It has the semantic of only lasting one future request (after which it is removed). It is typically used for MVC scenarios where you want to perform a client-side redirect to change the URL in the browser, and want a simple way to store scratch data.

With previous ASP.NET MVC Previews you had to mock objects in order to test the TempData collection. With Preview 4 you no longer need to mock or setup anything. You can now add and verify objects within the Controller's TempData collection directly within your unit tests (for example: populate a controller's TempData property before calling its action method, or verify that the action updated the TempData after the action returned). The actual storage semantics of the TempData collection is now encapsulated within a separate TempDataProvider property.

Conclusion

Hopefully the above post provides a quick look at a number of the new features and changes coming with ASP.NET MVC Preview 4. My next post on ASP.NET MVC Preview 4 will cover the new AJAX functionality that has been added, and demonstrate how to take advantage of it.

Hope this helps,

Scott

Passed 70-643

Sander Gerz — Fri, 11 Jul 2008 13:37:00 GMT

In order to upgrade my MCSE certification, I'm taking exams for Windows Server 2008. I could upgrade through a special upgrade path, but since I never took any exam on Windows 2003, I would first have to upgrade from 2000 to 2003, and then to 2008. I preferred to focus entirely on Windows Server 2008.

The end-goal is the MCITP: Enterprise Administrator certification. In order to achieve that, there are 4 exams to pass. For starters, I took exam 70-643 (Windows Server 2008 Applications Infrastructure Configuration). My hope was that my experience in the webhosting business made the preparation bit easier and would also be a benefit taking the exam. As a result, I focussed more on topics like Terminal Server and Windows deployment options, and less on IIS.

I passed. 953 out of 1000. Topic needing more attention: IIS

:-O

Next up: 70-642. I'm almost getting my head around ipv6.

Dinsdag 24 juni: Software Factories & DSL's

dvroegop — Tue, 17 Jun 2008 11:02:28 GMT

Software factories en DSL's zijn een hot item in ons vakgebied. Er is veel informatie over te vinden, zoveel dat je eigenlijk door de bomen het bos niet meer ziet. Een goede bron van informatie zijn uiteraard de webcasts van Microsoft.

Het is wel opvallend dat in veel van die webcasts verwezen wordt naar een Nederlands bedrijf die erg veel gedaan heeft op dit gebied: ze noemen bijna allemaal Ordina als reference site...

Het leek ons dus handig om de mensen van Ordina eens aan het woord te laten over dit onderwerp. En op dinsdag (ja ja, dinsdag) 24 juni gaat dat gebeuren!

Dus als je meer wilt weten over Software Factories ben je van harte uitgenodigd om je in te schrijven voor deze gratis bijeenkomst en te luisteren wat Ordina over dit onderwerp te vertellen heeft!

We zien je graag op de 24e te Nieuwegein!

Silverlight 2 Beta2 Released

ScottGu — Sat, 07 Jun 2008 04:50:26 GMT

Silverlight 2 Beta2 was released today. You can download both Silverlight 2 Beta2 and the Visual Studio and Expression Blend tools support to target it here.

Beta2 adds a lot of new features (more details below), but is still a 4.6 MB download that takes less than 10 seconds to install on a machine. It does not require the .NET Framework or any other software to be installed for it to work, and all features work cross-browser on both Mac and Windows machines. These features will also be supported on Linux via the Moonlight 2 release.

Silverlight 2 Beta2 supports a go-live license that allows you to start using and deploying Silverlight 2 for commercial applications. There will be some API changes between Beta2 and the final release, so you should expect that applications you write with Beta2 will need to make some updates when the final release comes out. But we think that these changes will be straight-forward and relatively easy, and that you can begin planning and starting commercial projects now.

You can build Silverlight Beta2 applications using the VS 2008 Tools for Silverlight and Expression Blend 2.5 June Preview downloads. You can download both of them here. The VS 2008 Tools for Silverlight download works with both VS 2008 and the recent VS 2008 SP1 beta release.

UI and Control Improvements

Silverlight 2 Beta2 includes a bunch of work in the UI and Control space:

More Built-in Controls

In Beta 1 only a few controls were included with the core Silverlight setup. Most common controls (including Button, ListBox, Slider, etc) were shipped within separate assemblies that you had to bundle with your applications (which increased the app download size). Beta 2 now installs 30+ of the most common controls as part of the core Silverlight 2 download. This means that you can now build Silverlight 2 applications that use core controls that are as small as 3kb in size - making Silverlight application downloads small and startup time fast.

In addition to the core controls included with the base Silverlight 2 setup, we are also this week shipping additional higher-level controls that are implemented in separate assemblies that you can then reference and include with your applications. This includes controls like DataGrid (more details on its new Beta2 features below), Calendar (now with multi-day selection and blackout date support in Beta2), and a TabPanel control (new in Beta2).

We ultimately expect to ship over a 100 controls for Silverlight.

Control Template Editing Support

One of the most powerful features of the WPF and Silverlight programming model is the ability to completely customize the look and feel of controls. This allows developers and designers to sculpt the UI of controls in both subtle and dramatic ways, and enables a tremendous amount of flexibility. I covered these concepts a little in my previous Silverlight Control Templating blog post here.

This week's Expression Blend 2.5 June Preview now adds designer support for editing control templates - which makes it easy for you to quickly change the look of any control without having to drop-down to XAML source to-do it.

To see control template editing in action, just drag/drop two Slider controls onto the Expression Blend design surface:

We might decide that the slider head in the default Slider control template is too large and wide for our application. To use control template editing to change it, we can right-click on one of the sliders in the designer and select the "Edit Control Parts" context menu item. We can choose to create a new empty control template for our slider (and start from scratch), or alternatively edit a copy of the built-in control template (and start from that and tweak it):

After we choose to edit a copy of the existing control template, Blend will prompt us to create and name a re-usable style resource that we'll define our control template within. We can name it and then choose to store the style at either the application level (within App.xaml) or within our current page/user-control:

When we click "ok" we'll find ourselves in template editing mode for our Slider control. We can change, tweak, or add/remove any of the underlying elements within the Slider control's template. Notice below how in template editing mode we can see and select any of the underlying elements that make up the slider's control template (these are circled in red below in the "Objects" window).

To make our slider head narrower, we can select the "HorizontalThumb" element within the control template and adjust its width (either graphically or via the property grid):

We can then use the breadcrumb navigation bar at the top of the designer to navigate back to our page and see the control template changes applied:

Notice that right now only one of our slider controls is using the new Style resource with the control template we defined.

To apply the same style resource to the other slider control as well, we can select it, right-click, and then use the "Apply Resource" context menu to apply our "ScottSlider" style to it as well:

Once we do this both our sliders reference the same style:

Changes we make to the "ScottSlider" style going forward will automatically apply to both controls.

Note that all controls shipped with Silverlight 2 support control templates and will support the above editing experience in Expression Blend.

Visual State Manager (VSM) Support

Control templates in Silverlight and WPF support customizing both the "look" of a control, as well as the "feel" of a control. By "feel" I mean changing its interactive responsiveness. For example: how it reacts when pushed, when it gets focus, loses focus, is in a pushed state, is in a disabled state, has something inside it selected, etc. Often you want animations to execute when the user interacts with a control like this.

One of the new things we are introducing with Silverlight 2 Beta2 is a "Visual State Manager" (VSM) feature that makes it much easier to build interactive control templates. VSM introduces two basic concepts that you can take advantage of within control templates: "Visual States" and "State Transitions". For example, a control like Button defines multiple visual states for itself - "Normal", "MouseOver", "Pressed", "Disabled", "Focused", "Unfocused". When in template editing mode in Blend, designers now have the ability to easily edit what the button looks like in each particular state, as well as setup transition rules to control how long it should take to animate when moving from one state to another. At runtime Silverlight will then dynamically run the appropriate animation Storyboards to smoothly move the control from one state to another.

What is nice about this model is that designers do not need to write code, do not need to manually create animation storyboards, and do not need to understand the object model of controls in order to be productive. This makes the learning curve for creating interactive control templates really easy, and means that existing graphic designers can very easily work on Silverlight projects. Later this year we will also be adding Visual State Manager (VSM) support to WPF as well, which will let you use the same approach with Windows applications as well as share control templates between WPF and Silverlight projects.

To see an example of this in action, let's add a Button control onto our design surface:

We can then right click on the button and edit its control template. Instead of starting with the existing default control template (like we did with the slider example above), let's create an empty control template and start from scratch:

Blend will prompt us for the name of the Style resource we want to create. We'll name it "ScottButton" and click ok. This will then put the designer in control editing mode for the Button, and start with an empty control template:

One of the things to notice above is the new "States" window inside Blend. This will show us all of the available "Visual States" that the Button control exposes. Above the "Base" state is currently selected - which allows us to define the common visual tree of our Button control template.

We can then add some vector elements into our base state that defines the look of a custom button like below. We could use the built-in vector drawing tool support provided by Blend to author these graphics, or alternatively use Expression Design or Adobe Illustrator to build the vector art and then import it into Blend. Below we are adding 4 "Path" elements into our control template - one a rounded background (named "background"), one a drop shadow (named "shadow"), one a 40% opacity "shine" that adds a glow near the top, and one that defines the default inner content (in this case a picture of a house):

Note: we could have alternatively imported an image, but using vector elements will give us the flexibility to scale/stretch/transform the button later and retain a crisp look and feel at any resolution or scale (particularly useful with Silverlight mobile scenarios - where screen resolutions might be different or smaller). It will also allow us to easily animate/change any vector element within the artwork.

Once we've finished designing our base state above, we can press F5 to run our application in the browser:

As you can see above - our Button control now has a nicer look. Despite its new look, the button still raises the same focus, click and hover events just like before - so a developer using the button does not need to change any code when working with a button that uses our new control template.

One downside with our new button control template, though, is that it isn't interactive. This means that I don't get any visual feedback if the button gains/looses focus, or if a mouse hovers over it. I also don't get a nice depress/bounce-back animation when I click it.

To add interactivity to our button, we'll return back to Blend and work with our Button's control template again. Previously we added vector graphic elements to the "Base" state of our Button control. This allowed us to define the default visual look of all visual states of our Button. We can now go back and customize individual Button visual states further.

For example, to implement a mouse-over behavior for our Button, we can select the "MouseOver" state in the "States" window, and then tweak the look of the button when it is in that state. Below I've selected the "shine" vector element inside our control template and adjusted its Opacity property in the property grid to have it be more visible when in the MouseOver state. Notice how Blend automatically highlighted the "Shine" element with a red dot and then listed the Opacity property below it in our objects window. This makes it easy to quickly track all changes that we've made between the "Base" state and the "MouseOver" state in our control template:

We can then select the "Pressed" state in the "States" window, and customize what a button looks like when it is pressed. We'll change two things from the "base" state. The first change is to make the "shine" element visible (like the MouseOver state). The second change will be to slightly offset the contents of the button control - while keeping the shadow element stationary. This will give the button a nice "depressed" look and contrast nicely with its base visual:

We can implement the offset change to the background, content and shine elements by selecting them in the designer, and then apply an offset render transform to them in the property browser:

And now when we run our application again in the browser, we'll find that our Button now has interactive visual feedback when it is being used. Below is the "normal" look of our Button:

Hovering the mouse over the Button will then cause it to glow like below:

Clicking the button will then cause it to depress and hide the shadow (it will then bounce back once the mouse button is released):

Note that we did not have to write any code or XAML to change our Button's look and feel - the new Visual State Manager feature automatically handled moving between visual states for us.

By default Silverlight dynamically constructs and runs a transition Storyboard for you as you move from visual state to visual state (providing a smooth animation between the two states). You do not need to write any code in order to make this happen (note: you do still have the ability to drop down and add a custom Storyboard transition if you want to, but for most cases you can probably use the automatic Storyboard transition).

One feature you can take advantage of with Silverlight's automatic transition feature is to customize the time duration it takes for a visual state transition to occur. You can do this by clicking the arrow to the right of a visual state and setup a rule that controls how long it should take the transition animation to run when moving from one particular state to another.

For example, we could indicate that we want it to take .2 seconds to transition from the "Normal" to "MouseOver" visual state by adding the rule below:

We can then configure this rule to take .2 seconds to transition between Normal->MouseOver like so:

We can then click on the "MouseOver" state and setup a rule that causes the transition from MouseOver->Normal to take .4 seconds:

Now when we re-run our application we'll have slower animation transitions for MouseOver scenarios, which adds a slightly smoother and more polished feel to our application. We did not have to write a single line of code to enable this. All controls shipped with Silverlight 2 will have built-in support for Control Template and Visual State Manager customization like above.

To learn more about the new Visual State Manager and Control Template Editing features, please check out the tutorials here and here, and the videos on it here, here, and here.

TextBox

Beta2 includes some significant improvements to the built-in TextBox editing control. Text scrolling with text-wrap, multi-line text selection, document navigation keys, and copy/paste from the clipboard are now supported.

Beta2 also now includes IME Level 3 input support (including candidate window selection) for non-western character sets:

Input Support

Beta2 adds additional keyboard support in FullScreen mode (arrow, tab, enter, home, end, pageup/pagedown, space). Note: full key input support isn't allowed to avoid password spoofing scenarios.

Beta2 also adds new APIs to support inking and stylus input support.

UI Automation and Accessibility

Beta2 adds UI Automation Framework support into Silverlight. UI Automation (or UIA) enables screen readers and other assistive tools to identify and interact with the components that make up your Silverlight 2 application.

Beta2 uses the UIA framework and adds UIA based behaviors to an initial set of Silverlight controls. By the final release of Silverlight 2 all controls will have UIA based behaviors built-in. We will also add support for high-contrast scenarios. These features will enable you to build accessible, section 508 compliant, applications. This UIA support will also enable automated UI testing of applications.

Animation and Graphic System

Beta2 adds support for animating custom dependency properties. Object animation support (animating structs) is also now supported. Beta2 also supports the ability to create Storyboards in code that can animate parts of the render tree without having to be added to it (allowing you to embed animations entirely in code). Per frame animation callback support will be added in the final release.

Beta2 includes a new Visual Tree Helper static class that provides advanced visual tree inspection APIs. It provides features such as the ability to enumerate children of an element and getting the ancestor/parent of a given reference element. These APIs work against any UIElement you pass to it.

DeepZoom

Beta2 now supports an XML based manifest file for DeepZoom collections. Beta2 also adds extensible MultiScaleTileSource support for DeepZoom (which allows developers to hook up existing image pyramids that don’t conform with the Deep Zoom format to the high performance rendering of Deep Zoom).

WPF Compatibility

Silverlight Beta2 includes a lot of fixes/changes to improve API compatibility between Silverlight and WPF (note: the final Silverlight release will contain some additional compatibility work as well). We are also adding some new APIs we are introducing in Silverlight 2 to WPF in .NET 3.5 SP1 this summer.

This work, combined with the VSM support we are adding to WPF later this year, will enable good code re-use across browser and desktop applications.

Media Improvements

Silverlight 2 Beta2 includes some significant Media related feature work:

Adaptive Streaming

Beta2 adds support for "adaptive streaming" - which enables you to encode media at multiple bit-rates and then have a Silverlight application dynamically switch between them depending on the network and CPU conditions.

This enables much richer end-user media experiences - since it makes it possible for content providers to provide both lower-end and higher-end bit rate versions of a video, and then have Silverlight choose the optimal one to use based on an end-user's machine hardware and network capacity. If while watching the video the machine or network conditions change, Silverlight can automatically switch to a more appropriate bit-rate without any buffering or interruption glitch.

Silverlight's support for adaptive streaming is extensible - which enables anyone to plug-in their own logic to control where the media content comes from, and what bit-rate should be used. This means that any CDN or media delivery provider can easily integrate their systems with Silverlight and deliver super high quality video delivery.

Content Protection

Beta2 includes DRM content protection, and supports Windows DRM and PlayReady DRM. Both work cross browser and cross platform.

Server Side Playlists

Beta2 adds support for server side playlists (previous releases only supported client-side playlists).

Networking Improvements

Silverlight 2 Beta2 includes a bunch of work in the networking space:

Cross Domain Sockets

Beta2 now enables cross domain networking support using both HTTP and Sockets (meaning your application can call sites other than the one the application was downloaded from).

Silverlight will check for the existence of an XML policy file on target servers that indicates whether cross domain network access is allowed. Silverlight supports a new XML policy file format that we've developed, as well as Flash policy files (which means existing sites open to Flash can be called from Silverlight without any additional work).

Background Thread Networking

Beta2 now allows Silverlight applications to initiate network requests on background threads, as well as process/handle network responses on background threads. This enables a bunch of powerful scenarios, and allows you to avoid blocking the browser's UI thread while doing both HTTP and Socket network communication.

Duplex Communication (Server Push)

Beta2 enables support for setting up duplex communication channels with a WCF service on a server. This enables a clean programming model that allows servers to "push" messages to Silverlight clients without the developer having to manually poll servers for changes. This programming model is very useful in a variety of scenarios, including instant messenger/chat applications, and monitoring/update applications like stock tickers and trader applications.

Web Services

Beta2 enables significantly improved interop with SOAP based web-services. Web service proxy class end-point URLs can now be configured without recompiling applications. Visual Studio also now has a new "Silverlight-enabled WCF Service" project item template that you can add to ASP.NET web projects to publish services to clients.

REST and ADO.NET Data Services

Silverlight includes support for working with REST based web-services.

Beta2 adds support for calling and consuming ADO.NET Data Services (formerly code-named: "Astoria"). ADO.NET Data Services will ship as part of .NET 3.5 SP1 and makes it easy to publish data end-points within an ASP.NET web project that are consumable from any client using REST URIs. Silverlight Beta2 now includes ADO.NET Data Service client support that allows you to easily call these services (and optionally use LINQ expressions within Silverlight to express remote REST queries to them).

JSON

Silverlight supports calling JSON-based services on the web.

Beta2 now includes LINQ to JSON support that enables you to easily query, filter, and map JSON results to .NET objects within a Silverlight application. This makes it easy to call and work with existing AJAX end-points and services published on the web.

Data Improvements

Silverlight 2 Beta2 includes a bunch of work in the data space:

DataGrid

Beta2 adds a number of new features to the DataGrid control. These include:

Auto-sizing support for columns and rows
Column sorting (with both single column and multi-column sort support)
Column re-ordering support by end-users (allowing them to drag/drop columns to re-arrange the order)
Frozen column support (allowing you to prevent a particular column from being customized)
Performance and bug fixes

DataBinding

Beta2 adds more core data-binding features and better validation support. These include:

Per-binding Validation and BindingValidationError event handler support on controls (allowing you to handle input validation with TwoWay bindings)
Support for binding expressions on attached properties
Richer binding value conversion support (including value conversion fallback support)

Isolated Storage

Silverlight enables applications to store data locally on a client (via a feature we call "Isolated Storage"). Applications can prompt users to grant them size permissions for this storage (for example: a user might grant an email program 50MB of local storage).

Beta2 increases the default local storage space provided to Silverlight applications to 1MB in size. Beta2 also now provides better end-user support for managing per-site storage permissions, as well as the ability to easily revoke/delete an application's local storage. Management UI to control this can now be brought up by an end-user by right-clicking on a Silverlight application and choosing the "Silverlight Configuration" menu option.

Understanding Compatibility with Silverlight 1.0 and Silverlight 2 Beta 1

Silverlight 2 Beta2 is compatible with applications that target Silverlight 1.0.

Silverlight 2 Beta2 will not run applications that target Silverlight 2 Beta1, since we've made a number of API changes between the two betas for the new features being added in Silverlight 2. Browsers that have Silverlight 2 Beta1 installed which visit a site that hosts a Silverlight Beta2 application will be prompted to upgrade to the newer beta of Silverlight. Once they do this they won't be able to run Beta1 applications without uninstalling Beta2. This means that if you have published a running sample on the web built with Beta1 you will probably want to update it to Beta2 soon.

We have published a document that details the changes between Beta1 and Beta2 here that can help with this. I also recommend reading Shawn Wildermuth's What Changed in Silverlight 2 Beta2 and Upgrading your Silverlight 2 Projects to Beta2 posts for more details on some of the changes between Beta1 and Beta2.

Summary

To learn more about Silverlight 2 and download the Beta2 release, please visit the http://www.silverlight.net and http://expression.microsoft.com web-sites. We'll be posting articles, tutorials, videos and more on both sites in the days and weeks ahead. I'll also be posting some tutorials of my own here on my blog as well.

If you haven't already read them I'd also recommend checking out my previous First Look at Silverlight 2 and First Look at Expression Blend with Silverlight 2 blog posts that I wrote a few months ago when Beta1 shipped, since they provide a good overview of the Silverlight programming model and how to target it using both Visual Studio 2008 and Expression Blend.

Hope this helps,

Scott

Powershell door Marc van Orsouw: demo code staan online

dvroegop — Thu, 05 Jun 2008 16:42:27 GMT

Voor diegene die er bij waren en ook voor diegene die er niet bij waren maar wel geinteresseerd zijn: de demo code van Marc van Orsouw staat online op http://www.dotned.nl/files/8/ppt/entry849.aspx

ASP.NET MVC Support with Visual Web Developer 2008 Express

ScottGu — Mon, 02 Jun 2008 03:50:22 GMT

Last week I blogged about the ASP.NET MVC Preview 3 release. One important thing I forgot to mention about this release is that you can now use it with both Visual Studio 2008 as well as the free Visual Web Developer 2008 Express edition.

The SP1 release of Visual Web Developer 2008 Express adds support for both class library projects as well as web application projects (previously only web site projects could be used with it). This new support is useful in itself, as well as in enabling both ASP.NET MVC and Silverlight project support with VWD Express. If you install the Visual Web Developer Express SP1 Beta you can start using ASP.NET MVC Preview 3 with it immediately.

Important: ASP.NET MVC Preview 3 does not require SP1 to be installed if you are using Visual Studio 2008. ASP.NET MVC Preview 3 will work with both VS 2008 and VS 2008 SP1 just fine.

You can learn more about the new VWD Express support for ASP.NET MVC from the VS Web Tools team blog here. This post also includes a free web download that provides ASP.NET MVC Test project support for NUnit-based unit tests. You can use these NUnit project templates with both Visual Studio 2008 as well as with Visual Web Developer Express 2008.

Hope this helps,

Scott

ASP.NET MVC Preview 3 Release

ScottGu — Tue, 27 May 2008 22:26:36 GMT

This morning we released the Preview 3 build of the ASP.NET MVC framework. I blogged details last month about an interim source release we did that included many of the changes with this Preview 3 release. Today's build includes some additional features not in last month's drop, some nice enhancements/refinements, as well as Visual Studio tool integration and documentation.

You can download an integrated ASP.NET MVC Preview 3 setup package here. You can also optionally download the ASP.NET MVC Preview 3 framework source code and framework unit tests here.

Controller Action Method Changes

ASP.NET MVC Preview 3 includes the MVC Controller changes we first discussed and previewed with the April MVC source release, along with some additional tweaks and adjustments.

You can continue to write controller action methods that return void and encapsulate all of their logic within the action method. For example:

which would render the below HTML when run:

Preview 3 also now supports using an approach where you return an "ActionResult" object that indicates the result of the action method, and enables deferred execution of it. This allows much easier unit testing of actions (without requiring the need to mock anything). It also enables much cleaner composition and overall execution control flow.

For example, we could use LINQ to SQL within our Browse action method to retrieve a sequence of Product objects from our database and indicate that we want to render a View of them. The code below will cause three pieces of "ViewData" to be passed to the view - "Title" and "CategoryName" string values, and a strongly typed sequence of products (passed as the ViewData.Model object):

One advantage of using the above ActionResult approach is that it makes unit testing Controller actions really easy (no mocking required). Below is a unit test that verifies the behavior of our Browse action method above:

We can then author a "Browse" ViewPage within the \Views\Products sub-directory to render a response using the ViewData populated by our Browse action:

When we hit the /Products/Browse/Beverages URL we'll then get an HTML response like below (with the three usages of ViewData circled in red):

Note that in addition to support a "ViewResult" response (for indicating that a View should be rendered), ASP.NET MVC Preview 3 also adds support for returning "JsonResult" (for AJAX JSON serialization scenarios), "ContentResult" (for streaming content without a View), as well as HttpRedirect and RedirectToAction/Route results.

The overall ActionResult approach is extensible (allowing you to create your own result types), and overtime you'll see us add several more built-in result types.

Improved HTML Helper Methods

The HTML helper methods have been updated with ASP.NET MVC Preview 3. In addition to a bunch of bug fixes, they also include a number of nice usability improvements.

Automatic Value Lookup

With previous preview releases you needed to always explicitly pass in the value to render when calling the Html helpers. For example: to include a value within a <input type="text" value="some value"/> element you would write:

The above code continues to work - although now you can also just write:

The HTML helpers will now by default check both the ViewData dictionary and any Model object passed to the view for a ProductName key or property value to use.

SelectList and MultiSelectList ViewModels

New SelectList and MultiSelectList View-Model classes are now included that provide a cleaner way to populate HTML dropdowns and multi-select listboxes (and manage things like current selection, etc). One approach that can make form scenarios cleaner is to instantiate and setup these View-Model objects in a controller action, and then pass them in the ViewData dictionary to the View to format/render.

For example, below I'm creating a SelectList view-model class over the set of unique category objects in our database. I'm indicating that I want to use the "CategoryID" property as the value of each item in the list, and the "CategoryName" as the display text. I'm also setting the list selection to the current CategoryId of the Product we are editing:

Within our view we then just have to write the below code to indicate that we want to create a drop-downlist against the SelectList we put into ViewData:

This will then render the appropriate drop down with items and selection for us at runtime:

Built-in error validation support isn't included with our HTML helpers yet (you currently need to write code for this) - but will show up in the future, which will make form editing scenarios even easier.

You'll also start to see ASP.NET AJAX helper methods show up in future preview releases as well, which will make it easier to integrate AJAX into MVC applications with a minimum of code.

URL Routing Improvements

ASP.NET MVC Preview 3 includes a number of improvements to the URL routing system. URL routing is one of the most "fundamental" components of a web MVC framework to get right, hence the reason we've spent a lot of focus the first few previews getting this area nailed. Our new URL routing engine will ship in .NET 3.5 SP1 this summer, and will support both Web Forms and MVC requests. ASP.NET MVC will be able to use the built-in .NET 3.5 SP1 routing engine when running on .NET 3.5 SP1. ASP.NET MVC will also include its own copy of the assembly so that it can also work on non-SP1 systems.

Some of the URL Routing Improvements in the Preview 3 release include:

MapRoute() and IgnoreRoute() helper methods

ASP.NET MVC Preview 3 includes new "MapRoute" and "IgnoreRoute" helper methods that you can use to more easily register routing rules. MapRoute() provides an easy way to add a new MVC Route rule to the Routes collection. IgnoreRoute() provides an easy way to tell the URL routing system to stop processing certain URL patterns (for example: handler .axd resources in ASP.NET that are used to serve up JavaScript, images, etc).

Below is an example of the default RegisterRoutes() method within Global.asax when you create a new ASP.NET MVC project where you can see both of these new helper methods in action.

The MapRoute() helper method is overloaded and takes two, three or four parameters (route name, URL syntax, URL parameter default, and optional URL parameter regular expression constraints).

You can call MapRoute() as many times as you want to register multiple named routes in the system. For example, in addition to the default convention rule, we could add a "Products-Browse" named routing rule like below:

We can then refer to this "Products-Browse" rule explicitly within our Controllers and Views when we want to generate a URL to it. For example, we could use the Html.RouteLink view helper to indicate that we want to link to our "Products-Browse" route and pass it a "Food" category parameter using code in our view template like below:

This view helper would then access the routing system and output an appropriate HTML hyperlink URL like below (note: how it did automatic parameter substitution of the category parameter into the URL using the route rule):

We could alternatively use the new Url.RouteUrl(routeName, values) within views if we wanted to just retrieve the URL for a named route (and not output the <a> html element).

We could also use the new RedirectToRoute(routeName, values) helper method on the Controller base class to issues browser redirects based on named routing rules.

Richer URL Route Mapping Features

ASP.NET MVC Preview 3 also supports a bunch of new URL route mapping features. You can now include "-", ".", ";" or any other characters you want as part of your route rules.

For example, using a "-" separator you can now parse the language and locale values from your URLs separately using a rule like below:

This would pass appropriate "language", "locale", and "category" parameters to a ProductsController.Browse action method when invoked:

URL Route Rule	Example URL	Parameters Passed to Action method
{language}-{locale}/products/browse/{category}	/en-us/products/browse/food	language=en, locale=us, category=food
	/en-uk/products/browse/food	language=en, locale=uk, category=food

Or you can use the "." file extension type at the end of a URL to determine whether to render back the result in either a XML or HTML format:

This would pass both "category" and a "format" parameters to the ProductsController.Browse action method when invoked:

URL Route Rule	Example URL	Parameters Passed to Action method
products/browse/{category}.{format}	/products/browse/food.xml	category=food, format=xml
	/products/browse/food.html	category=food, format=html

ASP.NET MVC Preview 3 also supports wildcard route rules (these were also in Preview 2). For example, you can indicate in a rule to pass all remaining URI content on as a named parameter to an action method:

This would pass a "contentUrl" parameter to the WikiController.DisplayPage action method when invoked:

URL Route Rule	Example URL	Parameters Passed to Action method
Wiki/Pages/{*contentUrl}	/Wiki/Pages/People/Scott	contentUrl="People/Scott"
	/Wiki/Pages/Countries/UK	contentUrl="Countries/UK"

These wildcard routes are very useful to look at if you are building a blogging, wiki, cms or other content based system.

Summary

Today's Preview 3 release of ASP.NET MVC includes a bunch of improvements and refinements. We are starting to feel good about the URL routing and Controller/Action programming model of MVC, and feel that those areas are starting to bake really well. In future preview releases you'll start to see more improvements higher-up the programming model stack in areas like Views (html helpers, validation helpers, etc), AJAX, sub-controllers and site composition, deeper Login, Authentication, Authorization and Caching integration, as well as data scaffolding support.

I also have a (very) long tutorial post that I started putting together this past weekend that walks-through building an application using ASP.NET MVC Preview 3 that I'm hoping to wrap up and post in the next few days. This should provide both a good intro to ASP.NET MVC, as well as help provide some context on how all the pieces fit together if you are interested in using the ASP.NET MVC option.

Hope this helps,

Scott

Altijd zicht op alle events: de dotnetevents site

dvroegop — Tue, 27 May 2008 09:30:33 GMT

Zoals je weet organiseren wij bij dotNed iedere maand een gratis bijeenkomst. Het enige wat we van je verlangen is dat je je inschrijft zodat we weten hoeveel mensen er komen. Naast deze bijeenkomsten (komende donderdag weer: dit keer over Powershell, er zijn nog plaatsen over, dus schrijf je in op http://www.dotned.nl/meetings/default.aspx !) zijn wij ook aanwezig op evenementen zoals de DevDays, de SDN bijeenkomsten, de CodeCamp en natuurlijk de SDC. Mocht dit nou nog niet genoeg zijn, dan hebben we goed nieuws: er zijn meer evenementen in Nederland voor de .net ontwikkelaar dan bovengenoemde!

Het is alleen wel af en toe lastig om bij te houden wanneer nou wat gebeurt. Om dit probleem te omzeilen heeft MVP Maurice de Beijer (beter bekend als 'The Problemsolver') een nieuwe site gebouwd met daarop alle events die eventueel voor jou interessant kunnen zijn (mits het met .net te maken heeft, uiteraard). Je vindt deze kalender op http://www.dotnetevents.nl/Default.aspx En ja: ook de dotNed events worden hier opgenomen. Een aanrader!

DevDays, verslag volgt...

dvroegop — Fri, 23 May 2008 19:07:56 GMT

Maar tot die tijd wilde ik je dit niet onthouden. Mochten er nu nog mensen zijn die denken dat er rivaliteit tussen de Nederlandse Usergroups bestaat, dan moeten ze dit zeker lezen!

http://tweakers.net/advertorials/devdays/article/17/brug-tussen-ontwikkelaars-en-microsoft.html

WPF: Attached dependency properties

dvroegop — Wed, 21 May 2008 15:18:00 GMT

Dependency Properties

Wie wel eens met WPF gespeeld heeft kent waarschijnlijk de term Dependency Property wel. Het is een nieuwe manier om met properties om te gaan, en ik moet zeggen: ze hebben er iets moois van gemaakt. Niet verwonderlijk als je bedenkt dat Dependency Properties een van de eerste dingen die ze bedacht hebben voor WPF: de eerste voorstellen voor deze techniek stammen uit het jaar 2000!

Voor diegene die het niet kennen volgt hier een korte uitleg.

We kennen allemaal wel de 'normale' properties. Neem bijvoorbeeld het volgende stuk code:

    8 class SomeClass
    9 {
   10     private int _Getal;
   11 
   12     public int Getal
   13     {
   14         get { return _Getal; }
   15         set
   16         {
   17             if (_Getal == value)
   18                 return;
   19             _Getal = value;
   20         }
   21     }
   22 }

Dit is allemaal leuk en aardig maar heeft een klein probleem. Stel dat we 100 instances maken van deze class (dus 100 objecten in het geheugen hebben van dit type). Het geheugen ziet er dan als volgt uit:

1 maal de code
100 maal de virtual method table (met pointers vanuit ieder object naar de code)
100 pointers naar de virtual method table (de pointers naar de objecten)
100 integers met de standaard waarde 0

De eerste 3 kunnen we niets aan doen. Maar die laatste... laten we daar eens over nadenken. Stel je hebt een class met daarin tientallen properties. Niet alle worden gevuld, veel hebben de default waardes en die blijven ook zo. Neem bijvoorbeeld een Button class (de welbekende knop uit WinForms). Die heeft enorm veel properties die vrijwel allemaal ongewijzigd blijven. De name, location, size en caption, ja: die worden aangepast. Maar de rest? Blijft meestal standaard. Toch nemen al die properties ruimte in beslag: voor iedere instance, dus ieder object, weer opnieuw.

Het zou mooier zijn als we de defaultwaardes ergens kunnen parkeren, bijvoorbeeld bij het stuk code. Een keer slechts, en niet iedere keer opnieuw. Alleen als we willen dat de waarde afwijkt van de default waarde, dan moet de waarde opgeslagen worden bij het object zelf. Op die manier kunnen we enorm veel geheugen besparen.

Dit is nou precies een van de dingen die DependencyProperties voor ons doen. Een voorbeeld:

    9 class SomeClass : DependencyObject
   10 {
   11     public static readonly DependencyProperty GetalProperty = DependencyProperty.Register("Getal", 
   12                                                                   typeof(int), 
   13                                                                   typeof(SomeClass), 
   14                                                                   new PropertyMetadata(0, PropertyChanged));
   15 
   16     private static void PropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
   17     {
   18         if(obj is SomeClass)
   19             ((SomeClass)obj).ObjectPropertyChanged(args);
   20     }
   21 
   22     private void ObjectPropertyChanged(DependencyPropertyChangedEventArgs args)
   23     {
   24         // Doe iets met de nieuwe waarde
   25     }
   26 
   27     public int Getal
   28     {
   29         get { return (int)GetValue(GetalProperty); }
   30         set { SetValue(GetalProperty, value); }
   31     }
   32 }

Ik geef toe: het ziet er een stuk ingewikkelder uit dan de eerste code, maar als je even meeloopt door de code heen zul je zien dat het eigenlijk enorm meevalt.

We beginnen met de class declaration: deze is nu afgeleid van DependencyObject, en niet meer van Object. Voor dit verhaal moet je nu maar even aannemen dat DependencyObject hetzelde doet als Object.

Dan op regel 11 definieren we de DependencyProperty. Zoals je ziet is hij static en readonly. Static is mooi. Dat betekent dus dat hij inderdaad maar een keer in het geheugen staat. Hij is readonly, want de gebruikers van de class kunnen de property niet wijzigen. De naam van de DependencyProperty eindigt op ...Property. Dat is een coding convention waarvan ik je aanraadt hem ook te gebruiken.

Een DependencyProperty moet geregistreerd worden. Daartoe gebruiken we de static method Register in de DependencyPropert class. Deze heeft een aantal overloads, in dit geval gebruik ik de volgende parameters (dit is gelijk de meest voorkomende vorm). Als eerste geven we hem een naam. Als tweede het type (int in ons geval), als derde het type van de class die de owner is (vrijwel altijd de class waarin hij gedefinieerd is) en als laatste maken we een PropertyMetaData object aan.

Dit PropertyMetaData object bevat in ons geval als eerste de default waarde (die inderdaad maar 1 keer opgeslagen wordt in het geheugen!) en de naam van de method die aangeroepen wordt als de waarde van de property verandert ten opzichte van de default waarde.

Aangezien de DependencyProperty een static is, moet de PropertyChanged method ook static zijn. Die zie je in regel 16 staan. We kijken eerst even of de DependencyObject die ons aanroept inderdaad een SomeClass is (in ons geval is dat altijd zo: we hebben maar 1 DependencyProperty en de owner daarvan is... inderdaad: SomeClass) en vervolgens roepen we de instance method ObjectPropertyChanged aan. Daarin kunnen we allerlei dingen doen die moeten gebeuren als een property wijzigt. Denk bijvoorbeeld weer aan een button: als de Width wijzigt, zullen we de code moeten aanroepen die de Paint verzorgd.

De DependencyProperty is readonly. We kunnen er dus niet veel mee doen behalve uitlezen. Om nu toch toegang te geven definieren we een standaard property met dezelfde naam als de DependencyProperty maar zonder de postfix Property (en dezelfde naam als we gedefinieerd hebben in de Register method): Getal. Dit is een int en bevat een getter en een setter. In plaats van dat we in de getter en setter een backing field benaderen (die hebben we immers niet) gebruiken we de methods GetValue en SetValue. Deze komen uit de DependencyObject class en zorgen ervoor dat de waardes op de juiste plek komen. Als de waarde die gezet is gelijk is aan de default waarde, wordt er geen extra geheugen gebruikt. Als de waarde echter afwijkt, wordt er een int gealloceerd bij het object en daarin komt de nieuwe waarde te staan.

GetValue en SetValue nemen als waarde altijd een object van het type Object aan, dus bij de getter moeten we die even casten naar het juiste type.

Lees het nog een keer door en je zult zien dat het eigenlijk voor zich spreekt.

Attached Dependency Properties

Laten we het nog even ingewikkelder maken.

Naast de normale dependency properties kennen we ook de attached dependency properties. Deze zijn helemaal leuk.

Als het goed is heb je wel eens met de Grid gewerkt. Die krijg je immers standaard bij een Windows WPF Applicatie. De XAML code ziet er als volgt uit (ik heb even wat columns en rows toegevoegd):

<Window x:Class="WpfApplication2.Window1" 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    Title="Window1" Height="300" Width="300"> 
    <Grid> 
        <Grid.ColumnDefinitions> 
            <ColumnDefinition/> 
            <ColumnDefinition/> 
        </Grid.ColumnDefinitions> 
        <Grid.RowDefinitions> 
            <RowDefinition/> 
            <RowDefinition/> 
            <RowDefinition/> 
        </Grid.RowDefinitions> 
        <Label Grid.Column="0" Grid.Row="0">0 - 0</Label> 
        <Label Grid.Column="1" Grid.Row="0">1 - 0</Label> 
        <Label Grid.Column="0" Grid.Row="1">0 - 1</Label> 
        <Label Grid.Column="1" Grid.Row="1">1 - 1</Label> 
        <Label Grid.Column="0" Grid.Row="2">0 - 2</Label> 
        <Label Grid.Column="1" Grid.Row="2">1 - 2</Label> 
    </Grid>    
</Window>

Hier is iets vreemds aan de hand. Als je naar de help gaat van Label, zie je daar tussen de properties geen property Grid.Row en Grid.Column staan. Dat is op zich te begrijpen: een label hoeft niets te weten van een grid en al helemaal niet van de plaatsing in dat grid. Als dat wel zo zou zijn, zouden alle UIElements en afgeleiden deze properties moeten hebben. En de properties om de plaats in de DockPanel te kunnen zetten, en ook voor.. nou ja, je snapt het al: de code zou absoluut ondoorzichtig worden.

Nee, in plaats daarvan is Row en Column een DependencyProperty op de Grid class. Dit verklaart voor een deel de syntax: aangezien DependencyProperties static zijn kunnen we ze op deze manier aanroepen: Grid.Row="0"

Dit zijn de zogenaamde Attached Dependency Properties. Het zijn dependencyproperties die aan een andere class ge-attached worden, zodat het lijkt dat ze bij die andere class horen. Op die manier kan de container, in ons geval de Grid, invloed uitoefenen op de plaatsing van de labels.

Laten we dat zelf eens maken. Stel je voor dat je een listbox wilt hebben waarin je bepaalde regels of items anders wilt weergeven dan de rest. Denk aan dit:

Regel 1 en regel 3 in onze listbox zijn normaal, regel 2 daarentegen is cursief en vet.

De XAML code ziet er als volgt uit:

<Window x:Class="WpfApplication2.Window1" 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:detrio="clr-namespace:WpfApplication2" 
    Title="Window1" Height="300" Width="300"> 
    <Grid> 
        <detrio:MyListBox x:Name="myListbox"> 
            <Label>Regel 1</Label> 
            <Label detrio:MyListBox.IsEmphasized="true">Regel 2</Label> 
            <Label>Regel 3</Label> 
        </detrio:MyListBox> 
    </Grid> 
</Window>
 

We voegen een extra namespace toe: detrio (in clr-namespace:WpfApplication2, oftewel deze applicatie). Vervolgens heb ik mijn eigen listbox gedefinieerd (detrio:MyListBox) en daarin een aantal labels geplaatst. We geven hem een naam (x:name="myListbox"), wat niet nodig is voor de XAML maar wel als je er bij code bij wilt komen. Een van de labels, de tweede, heeft de detrio:MyListBox.IsEmphasized="true" meegekregen, wat er toe leidt dat het scherm er uit ziet zoals in bovenstaande screenshot.

We gaan de source van detrio:MyListBox eens bekijken en analyseren.

   10 class MyListBox : ListBox

We maken een nieuwe class die we afleiden van ListBox (let op: gebruik System.Windows.Controls.ListBox en niet System.Windows.Forms.ListBox: die laatste is immers de oude winforms listbox). Niet spannend tot nu toe. De ListBox die voor ons als baseclass dient, is onderdeel van een classHierarchy:

Zoals je kunt zien is de ListBox afgeleid van (via andere classes) DependencyObject, wat ik voorheen noemde als vereiste. Nu is het bij een Attached Property niet echt nodig dat er in de inheritance tree een DependencyObject zit, maar dat leg ik zo uit. Kwaad kan het in ieder geval niet.

Het wordt tijd voor onze nieuwe property:

   12 public static readonly DependencyProperty IsEmphasizedProperty = DependencyProperty.RegisterAttached("IsEmphasized", 
   13                                                                     typeof(bool), 
   14                                                                     typeof(MyListBox), 
   15                                                                     new PropertyMetadata(false, PropertyChanged));

Deze code hebben we al gezien, met een klein verschil: we roepen nu RegisterAttached aan in plaats van Register. Klein verschil, maar met dramatische gevolgen.

Als je namelijk een Attached Property maakt, hoef je geen standaard property aan te maken (met in ons geval de naam bool IsEmphasized). Dat mag wel, maar hij zal waarschijnlijk nooit gebruikt worden. Wat je echter wel moet doen bij een attached property, is twee methods maken die de waardes zetten of ophalen. In plaats van onze normale property dus. Deze zien er als volgt uit:

   17 public static void SetIsEmphasized(UIElement element, bool value)
   18 {
   19     element.SetValue(IsEmphasizedProperty, value);
   20 }
   21 
   22 public static bool GetIsEmphasized(UIElement element)
   23 {
   24     return (bool)element.GetValue(IsEmphasizedProperty);
   25 }

Twee methods, een om te zetten en een om uit te lezen. Ze moeten deze namen hebben: Getxxx en Setxxx. Het type van de eerste parameter (bij ons UIElement) mag je zelf bedenken. Hier zeg je dus eigenlijk welke classes de nieuwe property kunnen krijgen (zoals in ons geval de labels). Ik heb het wat breder gehouden en voor een UIElement gekozen. De tweede parameter bij de Setxxx en de returnvalue bij Getxxx is uiteraard gelijk als wat je bij de RegisterAttached hebt gebruikt.

Daarna rest alleen de implementatie: je roept SetValue aan op het element, en geeft hem onze DependencyProperty mee en de waarde (of bij de getter: je leest deze uit). Met andere woorden: een DependencyObject kan properties krijgen vanuit een andere class. Dat is precies wat hier gebeurt: een UIElement krijgt een link naar onze IsEmphasizedProperty.

In de RegisterAttached method geven we als callback mee de PropertyChanged method. Laten we die eens bekijken:

   27 private static void PropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
   28 {
   29     if(obj is Label)
   30         SetLabelEmphasized(obj as Label);
   31 }

In dit geval is obj meestal van het type Label. Immers, wij zetten alleen maar labels in onze listbox (technisch gezien zouden het allemaal type UIElement kunnen zijn, maar die gebruiken we niet in onze XAML code). Als het inderdaad een Label is, roepen we de static method SetLabelEmphasized aan en geven hem de label mee waarvan de attached property is gewijzigd. Let op: formeel is dit niet waar: de attached property hoort niet bij de label, immers: het is een onderdeel van MyListBox. Toch lijkt het wel zo te zijn, vandaar dat ik het ook zo benoem: de attached property van de label is gewijzigd. Jij weet nu beter: de property van MyListBox die gekoppeld is aan de label is gewijzigd, maar dat is zo'n mond vol....

De volgende code is erg eenvoudig:

   33 private static void SetLabelEmphasized(Label labelToSet)
   34 {
   35     if ((bool)(labelToSet.GetValue(MyListBox.IsEmphasizedProperty)))
   36     {
   37         labelToSet.FontStyle = FontStyles.Italic;
   38         labelToSet.FontWeight = FontWeights.ExtraBold;
   39     }
   40     else
   41     {
   42         labelToSet.FontStyle = FontStyles.Normal;
   43         labelToSet.FontWeight = FontWeights.Normal;
   44     }
   45 }

Deze method (static, uiteraard) krijgt een label en daarin zetten we wat font attributen. Een kind kan de was doen.

Als je dit vanuit de code wilt, werkt het iets anders. Op het eerste gezicht is dat niet zo duidelijk waarom dat zo moet, maar nu je weet hoe de attached properties werken is het vrij voor de hand liggend:

   22 public Window1()
   23 {
   24     InitializeComponent();
   25     Label label4 = new Label();
   26     label4.Content = "Regel 4";
   27     label4.SetValue(MyListBox.IsEmphasizedProperty, true);
   28     myListbox.Items.Add(label4);
   29 }

En dat is alles! Deze class kan, in XAML of in code, een aantal labels als content krijgen en die labels kunnen zelf aangeven of ze emphasized weergegeven worden of niet! Pure magie, als je het mij vraagt....

May 20th Links: ASP.NET, ASP.NET AJAX, .NET, Visual Studio, Silverlight, WPF

ScottGu — Wed, 21 May 2008 07:02:44 GMT

Apologies for the sparseness of my posting the last few weeks - work and life have been busy here lately. Below is a new post in my link-listing series to help kick things up a little. Also check out my ASP.NET Tips, Tricks and Tutorials page and Silverlight Tutorials page for links to popular articles I've done myself in the past.

ASP.NET

Bulk Inserting Data with the ListView Control: Matt Berseth continues his awesome posts with one that shows how to handle bulk-editing of data using the ASP.NET ListView control in .NET 3.5.

Master-Detail with the GridView, DetailsView, and ModalPopup Controls: Another great post from Matt that describes how to cleanly handle a common data entry scenario.

Creating Great Thumbnail Images in ASP.NET: A really nice blog post by a different Matt that details an approach that generates high quality (and small) thumbnail images.

Warning the User when Caps-Lock is on: Scott Mitchell has a nice article that describes how to automatically detect and warn users in login pages when the caps-lock button is on.

ASP.NET Perf Issue: Large numbers of application-restarts due to virus scanners: Tess Ferrandez has a great post that details a debug session to determine why an ASP.NET application was restarting frequently (causing performance slowdowns). The issue was a virus scanner that was causing files to be constantly updated. Make sure to check out the logging code you can add to your application to identify restart causes like this.

ASP.NET AJAX

ASP.NET AJAX Progress Bar Control: Matt Berseth has another great article that describes his new ASP.NET AJAX Progress Bar control.

Faster Page Loading By Combining Multiple JavaScript files in Batch: Omar Al Zabir (founder of PageFlakes.com and author of the great Building a Web 2.0 Portal with ASP.NET 3.5 book) has a good article that describes the performance benefit of merging multiple JavaScript file downloads. Note that .NET 3.5 SP1 will include a new script combiner feature that helps make doing this even easier.

Create ASP.NET AJAX Server Controls using the ScriptControl base class: Chris Pietschmann has a nice article that talks about how to build new ASP.NET AJAX server controls by deriving from the built-in ScriptControl base class.

Inline Edit Box and Postback Ritalin Beta: Dave Ward and Mike Davis have created a new CodePlex project for their popular Inline Edit Box and PostBack Ritalin ASP.NET AJAX controls.

.NET

7 Ways to Simplify your code with LINQ: Igor Ostrovsky has a great blog post that talks about new code techniques you can use to improve your code using .NET 3.5 and the new language and LINQ features in it.

Visual LINQ Query Builder for LINQ to SQL: Mitsu Furuta has created a cool Visual Studio designer that allows you to graphically construct LINQ to SQL queries. Also make sure to download download the latest LINQPad utility - which is invaluable for learning LINQ and trying out LINQ queries.

DataContracts without Attributes (POCO support): Aaron Skonnard has a good post that talks about a nice usability change with .NET 3.5 SP1 that allows you to serialize POCO (plain old objects) using the WCF serializers.

Ukadc.Diagnostics: Josh Twist pointed me at a new CodePlex project he is working on that extends the System.Diagnostics features in .NET to include richer logging features (SQL trace support, email support, etc).

Visual Studio

11 More VS Short Cuts you Should Know: A great post that talks about a bunch of useful shortcuts to print out and remember when using Visual Studio.

Did you know you can show extension methods in the object browser?: Sara Ford continues her excellent "Did you know" series. I confess I didn't know this one.

Silverlight

50 New Silverlight 2 Beta 1 Screencasts: Mike Taulty and Mike Ormond have put together 50 nice tutorial screen-casts that cover Silverlight 2 - all in their "spare time". Wow.

AutoComplete for Silverlight TextBoxes: Nikhil Kothari has a nice blog post that demonstrates how he built an auto-complete behavior control for Silverlight.

Scrolling through Large Resultsets with Silverlight 2 and LINQ to SQL: The Swiss MSDN team has a nice blog post that demonstrates how to scroll through large resultsets using the Silverlight DataGrid and LINQ to SQL.

IValueConverter: The Swiss Army Knife of Bindings: David Anson has a useful blog post and sample that demonstrates how to use the IValueConverter feature in Silverlight and WPF to support richer bindings against complex objects.

Silverlight 2 Pie Chart: Peter McGrattan has posted a nice control and article that demonstrates how to use a new Silverlight charting control he has written.

WPF

WPF week on Channel9: Watch 6 great videos on Channel9. Each one includes interviews and demos with members of the WPF team talking about some of the awesome work that went into WPF 3.5 SP1 (read my blog post here for a summary of some of it).

WPF Testing and Application Quality Guide: Check out the 0.2 release of a free online book being developed by Microsoft that covers how to test WPF applications. Definitely worth book-marking if you are doing WPF development.

Moving Toward WPF Data Binding One Step at a Time: Josh Smith has a great article on CodeProject.com that explains WPF data binding and walksthrough how to use it.

WPF 3.5 SP1 StringFormat: Lester has a nice post that describes how to use the new StringFormat feature in WPF 3.5 SP1. This makes it much easier to handle formatting of databound values.

Hope this helps,

Scott

29 mei: Powershell MVP Marc van Orsouw over... Powershell!

dvroegop — Tue, 20 May 2008 09:11:03 GMT

Veel mensen denken bij Powershell aan ingewikkelde scripts voor beheerders. Nu is het zo dat Powershell daar inderdaad veel gebruikt wordt. Maar wist je dat ook ontwikkelaars enorm veel kunnen doen met Powershell? Je kunt vanuit je scripts gebruik maken van het .net framework om zo de meest fantastische (en tijdsbesparende!) dingen te doen, dingen die je eigenlijk alleen vanuit een full-blown .net applicatie zou kunnen. En dus niet vanuit een script. En nu dus wel, met behulp van Powershell!

Wist je dit niet? Kom dan langs op 29 mei in Doorn voor een sessie over Powershell!

De spreker van deze avond is Marc van Orsouw. Hij wordt beschouwd als een van de grootste experts op het gebied van Powershell. Hij was de eerste MVP op dit gebied (dit jaar zijn er een paar bij gekomen zodat er nu wereldwijd 12 Powershell MVP's zijn). Hij wordt regelmatig door het Powershell team gevraagd om zijn mening over bepaalde features te geven. Je ziet het: ook als je al expert ben op het gebied van Powershell is dit een avond om niet te missen: als er iemand is die vragen kan beantwoorden op dit gebied is Marc het wel.

Voor de voorbereiding voor deze avond kun je je alvast inlezen op Marcs site op http://www.thepowershellguy.com Maar het is beter om het van de man zelf te horen!

We zien je graag op de 29e te Doorn!

29 mei: Powershell MVP Marc van Orsouw over... Powershell!

dvroegop — Tue, 20 May 2008 09:11:00 GMT

Wist je dit niet? Kom dan langs op 29 mei in Doorn voor een sessie over Powershell!

Voor de voorbereiding voor deze avond kun je je alvast inlezen op Marcs site op http://www.thepowershellguy.com Maar het is beter om het van de man zelf te horen!

Je kunt je inschrijven op http://www.dotned.nl/meetings/default.aspx Uiteraard is zoals altijd het bezoek aan onze avonden, inclusief wat eten en te drinken, gratis.

We zien je graag op de 29e te Doorn!

VB for C# programmers - a little gotcha

Sander Gerz — Thu, 15 May 2008 13:59:00 GMT

The debate whether to use C# or Visual Basic .NET is not uncommon for most .NET developers. Certainly, one has a distinct preference, but the general idea is that you can do in C# what you can do in VB and vice versa, because the .NET Framework is our common denominator. No, I don't mean XML literals versus automatic properties. It's the end result that counts.

So I'm currently involved in some VB programming when we stumbled upon something peculiar. Here's a simplified form of what my predecessor, also preferring C#, tried to do:

Public Class PropertyClass

Private m_name As String = String.Empty

Public Property Name() As String

Get

If m_name = String.Empty Then

Name = "Unknown"

End If

Return m_name

End Get

Set(ByVal value As String)

m_name = value

End Set

End Property

End Class

Simple enough, and here's the C# version:

class PropertyClass

{

private string m_name = string.Empty;

public string Name

{

get

{

if (m_name == string.Empty) Name = "Unknown";

return m_name;

}

set { m_name = value; }

}

What do you expect to happen here, using the C# version?

PropertyClass pc = new PropertyClass();

Console.WriteLine(pc.Name);

The output would show Unknown and that's expected, right?

And what would it be using the VB version?

Dim pc As New PropertyClass

Console.Write(pc.Name)

Well, surpsingly, at least to me, the output is... nothing! Yes, you try it. If we look at the compiler output. Here's what the C# compiler made of it:

    ...
    L_0016: brtrue.s L_0024
    L_0018: ldarg.0
    L_0019: ldstr "Unknown"
    L_001e: call instance void CSharpProperty.PropertyClass::set_Name(string)
    L_0023: nop
    L_0024: ldarg.0
    ...

I'm no expert in reading IL, but clearly you see a call to the set_Name method. For VB, the compiler turns it into:

    L_0015: stloc.1
    L_0016: ldloc.1
    L_0017: brfalse.s L_001f
    L_0019: ldstr "Unknown"
    L_001e: stloc.0
    L_001f: nop
    L_0020: ldarg.0

It's completely gone. The compiler simply removed the

Name = "Unknown"

It appears there's more difference between VB.NET and C# than I thought. I certainly hope to return to some C# code soon.

Visual Studio 2008 SP1 / .net 3.5 SP1 betas beschikbaar

dvroegop — Tue, 13 May 2008 07:57:53 GMT

Heet van de naald: de langverwachte Service Packs zijn bijna af, de beta's kunnen worden gedownload van de site van Microsoft. Ik heb hem geinstalleerd en ben nu aan het kijken waar ik allemaal tegen aan ga lopen. De downloads vind je hier onder:

Visual Studio 2008 SP1

http://www.microsoft.com/downloads/details.aspx?FamilyID=cf99c752-1391-4bc3-babc-86bc0b9e8e5a&DisplayLang=en

.NET Framework 3.5 SP1

http://download.microsoft.com/download/8/f/c/8fc1fe13-55de-4bf5-b43e-375daf01452e/dotNetFx35setup.exe

Visual Studio Express 2008 met SP1

Team Foundation Server 2008 SP1

http://download.microsoft.com/download/a/e/2/ae2eb0ff-e687-4221-9c3e-9165a942bc1c/TFS90sp1-KB949786.exe

Je weet wat ze zeggen: don't install Beta software on machines you care about. Het risico bestaat immers dat je de boel dusdanig beschadigt dat een complete herinstallatie de enige optie is om de boel aan de praat te krijgen. Tot nu toe werkt het bij mij wel aardig, maar ik moet er nog verder mee stoeien.

Ik hou je op de hoogte!

Visual Studio 2008 and .NET Framework 3.5 Service Pack 1 Beta

ScottGu — Mon, 12 May 2008 18:51:33 GMT

Earlier today we shipped a public beta of our upcoming .NET 3.5 SP1 and VS 2008 SP1 releases. These servicing updates provide a roll-up of bug fixes and performance improvements for issues reported since we released the products last November. They also contain a number of feature additions and enhancements that make building .NET applications better (see below for details on some of them).

We plan to ship the final release of both .NET 3.5 SP1 and VS 2008 SP1 this summer as free updates. You can download and install the beta here.

Important: SP1 Beta Installation Notes

The SP1 beta released today is still in beta form - so you should be careful about installing it on critical machines. There are a few important SP1 Beta installation notes to be aware of:

1) If you are running Windows Vista you should make sure you have Vista SP1 installed before trying to install .NET 3.5 SP1 Beta. There are some setup issues with .NET 3.5 SP1 when running on the Vista RTM release. These issues will be fixed for the final .NET 3.5 SP1 release - until then please make sure to have Vista SP1 installed before trying to install .NET 3.5 SP1 beta.

2) If you have installed the VS 2008 Tools for Silverlight 2 Beta1 package on your machine, you must uninstall it - as well as uninstall the KB949325 update for VS 2008 - before installing VS 2008 SP1 Beta (otherwise you will get a setup failure). You can find more details on the exact steps to follow here (note: you must uninstall two separate things). It is fine to have the Silverlight 2 runtime on your machine with .NET 3.5 SP1 - the component that needs to be uninstalled is the VS 2008 Tools for Silverlight 2 package. We will release an updated VS 2008 Tools for Silverlight package in a few weeks that works with the VS 2008 SP1 beta.

3) There is a change in behavior in the .NET 3.5 SP1 beta that causes a problem with the shipping versions of Expression Blend. This behavior change is being reverted for the final .NET 3.5 SP1 release, at which time all versions of Blend will have no problems running. Until then, you need to download this recently updated version of Blend 2.5 to work around this issue.

Improvements for Web Development

.NET 3.5 SP1 and VS 2008 SP1 contain a bunch of feature improvements targeted at web application development.

The VS Web Dev Tools team has more details (including specific bug fix details) on some of the VS specific work here. Below are more details on some of the work in the web-space:

ASP.NET Data Scaffolding Support (ASP.NET Dynamic Data)

.NET 3.5 SP1 adds support for a rich ASP.NET data "scaffolding" framework that enables you to quickly build functional data-driven web application. With the ASP.NET Dynamic Data feature you can automatically build web UI (with full CRUD - create, read, update, delete - support) against a variety of data object models (including LINQ to SQL, LINQ to Entities, REST Services, and any other ORM or object model with a dynamic data provider).

SP1 adds this new functionality to the existing GridView, ListView, DetailsView and FormView controls in ASP.NET, and enables smart validation and flexible data templating options. It also delivers new smart filtering server controls, as well as adds support for automatically traversing primary-key/foreign-key relationships and displaying friendly foreign key names - all of which saves you from having to write a ton of code.

You can learn more more about this feature from Scott Hanselman's videos and tutorials here.

ASP.NET Routing Engine (System.Web.Routing)

.NET 3.5 SP1 includes a flexible new URL routing engine that allows you to map incoming URLs to route handlers. It includes support for both parsing parameters from clean URLs (for example: /Products/Browse/Beverages), as well as support to dynamically calculate and generate new URLs from route registrations.

This new routing engine is used by both ASP.NET Dynamic Data as well as the new ASP.NET MVC framework. It will support both WebForms and MVC based requests.

ASP.NET AJAX Back/Forward Button History Support

.NET 3.5 SP1 adds new APIs to ASP.NET AJAX to allow you to better control the history list of a browser (enabling you to control the behavior of the back/forward button of the browser).

You can learn more about this feature in the article here and the screencast here.

ASP.NET AJAX Script Combining Support

.NET 3.5 SP1 introduces a new <CompositeScript> element on the <asp:ScriptManager> server control, which allows you to declaratively define multiple script references within it. All the script references within the CompositeScript element are combined together on the server and served as a single script to the client, reducing the number of requests to the server and improving page load time for ASP.NET AJAX applications.

The script combining feature supports both path based scripts and assembly resource based scripts, and dynamically serves up the combined scripts using the ScriptResources.axd handler.

Visual Studio 2008 Performance Improvements HTML Designer and HTML Source Editor

In February we released a HotFix roll-up that included a number of performance improvements and bug fixes for the VS 2008 Web Designer. VS 2008 SP1 includes all of these fixes, as well as a number of additional performance improvements.

Visual Studio 2008 JavaScript Script Formatting and Code Preferences

Visual Studio has for several releases supported rich source code formatting options for VB and C# (spacing, line breaks, brace positions, etc).

VS 2008 SP1 adds richer source code formatting support for JavaScript as well (both inline <script> blocks and .js files). You can now set your Javascript coding preferences using the Tools->Options dialog:

These preferences will be automatically used as you type new Javascript code in the source editor. You can also select existing code, right-click, and choose the "Format Selection" option to apply your style preferences to existing JavaScript code. You can learn more about this new feature here.

Better Visual Studio Javascript Intellisense for Multiple Javascript/AJAX Frameworks

VS 2008 includes Javascript Intellisense support in source view. The intellisense support with the initial VS 2008 release works well with vanilla JavaScript as well as code written using the ASP.NET AJAX JavaScript type patterns. JavaScript is a very flexible language, though, and many JavaScript libraries use this flexibility to full advantage to implement their features - sometimes in ways that prevented the intellisense engine from providing completion support.

VS 2008 SP1 adds much better intellisense support for popular Javascript libraries (we specifically did work to support JQuery, Prototype, Scriptaculous, ExtJS, and other popular libraries). You will get better default intellisense when you reference these libraries. We are also looking at whether we can maintain additional intellisense hint files that you can download to get even better intellisense and documentation support for some of the more popular libraries.

Below is an example of using a JQuery startup function with the VS 2008 SP1 JavaScript intellisense engine:

Notice below how VS 2008 SP1 can now provide method argument completion even on chained JQuery selectors:

Visual Studio Refactoring Support for WCF Services in ASP.NET Projects

VS 2008 SP1 adds better refactoring support for WCF services included within both ASP.NET Web Site and ASP.NET Web Application Projects.

If you use the refactoring support to rename the class name, interface contract, or namespace of a WCF service, VS 2008 SP1 will now automatically fix up the web.config and SVC file references to it.

Visual Studio Support for Classic ASP Intellisense and Debugging

Previous versions of Visual Studio included support for intellisense and debugging within classic ASP (.asp) pages. The file and project templates to create classic ASP pages/projects hasn't been in VS for a few releases, though, and with the initial VS 2008 we incorrectly assumed this meant that people weren't still using the classic ASP support. We heard feedback after we shipped that indeed they were.

With VS 2008 SP1 this support for classic ASP intellisense and debugging is back:

Visual Web Developer Express Edition support for Class Library and Web Application Projects

The Visual Web Developer 2008 Express edition (which is free) is being updated in SP1 to add support for both class library and ASP.NET Web Application project types. Previous versions of Visual Web Developer Express only supported ASP.NET web-site projects.

Among other benefits, the support of class library and web application projects will enable ASP.NET MVC and Silverlight projects to be built with the free Visual Web Developer 2008 Express. All of the above JavaScript, Dynamic Data, Classic ASP, and AJAX improvements work with Visual Web Developer Express as well.

Improvements for Client Development

.NET 3.5 SP1 and VS 2008 SP1 contain major performance, deployment, and feature improvements for building client applications.

Tim Sneath has a great blog post that talks about some of the client improvements here. Below are more details on them:

Application Startup and Working Set Performance Improvements

.NET 3.5 SP1 includes significant performance improvements to the CLR that enable much faster application startup times - in particular with "cold start" scenarios (where no .NET application is already running). Much of these gains were achieved by changing the layout of blocks within CLR NGEN images, and by significantly optimizing disk IO access patterns. We also made some nice optimizations to our JIT code generator that allow much better inlining of methods that utilize structs.

We are today measuring up to 40% faster application startup improvements for large .NET client applications with SP1 installed. These optimizations also have the nice side-effect of improving ASP.NET application request per second throughput by up to 10% in some cases.

New .NET Framework Client Profile Setup Package

.NET 3.5 SP1 introduces a new setup package option for developers building .NET client applications called the ".NET Framework Client Profile". This provides a new setup installer that enables a smaller, faster, and simpler installation experience for .NET client applications on machines that do not already have the .NET Framework installed.

The .NET Framework Client Profile setup contains just those assemblies and files in the .NET Framework that are typically used for client application scenarios. For example: it includes Windows Forms, WPF, and WCF. It does not include ASP.NET and those libraries and components used primarily for server scenarios. We expect this setup package to be about 26MB in size, and it can be downloaded and installed much quicker than the full .NET Framework setup package.

The assemblies and APIs in the .NET Framework Client setup package are 100% identical to those in the full .NET Framework setup package (they are literally the same binaries). This means that applications can target both the client profile and full profile of .NET 3.5 SP1 (no recompilation required). All .NET applications that work using the .NET Client Profile setup automatically work with the full .NET Framework.

A developer can indicate that the client application they are building supports both the .NET Framework Client Profile and the full .NET Framework by pulling up the project properties page for a client application within VS 2008 SP1. Within the project properties page they can select a new checkbox that indicates it only requires those assemblies included in the .NET Framework Client Profile:

VS 2008 will then ensure that the project can only reference those assemblies shipped in the client profile setup package (and it will generate a compile error if you try and use a type in an assembly not included in the client redist). The compiled client application will then run on machines that have both the full .NET Framework installed, as well as machines that only have the .NET Framework Client Profile installed.

If you have a machine that only has the .NET Framework Client Profile installed, and you try and run a .NET application on it that did not mark itself as supporting the .NET Framework Client Profile, then the CLR will refuse to run the application - and will instead prompt the end-user to upgrade to the full .NET Framework package. This ensures that applications always run correctly - and that developers do not need to worry about missing assembly exceptions at runtime if a user tries to run an application that requires the full .NET Framework on a machine that only has the .NET Framework Client Profile installed.

We believe that a large class of .NET client applications will be able to use this new .NET Client Profile setup to significantly speed up their installation, and enable a much more consumer friendly experience.

New .NET Framework Setup Bootstrapper for Client Applications

.NET 3.5 SP1 introduces a new "bootstrapper" component that you can use with client applications to help automate making sure that the right version of the .NET Framework is installed.

The bootstrapper component can handle automatically downloading and installing either the .NET Framework Client Profile or the full .NET Framework Setup Package from the Internet if your machine doesn't have either of them installed. The boostrapper can also automatically handle upgrading machines that have a previous version of the .NET Framework installed. For example, if your machine already has .NET 3.0 installed, and your application requires .NET 3.5, the bootstrapper can optionally download just the update files needed to upgrade it to .NET 3.5 (and avoid having to download the full .NET Framework setup download).

The setup bootstrapper component can be used with both ClickOnce based setup packages, as well as with third party installer products (like Installshield). The boostrapper optionally enables fully customized setup branding experiences (splash screens, custom setup wizard steps, etc) and should make it much easier to build optimized client setup experiences.

ClickOnce Client Application Deployment Improvements

.NET 3.5 SP1 includes several improvements for ClickOnce deployment of both Windows Forms and WPF applications. Some of these improvements include:

Support for the .NET Framework Client Profile (all ClickOnce features are supported with it)
ClickOnce applications can now be programmatically installed through a ‘Setup.exe’ while displaying a customized, branded install UX
ClickOnce improvements for generating MSI + ClickOnce application packages
ClickOnce error dialog boxes now support links to application specific support sites on the Web
ClickOnce now has design-time support for setting up file associations
ClickOnce application publishers can now decide to opt out of signing and hashing the ClickOnce manifests as they see appropriate for their scenarios.
Enterprises can now choose to run only Clickonce Applications Authenticode signed by ‘Known Publishers’ and block anything else from running
FireFox browser extension to support Clickonce installations using FireFox browsers

Windows Forms Controls

SP1 adds several new Windows Forms controls - including new vector shape, Printing, and DataRepeater controls:

WPF Performance Improvements

.NET 3.5 SP1 includes several significant performance optimizations and improvements to WPF. Some of the specific graphics improvements include:

Smoother animations
Hardware accelerated rendering of Blur and DropShadow Bitmap Effects
Text Rendering speed improvements - especially with VisualBrish and 3D scenes
2D graphics improvements - especially with z-index scenarios
A new WriteableBitmap class that enables real-time and tear-free bitmap updates. This enables custom "paint"-style applications, data visualizations, charts and graphs that optionally bypass the default WPF 2D graphics APIs.
Layered window performance improvements

SP1 also adds support for better data scalability in WPF. The ListView, ListBox and TreeView controls now support "item container recycling" and "virtualization" support which allows you to easily achieve a 40% performance improvement with scrolling scenarios. These controls also now optionally support a "deferred scrolling" feature which allows you to avoid scrolling in real time and instead wait until a user releases the scroll thumb (the default scrolling mode in Outlook). This can be useful when scrolling over very large data sets quickly.

WPF Data Improvements

.NET 3.5 SP1 includes several data binding and editing improvements to WPF. These include:

StringFormat support within {{ Binding }} expressions to enable easy formatting of bound values
New alternating rows support within controls derived from ItemsControl, which makes it easier to set alternating properties on rows (for example: alternating background colors)
Better handling and conversion support for null values in editable controls
Item-level validation that applies validation rules to an entire bound item
MultiSelector support to handle multi-selection and bulk editing scenarios
IEditableCollectionView support to interface data controls to data sources and enable editing/adding/removing items in a transactional way
Performance improvements when binding to IEnumerable data sources

WPF also now exposes hooks that enable developers to write custom panels w/ virtualized scrolling. We'll be using this support together with the above data binding improvements to build the new WPF datagrid that will be shipping later this year.

WPF Extensible Shader Effects

.NET 3.5 SP1 adds support in WPF for a new shader effects architecture and API that allows extremely expressive visual effects to be created and applied to any control or element within WPF. These shader effects support blending multiple input compositions together. What makes them particularly powerful is that WPF executes effects (including custom effects you build yourself) using the GPU - giving you fully hardware accelerated graphics performance. Like almost everything in WPF, you can also use WPF databinding and animation on the properties of an effect (allowing them to be fully integrated into an experience).

Applying an effect onto a Control is super easy - just set a Control's "Effect" property. For example, to add a hardware accelerated drop-shadow effect on a button you can use the built-in <DropShadowEffect> on it via either code or XAML:

Which will cause the button to render like so:

Because Effects are extensible, developers can create their own custom Effect objects and apply them. For example, a custom "DirectionalBlurEffect" could be created and added to a ListBox control to change its scroll appearance to use a blur effect if you rapidly scroll across it:

Keep an eye on Greg Schechter's blog to learn more about how the Effects architecture works and to learn how you can both create and apply new effects within your applications (his first set of posts are here).

Note: In addition to introducing the new Shader Effects API, WPF in SP1 also has updated the existing Blur and DropShadow Bitmap effects already in WPF to be hardware accelerated.

WPF Interoperability with Direct3D

.NET 3.5 SP1 adds support to efficiently integrate Direct3D directly into WPF. This gives you more direct access to the hardware and to take full advantage of the Direct3D API within WPF applications. You will be able to treat Direct3D content just like an image within an application, as well as use Direct3D content as textures on WPF controls.

For example, below are three samples from the Direct3D SDK:

We could either load them in as image surfaces within a WPF application, or map them as textures on WPF controls. Below is an example of mapping them as textures onto cubes in a WPF 3D application:

Note: the Direct3D integration isn't today's SP1 beta release. It will appear in the final SP1 release.

VS 2008 for WPF Improvements

VS 2008 SP1 includes several significant improvements for WPF projects and the WPF designer. These include:

Several performance improvements
Events tab support within the property browser
Ability to sort properties alphabetically in the property browser
Margin snaplines which makes form layout much quicker
Better designer support for TabControl, Expander, and Grid
Code initiated refactoring now updates your XAML (including both control declarations and event declarations in XAML)
Go to Definition and Find All References now support things declared in XAML

The debugger has also been updated in SP1 so that runtime errors in XAML markup (for example: referencing styles, datasources and/or other objects that don't exist) will now be better identified within the debugger:

Data Development Improvements

.NET 3.5 SP1 and VS 2008 SP1 include a bunch of improvements for data development. Some of them include:

SQL 2008 Support

VS 2008 and .NET 3.5 are being updated to include support for the upcoming SQL 2008 release. Visual Studio 2008 data designers, projects and wizards now fully supporting connecting and working against SQL 2008 databases.

ADO.NET Entity Framework and LINQ to Entities:

.NET 3.5 SP1 includes the new ADO.NET Entity Framework, which allows developers to define a higher-level Entity Data Model over their relational data, and then program in terms of this model. Concepts like inheritance, complex types and relationships (including M:M support) can be modeled using it. VS 2008 SP1 now includes built-in designer support to help with this modeling:

The ADO.NET Entity Framework and the VS 2008 Entity Framework Designer both support a pluggable provider model that allows them to be used with any database (including Oracle, DB2, MySql, PostgreSQL, SQLite, VistaDB, Informix, Sybase, and others).

Developers can then use LINQ and LINQ to Entities to query, manipulate, and update these entity objects.

ADO.NET Data Services (formerly code-named "Astoria")

.NET 3.5 SP1 includes a flexible framework that enables the creation of REST-based data services. Formerly code-named "Astoria", the ADO.NET Data Services framework provides support for publishing data through a standard REST URI syntax and using standard HTTP verbs to operate on the data resources. Developers can easily expose data models created using the ADO.NET Entity Framework, and/or use a pluggable provider model to expose other data models.

In addition to publishing data sources, the framework also adds a client API for working with remote REST services. Included with this client API is a LINQ library that allows the remote query of REST services.

WCF Development Improvements

.NET 3.5 SP1 and VS 2008 SP1 include several enhancements for WCF development. Some of these include:

Significant scalability improvements (5-10x) in Web-hosted application scenarios
Support for using ADO.NET Entity Framework entities in WCF contracts
API usability improvements with DataContract Serializers, and with the UriTemplate and WCF web programming models
Enhanced TestClient support within VS 2008 SP1
New Hosting Wizard in VS 2008 SP1 for WCF Service Projects
Improved debugging support in partial trust scenarios

VB and C# Improvements

The VB and C# teams have also added some nice improvements to VS 2008 SP1:

Visual Basic

You can now add "XML to Schema" items to Visual Basic projects. On adding these project items a wizard will open that allows you to create a XSD schema set from a variety of XML sources. This schema set is then added to the project and it enables VB XML intellisense. This support was previously available as a web download - you can learn more about it here.

A XSD browser is also now included with VS 2008 SP1 and allows you to browse XSD schema sets. With the final SP1 release, developers will be able to right-click on XML element names (either in XML properties or XML literals) in the VB code editor and select “Go To XML Schema Definition” - this will open the XSD browser and display the schema set (and select the current element) for the VB project.

The C# code editor now identifies and displays red squiggle errors for many semantic code issues that previously required an explicit compilation to identify. For example, if you try to declare and use an unknown type in the C# code-editor today you won't see a compile error until you do a build. Now with SP1 you'll see live red squiggle errors immediately (no explicit compile required):

The debugger in VS 2008 SP1 has also been improved to provide more debugging support for evaluating LINQ expressions and viewing results at debug time:

LINQ enabled data sources now have a "Results View" node show up within the debugger watch window. Expanding this node will evaluate a LINQ expression and allow you to examine the materialized objects it returns:

Team Foundation Server Improvements

TFS 2008 SP1 includes a ton of improvements. Please read Brian Harry's Team Foundation Server 2008 SP1 Preview blog post for more details.

Summary

.NET 3.5 SP1 and VS 2008 SP1 provide a bunch of bug fixes, performance improvements, and additional feature enhancements that make building all types of .NET applications better. It will be a fully compatible service pack release.

We plan to ship the final release of both .NET 3.5 SP1 and VS 2008 SP1 this summer as free updates. You can download and use the beta now here.

Hope this helps,

Scott