Welcome to Metadata Island.  It’s a beautiful place.  Rich in resources that represent the hard work of application designers, business analysts and their customers.  Those very long specification meetings.  Countless missed meals typing up specifications.  Yes we have all contributed to the paradise repository called, Metadata Island.  Not to mention this vast metadata resource that sits dormant which companies paid tens of thousands of dollars to create.  If you were to get in your boat, the lone guy managing the metadata can be heard on the beaches waving his arms and crying out, “Hey!! I’m over here!”

The Problem

Bottom line; the once thought out and complete metadata never gets off the island after it arrives.  Current development tools are not set up to take advantage of developer metadata during the form or code generation processes.  Anyone ever used Microsoft Access?  Since Access 1.0, the program utilizes the developers metadata stored in the table object.  The form and report designers expose this metadata in a ComboBox allow the developer to drag a field to the design surface and Access will create the control and corresponding label.  It also has Mr. Wizard that creates forms and reports for you.

Why should our developers have to retype ToolTip text into form property grids?  Why should developers spend time entering data into property grids at all, especially the same data that is sitting on Metadata Island?  Beside being error prone, software companies are having to pay another person to enter this same data into yet another interface.

Why Did I Write This?

Before I get much further I must explain the context of this blog post.  First and foremost, I’m not a Microsoft finger pointer, not by a long shot.  We have fantastic tools and outstanding developers that I have deep respect for standing behind them.

I have been to two recent Microsoft events, MIX08 and the 2008 Microsoft MVP Summit.  I didn’t hear anything in any keynote, presentation or off-line conversation about any plans for Visual Studio or Visual Studio related tools to consume developer metadata.  I feel so strongly about this, so I wrote this blog post to raise the awareness of this need and to demonstrate how simple this is to accomplish.

I like Visual Studio 2008 and Expression Blend 2 and 2.5.  I like that I can open a designer and the tool creates classes for me.  Someone worked real hard to deliver that tool.  Where I get disappointed is when I have a great tool that I can’t use because it can’t consume my metadata.

For example the LINQ to SQL and SQLMetal tools don’t currently add XML comments to my classes or add my attributes to my properties.  But this would be easy to accomplish.

Currently there is no way to use the tools and have them populate a control’s properties based on my metadata as the control is being dragged to the design surface.  But this would be easy to accomplish.

Video Demonstrations

Please watch the two below videos.  The first one demonstrates a program I wrote that uses metadata to generate WPF forms in milliseconds.  It can also generate individual controls  The second is a short video on the program and how simple it was to write.

When I made the videos, this was using the Alpha One version.  Since then I have updated it after getting suggestions.  The version in the video works great but has been updated and now looks like the version at the bottom of this post.

The video links require Microsoft Silverlight 1.0. If you do not have it, you will be prompted to install it when you click one of the links. After the short installation is completed, close the browser window that you did the install in and re-click the video you want to watch. You can also download it here. Windows XP or Vista required.

Metadata Form Generation Video

Metadata Form Generation How I Did It Video

The Solution

We need bridges from our tools to Metadata Island.  Bridges is such a friendly and happy word.  The phrase, “bridge building or building bridges” is normally used in the context of good, of creating relationships or joining separate objects.

After watching the first video, no one can now say, WPF is not RAD capable.  In fact this simple tool is way faster than the great Winforms designer.  I spent a days time thinking the tool out, writing and testing it.

I have been thinking about metadata and code generation since I wrote the Visual Studio 2008 Designers and Code Generators; You Have Overlooked (…) blog entry.

I have come up with two bridge building methods I think would work.  Of course there are much smarter architects and developers working on tools than me, so maybe they would have a better solution that what I’m proposing here.  I’m just praying the ball gets rolling in time for the next release of Visual Studio or possibly a service pack to Visual Studio 2008.

Solution A:  Bridge Provider Model

This would be the simplest solution to implement and one that completely decouples the tools from the developers.

In each Visual Studio Solution the developer would place a .dll in the MetadataProvider directory of the solution that was decorated with the required attributes.

When Visual Studio opens the solution, it looks for it, similar to the way it currently does for Visualizer .dlls.

Here is the workflow.  When LINQ to SQL or SQLMetal needs to write a class or property object they pass the class name and property name and the MetadataProvider either returns a string or nothing.  If nothing, then the tool simply uses its default implementation like it does today.  If a string is returned, then that string is used for that object.  This would allow developers to create the property with XML comments, attributes and property getter and setter code that they want to use.  This way the code the the LINQ to SQL designer generates now looks exactly like code I would have hand coded.  Now everyone is happy, very happy.  How easy would this be to code into the current tools?

If the developer wanted to generate a form, they would select a business object class that would be used to populate a Data Grid like my program and then generate the code.  So in this case, Visual Studio would be interacting with the .dll in the MetadataProvider directory twice.  Once to fill up the grid and once when each object is created.  Again, very simple workflow and almost zero impact on the current tools.

Advantages

The major advantage to this solution is that it completely decouples the tools from the solution.  The tools do not have to be concerned about metadata management.  Just call the provider and use what it returns.

Solution B:  Metadata Model

This solution would require that a metadata model be established and then developers could populate.  This model would be consumed by the tools during object construction.

This model would require that the solution expose templates that could be modified so that the constructed classes, properties and controls be generated exactly if a developer had hand coded them.

Program

I have receieved a few emails about the program so I’ll give the overview.

I used the Infragistics xamDataGrid in the above application for very easy editing of the individual metadata objects. 

Most of the columns are editable.  The control type column is a ComboBox and the two button columns allow the creation of the control by clicking the button to copy the control to the clipboard as in the demo video or allow the control to be created by dragging the button to a Visual Studio or Blend XAML editor and the control is created there.

You can see I’ve also have put my Code Generator here also.  I’ll post some more videos soon on this entire application and demonstrate how RAD WPF development can be.

Close

My program is not a templated solution.  It’s coded to generate code they way I would write it.  This makes my program very useful to me and anyone that subscribes to my methods and Core library that I have written.  We also have a super clean metadata store for our applicaiton generation.

Until the tools catch up, I hope this encourages you to start mining your own rich metadata stores and bringing that well thought out data into your development cycles.

Have a great day and thank you!

Just a grain of sand on the worlds beaches.

I’ve been trying to utilize the Server Explorer in Visual Studio 2008 for my SQL Server programming tasks like table maintenance and stored procedure authoring.  However this new workflow is not as productive as using SQL Server Management Studio.

Viewing Columns

A quick glance at the below images shows that Visual Studio 2008 does not display the same MUCH needed column information.  Yes, when you click on a column, the Visual Studio 2008 Properties Window displays this and more data.  However, when you click back to the code window or anywhere else, the Properties Window data changes.  Also, having to click on a column to see its information slows the developers workflow down.  Please display at least the same information that SSMS does for a column.

SQL Server Management Studio	Visual Studio 2008

Copying Column Name(s)

Another very missed piece of functionality is the ability to copy one or more column names from the above displayed list into either a stored procedure or code window.

In SSMS the developer can drag the Columns folder into a code window and all column names are copied into the code window separated by commas.  Visual Studio 2008 does not have this.

In SSMS the developer can drag the column name into a code window and the column name is copied into the code window.  Visual Studio 2008 does not have this.

This is an invaluable time saver and ensures accurate copying of column names into code or stored procedures.

Viewing Stored Procedure Declarations

A look at the two below images shows that Visual Studio 2008 does not display the same MUCH needed parameter information.  This functions that same way and has the same limitations at the above table columns.

SQL Server Management Studio	Visual Studio 2008

Help Get This Fixed

I have posted this problem on Microsoft Connect here: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=341791. 

Please rate this issue on Microsoft Connect so that it will get corrected. 

VS2005 had the same issue and I wish I would have known how to report problems like this long ago.

Close

I was going to write this up on the Visual Studio 2008 forums, but you can’t post images (which is a very good feature) so I wrote it up here where I could post the images and wrote a text only version that you can read here: http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=3281961&SiteID=1.

I do like the fact that many features have been moved into Visual Studio (STRONGLY wish SSMS could debug stored procedures) but if I’m being asked to alter my workflow, then I should at least have the same features that the other tool does.

Microsoft, please update Visual Studio 2008 with these features.

Have a great day and thank you!

Just a grain of sand on the worlds beaches.

On Saturday 17 May 2008, the Enterprise Developers Guild will have their spring Code Camp at the CPCC Central Campus located in Charlotte, NC.

Directions and registration is posted here: http://www.developersguild.org/Default.aspx?alias=www.developersguild.org/codecamp/2008/spring

Code Camps are very informative, free and fun.

Code Camp Tracks

• WPF Multi-Tier Business Application Track
• VS 2008 / SQL 2008 Labs Track
• Agile Track
• Presentation Track

I have updated the information on the WPF Multi-Tier Business Application Track that you can read here: http://karlshifflett.wordpress.com/2008/04/06/may2008codecamp/

See You At Code Camp!

Have a great day!

Just a grain of sand on the worlds beaches.

A few days ago in my blog post, Sample Series - Bench Marking Object Loading I showed bench mark times for several different methods of loading Business Entity Objects from a SQL Server database.  LINQ to SQL turned in the slowest times. 

I received comments and emails so I went back and wrote a real world application that did more than one test that is posted here, Sample Series - Bench Marking Object Loading Application II.  This application showed that LINQ to SQL is as faster or faster than other methods used to load objects.

However, I still needed to reconcile the results from the first bench mark test.  These numbers were not going to go away.

Josh Smith and I will be teaching the WPF Multi-Tier Business Application Track at the Enterprise Developers Guild Code Camp on 17 May 2008 and one of the sessions is on WPF Tools & Performance Testing.

Marlon Grech and I were emailing back and forth about how to find the hold up and he told me he uses Red Gate Software’s Ants Profiler.  So, yesterday I purchase Ants Profiler and got to work.

The Profiling

Using Ants Profiler, I ran two profile tests.  The first test I only ran the LoadLINQ method once.  This would give me a base line to compare the running of LoadLINQ multiple times.

The times are in seconds.  The longer run time in seconds is because the Ants Profiler is doing a lot of work to gather the information from the application and CLR classes that the application calls.

While the number of seconds to run the program under the profiler is longer than the one second run times we got in the initial blog post, the results are relative with respect to method run times.  The red bar graph indicates a relative run time of the method compared to other methods.

In the next two images, notice that LoadLINQ runs much faster on the second run.  Ants Profiler will enable us to find out why.

In the below two images the longer running code is easily found.  Look at the top line of code in each image.  This is the constructor for the DataContext. 

We can see that the very first time this is called it took 2.66.  When I profiled the application the second time, notice that the time to call the constructor twice was only 2.67.

Ants Profiler has shown us exactly which line of code was the initial bottleneck.

I used another feature of Ants Profiler to view the CLR method calls and execution times to determine what was happening within the constructor of the DataContext. 

The below image shows the method calls inside the DataContext constructor and that the DataContext.Init method was taking up almost all of the time.  Ants Profiler allows you to “drill into” that method and see what is going on under the covers.  Karl really likes this drilling business;  both Ants Profiler and Mole share this common feature of allowing developers to drill around very easily and inspect under the hood.

The below image is a profile of the DataContext.Init method.  (the reason for the time differences is that I captured these images on different runs of the profiler.)

Close

In case you’re wondering, I’m not a sales person or employee of Red Gate, I just love their products and support.  I’ve been a long time SQL Compare customer. 

Now I have Ants Profiler in my toolbox and love the fact that I can look under the hood and see what is going on in my applications.

Just a grain of sand on the worlds beaches.

This is the next sample in the Sample Applications Series. The purpose of the Sample Series is to provide concise code solutions for specific programming tasks. This sample provides a brief description of the problem, the solution and full source code.

After last nights blog post Sample Series - Bench Marking Object Loading I received a good number of questions on a WPF Disciples Google Group Discussion Thread.  If you didn’t get a chance to read that blog post, please look at it now as I won’t be repeating the background information.

I thought about all the comments, suggestions and possible “one time” object initiation that various software technologies pay the first time they are used.

I really want to get to the bottom for the initial delay that me and others got when using LINQ to build object collections.  Additionally I wanted to see what the bench mark would look like in a typical application.

When I was researching the loading of business entity objects from a database I ran across an awesome article on Code Project entitled, Dynamic Method IL Generator written by Code Project author Herb Randson.  I used the code from his article and translated into VB.NET and made just a few very minor adjustments and added a LINQ test to the mix for comparison.

New Bench Mark Test

Let me introduce you to the players in this bench mark.

NEW SQL Server Express Database

Included in the download is a NEW BenchMarkData SQL Server Express 2005 Database.  If you downloaded and set up the database from the previous sample, please remove that database and attached the new database supplied with the source download below. 

To run the tests in the sample download, you will need to have either SQL Server 2005 or SQL Server 2005 Express installed on your computer.  Attach the included database to either server and edit the app.config file and changed the connection string to match your system.  This database is ultra simple with one table at has 19,972 rows that I imported from the AdventureWorks database Person.Contacts table. 

This new database has an additional field and stored procedures for all CRUD operations.

NEW Bench Mark Loading Objects Sample Application

This new application is a Windows forms application that runs all the tests and displays the results in a DataGridView.  There are four sets of tests.  Each set of tests has 5 tests, except for the LINQ set which has 6 tests.  All CRUD operations are performed using stored procedures and concurrency checks are made using the SQL Server timestamp column in each row.  Each test has been optimized and correctly handles DBNull coming from the database and correctly set Nullable(Of Type) properties.

The below list describes the four sets of tests. 

• Manual - method loads the business objects by iterating a SQLDataReader and manually constructing the classes with optimized code.  In a real world application, this would require that a method be written for each business entity to load it.
• Reflection - method loads the business objects by iterating a SQLDataReader and using a cached listing of the target objects properties.  In a real world application, this requires only this code be called and a List of business objects will be returned.  What is more realistic is that a method will be created that wraps this code as I have done in this application.
• Dynamic - method loads the business objects by iterating a SQLDataReader and using some of the most wicked code I’ve seen a long time.  In his Code Project article Dynamic Method IL Generator the author lays out how to generate IL code at runtime and then call that code.  This method results in insanely fast loading of business objects.  In a real world application, this requires only this code be called and a List of business objects will be returned.  What is more realistic is that a method will be created that wraps this code as I have done in this application.
• LINQ - method utilizes code generated by Visual Studio 2008 and takes advantage of the stored procedures for CRUD operations.

The below list describes each of the five tests performed by the four above methods.

• Read - Update One Record Single Connection - this test simulates the retrieval of a single record, the changing of the record by a process and the updating of the record over a single connection to the database.  NOTE:  This is also the very first test in the set and you will notice that it records a longer execution duration than the next test.
• Read - Update One Record Two Connections - this test simulates a user loading a form with a single record, editing of the record and then updating the record over two separate connections to the database.
• Read 911 records - this test reads all records in the database where the last name starts with “a.”  911 is the total number of records returned.
• Read Insert and Delete - this test inserters a record, rereads that record and deletes that same record.
• Read and Update 19,972 records using same connection - this test simulates business processing with complex business layer calculations being applied to a set of data.  All the records are loaded into business objects, that collection of objects is iterated and each object has a field updated using a calculation and each individual record is updated back to the database.  The same database connection is used to retrieve the records and to write them back to the database.
• Read and Update 19,972 records using SUBMIT CHANGES same connection - this test is only performed by LINQ and is TestNumber 6.  I did this to show the difference between using a stored procedure and LINQ to update a large number of records in a batch.

Test Results

All of these tests were run against a production SQL Server in the middle of the day.  The client was a 2 Core Dual 2.4GHz with 2GB memory running Vista x32.

This test clearly shows that LINQ to SQL is just as fast or faster than other techniques for building business entity objects from a database query.

It is only in the Update department that LINQ to SQL turns in slower times.  The average time to retrieve 19,972 records, iterate through them and write individual updates back to the database was 16 seconds.  Pretty impressive.  LINQ using stored procedures took 24 seconds.  Not back either.  However, when I used the LINQ SubmitChanges command it took 1:28 seconds.

Comments

After showing this to others at my work, they looked at me and said, what is the conclusion?  Which technique should we go with?  We can generate all of the code for any of the techniques.  The leanest method is the ManualBuilder method.  It consistently turns in the second fastest time and does not require any caching of precompiled queries, IL execution code or reflection property lists.  So for my next few projects, I’m sticking with “old school” DataReaders and optimized .NET object loading.

Choosing the ManualBuilder does not prevent me from using LINQ within the application once the object are loaded.  For object loading, I prefer simpler business objects with less overhead and less dependencies.

Close

Your application requirements and development resources will dictate your choices.  Making an informed decision that meets your needs is what this post is about.

I hope this sample gets you to investigate the various options you have for loading business entity objects from a database.

Source Code: After downloading the source code you MUST change the file extension from .zip.DOC to .zip. This is a requirement of WordPress.com.

The source includes a Visual Studio 2008 solution and SQL Server 2005 database for testing.  At your option, you could very easily download the code and point it to any of your current databases and run tests against them.

Download Source and SQL Database 779KB

Hope you can learn just a little bit more about .NET from this article and the Sample Series.

Just a grain of sand on the worlds beaches.

              Time to create 19,972 business objects

This is the next sample in the Sample Applications Series. The purpose of the Sample Series is to provide concise code solutions for specific programming tasks. This sample provides a brief description of the problem, the solution and full source code.

Josh Smith and I are very busy preparing for the Charlotte, NC May 17th Code Camp as we will be teaching the WPF Multi-Tier Business Application Track.  This will be a very exciting day for WPF and LOB and hope to see you there! 

I am also writing the 4th installment of the WPF Business Application Series and hope to deliver the entire application soon and then continue to write articles against it.

During this preparation the topic of loading Business Entity Objects from the database keesp coming up.  Each time I reflect on that topic these questions immediately come to mind:

• Should I stick with the time tested and super fast SQLDataReader?
• Should I move to LINQ to SQL?
• Should I load objects using reflection?
• Should I write object loader code for each object?
• When I add Silverlight into the mix will that effect my above choice?

I did a good bit of research and will present the results. 

When researching I ran across an awesome article on Code Project entitled, Dynamic Method IL Generator written by Code Project author Herb Randson.  I used the code from his article and translated into VB.NET and made just a few very minor adjustments and added a LINQ test to the mix for comparison.

I hope this blog post encourages you to perform your own testing before choosing Door #1 or Door #2.

Introduction

I wanted the test to simulate a real world database request that involved selecting almost 20,000 rows and building a generic collection of objects to process.  Not that any of us would be selecting all our customers and stuffing them into a ComboBox, but that the test would simulate building 20,000 instances of a business object class that would be processed and the results written back to the database.  For this bench mark, I’m not writing results back to the database.  Business applications I write can easily generate this type and volume of traffic when performing business processing so I elected to use this as my test.  This type of request is also commonly used to preprocess data for a report.

Users could care less about bench marks.  They judge our applications based on how it appears to run on their desktop in their unique environment.  How long does a form take to appear?  When the customer form opens and the users clicks on the History tab, is there a delay before the 500 records appear in the grid?  When the user runs a report that requires preprocessing, how long does it take?  How long does batch processing take?  Is the UI frozen while processing?

When I design applications my first priority is delivering documented, maintainable code, my second priority is performance.

As architects we are not only concerned with how responsive and quick our UI’s are, but must take into consideration processing time on our servers.  If we have clients that are connected over the web, almost all processing will take place on the web or application server.  It is imperative that server deployed code runs as fast and efficient as possible. 

Bench Mark Testing

Let me introduce you to the players in this bench mark.

SQL Server Express Database

Included in the download is the BenchMarkData SQL Server Express 2005 Database.  To run the tests in the sample download, you will need to have either SQL Server 2005 or SQL Server 2005 Express installed on your computer.  Attach the included database to either server and edit the app.config file and changed the connection string to match your system.  This database is ultra simple with one table at has 19,972 rows that I imported from the AdventureWorks database Person.Contacts table.

SQL Server Profiler

I used the SQL Server Profiler to record bench marks from the SQL Server during processing and have included the results below.

Bench Mark Loading Objects Sample Application

This is a very simple console application that demonstrates four different methods of loading business objects.  I tried to make each test as far as possible.  Each test will open and close the connection to the database.  Each test has been optimized and correctly handles DBNull coming from the database and correctly set Nullable(Of Type) properties.

Below is the list of the four methods.  Each method will build a generic List(Of Contact) or List(Of ConactEntity).  LINQ builds the Contact class and the other methods build the ConactEntity class.  I did this so that each technique would build a class like it would in a real world application.

• Manual - the LoadManual method loads the business objects by iterating a SQLDataReader and manually constructing the classes with optimized code.  In a real world application, this would require that a method be written for each business entity to load it.
• Reflection - the LoadReflection method loads the business objects by iterating a SQLDataReader and using a cached listing of the target objects properties.  In a real world application, this requires only this code be called and a List of business objects will be returned.  What is more realistic is that a method will be created that wraps this code.
• Dynamic - the LoadDynamic method loads the business objects by iterating a SQLDataReader and using some of the most wicked code I’ve seen a long time.  In his Code Project article Dynamic Method IL Generator the author lays out how to generate IL code at runtime and then call that code.  This method results in insanely fast loading of business objects.  This code reminds me of the old ADO GetRows method we used on early ASP web sites.  This too was insanely fast compared to any other method of reading data from SQL Server.
• LINQ - the LoadLINQ method utilizes code generated by Visual Studio 2008, creates a DataContext and with a single line of code, transforms the query results into a List(Of Contact).

Test Results

This test was run on my home system, an Intel Core2 Quad 2.4 GHz with 4 GB main memory, 4 MB L2 cache and a single hardware RAID 1 SATA disk array.  This configuration would be common among server class machines except large servers would have more memory and dual SCSI RAID arrays.

From the above image, the stats that stick out are the low and high results (lower time is better).  The LINQ loader took just over one second.  The Dynamic loader to .063 seconds which is insanely fast.  The other two were longer but still much faster than the LINQ solution.  In a UI, time is perception.  Add in any other latencies, and the user is now waiting.

In the below image, we can see how each of the above techniques interacted with the SQL Server while iterating the SQLDataReader.  The duration is measured in microseconds.

All of the techniques are very efficient in terms of working with the SQL Server.  Each time I ran this, I got different results with respect to CPU, but he Reads and Duration columns remained the same.  To be honest, I do not know why the Reflection method Duration was so long compared to the others or why the LINQ to SQL method was 2.5 times slower than the Manual of Dynamic methods.  The SQL queries were the same except for the way the LINQ query used fully qualified column names.

Real World Development

I strongly recommend that you read Herb’s article and the comments other developers posted.  Herb’s article is about “how” something can be accomplished and he presents several solutions for the accomplishing the same programming task.  I simply added a LINQ to SQL solution to the mix and presented these here for your inspection and review.

I don’t know about you, but I like to adopt new technologies slowly.  Give myself and others around me time to prove them from a security, development, performance, reliability, scalability, toolset availability, toolset maturity and maintenance perspectives.

From a code generation standpoint, all four solutions can be code generated.  I don’t recommend using the Visual Studio ORM Designer or SQLMetal tools at this time because they do not provide any ability for developers to place either XML comments or attributes on their class properties.  You can use the XML Map Files to make this happen but have to pay additional performance hits for this ability.  The lack of support for the developers meta data in the ORM tools has caused me to write all my own code generation tools.  I hope this will be corrected in future releases of the ORM or other Visual Studio RAD tool offerings.  While at the April 2008 MVP Summit I did speak with several teams at Microsoft about this current limitation of meta data awareness.

I have a blog post that raises some questions on ORM tools consuming meta data that you can read here.

The time tested Manual technique is super fast but requires the most code.  If this code is generated then this becomes a non-issue.  The Reflection and Dynamic methods offer very simple and small footprint for great functionality and performance.  The Dynamic method has a draw back in that you can’t debug the generate IL code using the standard debugging techniques most developers are comfortable with.

I don’t think I’m ready to jump on the LINQ to SQL bandwagon for business object loading just yet.  However, that does not mean that I can’t load my objects using the other techniques and then use LINQ to work with them.

Close

Your application requirements and development resources will dictate your choices.  Making an informed decision that meets your needs is what this post is about.

I hope this sample gets you to investigate the various options you have for loading business entity objects from a database.

Source Code: After downloading the source code you MUST change the file extension from .zip.DOC to .zip. This is a requirement of WordPress.com.

The source includes a Visual Studio 2008 solution and SQL Server 2005 database for testing.  At your option, you could very easily download the code and point it to any of your current databases and run tests against them.

Download Source 951 KB

Hope you can learn just a little bit more about .NET from this article and the Sample Series.

Just a grain of sand on the worlds beaches.

Glen Gordon has posted the MSDN webcast geekSpeak we did on Mole.

You can view the webcast and links to resources mentioned in the webcast here: Mole geekSpeak.

Enjoy Mole!

Just a grain of sand on the worlds beaches.

On April 23rd 2008 I did a MSDN geekSpeak web cast with Microsoft Developer Evangelists Glen Gordon and Brian Hitney.  The great thing about geekSpeaks is that the attendees can ask questions during the web cast and get the answers they need.  My great friend and Microsoft MVP Chris Love asked if Mole could be used to view ViewState.  We were getting short on time so Glen suggested we take this question offline.

I have put together a short video that covers using Mole to view ViewState.  Currently Mole does not decrypt the __VIEWSTATE object.  I might do this for Mole v5 if some ASP.NET developers need this.  Please leave a comment and let me know if you would like this feature.

For now, Mole does provide access to each individual control’s ViewState which includes the StateBag for the page.  The below video demonstrates using Mole in each of these scenarios.

The video links require Microsoft Silverlight 1.0. If you do not have it, you will be prompted to install it when you click one of the links. After the short installation is completed, close the browser window that you did the install in and re-click the video you want to watch. You can also download it here. Windows XP or Vista required.

Mole v4 Viewing ASP.NET ViewState

Enjoy Mole!

Just a grain of sand on the worlds beaches.

This is the next sample in the WPF Sample Applications Series. The purpose of the Sample Series is to provide concise code solutions for specific programming tasks. This sample provides a brief description of the problem, the solution and full source code.

I have been working on several WPF applications in parallel for some time now.  All of my business applications have one main window.  These applications also have the ability to display a modal dialog box when required.  For example displaying the About Dialog Box or to allow the user to interact with the currently displayed task in some modal way, like looking up a value in a related table or editing values in related tables.  Very common tasks in a business application.

As I was testing my application I noticed a very strange behavior in the application for the first time.  Code was running in the main window, but the modal window was the window raising the RoutedEvent.  I had always read and been taught that RoutedEvents tunnel and bubble in the current window and not other windows.  That is true, except when the RoutedEventHandler is set up using EventManager.RegisterClassHandler. 

If WPF RoutedEvents are new to you or you feel you need a short review, please check out the RoutedEvent Viewer on my blog.  It provides an interactive Routed Event Viewer application for understanding WPF Routed Events.  An understanding of RoutedEvents and the concept of events being handled is important for this short demonstration.  Additionally I recommend reading the Routed Events Overview in the MSDN documentation.

Let’s get into this.

Test Bench UI

The UI is very straightforward.  In the above image, I have opened the included sample program and clicked the Click Me button. 

When the two buttons are clicked, the code handlers respond by displaying a message.  In the case of the New Window button being clicked, a new instance of Window2 will be created and displayed.  The CheckBox when Checked, will mark any events handled by Class Handler as Handled.

The Message: #, provides a simple way of viewing the order in which the event handlers were called by WPF.  As you use this Test Bench UI, keep track of the Message #’s to understand what is going on.

In the above image, the New Window button was clicked.  You can see the order in which the handlers were called and a new instance of Window2 was created and displayed.

Now things get VERY interesting.  The Window 2 Button Clicked button, was clicked and handled in Window1.  Notice Message 6.  This is what caught me off guard and the purpose of this blog post.  The Class handler is assigned to handle all ClickEvents owned by the Button class.  Have a look at the below code EventManager.RegisterClassHandler line.  This line of code allows the Window1 class to monitor Button.ClickEvents in its own window and other windows in the application.  This is a great feature, unless you don’t expect it to work this way.

Private Sub Window1_Loaded(ByVal sender As Object, _
            ByVal e As System.Windows.RoutedEventArgs) Handles Me.Loaded

    ‘best fully understand WPF when using this
    EventManager.RegisterClassHandler(GetType(Button), _
        Button.ClickEvent, New RoutedEventHandler(AddressOf WatchOutHandler))

    ‘notice that the CheckBox’s Click event will be captured with
    ‘this event handler because the CheckBox gets its ClickEvent
    ‘from ButtonBase and not the CheckBox class.
    Me.AddHandler(Button.ClickEvent, _
        New RoutedEventHandler(AddressOf WindowSafeHandler))

End Sub

The above Me.AddHandler statement goes along with the above image.  The comments above the Me.AddHandler statement give the big picture.  Notice that after clicking the CheckBox, Message 7 is displayed for the Window Handler, but not the Class Handler.  Many WPF programmers like to handler RoutedEvents at a parent container level since it just makes sense to do this.  This little application teaches us, to be on the look out for other controls that derive from the same base class that can raise the event we are watching for.  So as programmers, we should not just assume that if we are listening for a Button.ClickEvent that a real button control actually raised the event.  In the above case, it was a CheckBox control that actually raised the event.

In the above image the Click Me button was clicked, but only the Class Handler actually handled the event since it was marked as handled and the other event handlers down stream were not set up to handle, previously handled events.  This is where the Routed Event Viewer application really shines by allowing you to experiment and fully understand the concept of Handled RoutedEvents.

Window1 XAML

<Window
    x:Class=”Window1″
    xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation”
    xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”
    Title=”Window1″ Height=”300″ Width=”500″>
    <StackPanel Orientation=”Vertical”>
        <Button Margin=”10″ Content=”Click Me”
                ToolTip=”Click to display message below”
                VerticalAlignment=”Top”
                Click=”Button_Click_1″/>

        <Button Margin=”10″ Content=”New Window”
                ToolTip=”Click to display a new window”
                VerticalAlignment=”Top”
                Click=”Button_Click” />

        <CheckBox Margin=”10″
                  x:Name=”chkHandleWatchOutEvents”
                  VerticalAlignment=”Top”
                  Content=”Handle Watch Out Event” />

        <TextBlock Margin=”10″ VerticalAlignment=”Top”
                   x:Name=”tbWatchOutMessages” />

        <TextBlock Margin=”10″ VerticalAlignment=”Top”
                   x:Name=”tbSafeMessages” />

        <TextBlock Margin=”10″ VerticalAlignment=”Top”
                   x:Name=”tbHandlerMessages” />

    </StackPanel>
</Window>

Window1 XAML VB

Class Window1

    Private _intMessageNumber As Integer

    Private Sub WatchOutHandler(ByVal sender As Object, ByVal e As RoutedEventArgs)

        _intMessageNumber += 1
        If TypeOf e.OriginalSource Is CheckBox Then
            ‘this line of code will never run, but here to prove the point
            Me.tbSafeMessages.Text = String.Format( _
              “Class Handler: CheckBox clicked at {0}, Message: {1}”, _
              Now.ToLongTimeString, _intMessageNumber.ToString)
        Else
            Me.tbWatchOutMessages.Text = String.Format( _
              “Class Handler: {0} was clicked at {1}, Message: {2}”, _
              CType(e.OriginalSource, Button).Content.ToString, _
              Now.ToLongTimeString, _intMessageNumber.ToString)
        End If

        e.Handled = Me.chkHandleWatchOutEvents.IsChecked.Value

    End Sub

    Private Sub WindowSafeHandler(ByVal sender As Object, ByVal e As RoutedEventArgs)

        _intMessageNumber += 1
        If TypeOf e.OriginalSource Is CheckBox Then
            Me.tbSafeMessages.Text = String.Format( _
              “Window Handler: CheckBox clicked at {0}, Message: {1}”, _
              Now.ToLongTimeString, _intMessageNumber.ToString)
        Else
            Me.tbSafeMessages.Text = String.Format( _
              “Window Handler: {0} was clicked at {1}, Message: {2}”, _
              CType(e.OriginalSource, Button).Content.ToString, _
              Now.ToLongTimeString, _intMessageNumber.ToString)
        End If

    End Sub

    Private Sub Window1_Loaded(ByVal sender As Object, _
                ByVal e As System.Windows.RoutedEventArgs) Handles Me.Loaded

        ‘best fully understand WPF when using this
        EventManager.RegisterClassHandler(GetType(Button), _
            Button.ClickEvent, New RoutedEventHandler(AddressOf WatchOutHandler))

        ‘notice that the CheckBox’s Click event will be captured with
        ‘this event handler because the CheckBox gets its ClickEvent
        ‘from ButtonBase and not the CheckBox class.
        Me.AddHandler(Button.ClickEvent, _
            New RoutedEventHandler(AddressOf WindowSafeHandler))

    End Sub

    Private Sub Button_Click(ByVal sender As System.Object, _
                ByVal e As System.Windows.RoutedEventArgs)

        Dim obj As New Window2
        obj.Show()

    End Sub

    Private Sub Button_Click_1(ByVal sender As System.Object, _
                ByVal e As System.Windows.RoutedEventArgs)

        _intMessageNumber += 1
        Me.tbHandlerMessages.Text = String.Format( _
          “Button Handler: {0} was clicked at {1}, Message: {2}”, _
          CType(e.OriginalSource, Button).Content.ToString, Now.ToLongTimeString, _
          _intMessageNumber.ToString)

    End Sub
End Class

Close

As WPF developers we have 4 ways of adding RoutedEvent Handlers to our applications and each was demonstrated in this Test Bench Sample.

1. In XAML
2. At the class level
3. At the container level
4. At the control level

Understanding how and when each event handler will be called is vital to writing a WPF application. WPF provides the flexibility we as developers require. However, it’s incumbent upon developers to understand and harness that intrinsic power so that we can deliver stable, super cool applications.

Source Code: After downloading the source code you MUST change the file extension from .zip.DOC to .zip. This is a requirement of WordPress.com.

Download Source Code 17KB

Hope you can learn just a little bit more about WPF from this article and the Sample Series.

Just a grain of sand on the worlds beaches.

Back in January 2008, I was asked by Glen Gordon, our fantastic Microsoft Developer Evangelist for the Southeast if I would like to be a guest on geekSpeak and do a MSDN Webcast about Mole.

My reaction; honored and thrilled.

Wednesday 23 April 2008 at 3:00pm EST, Mole will be live on geekSpeak! 

You can register for the Mole geekSpeak Webcast here: http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032374735&Culture=en-US.

geekSpeaks are free Webcasts conducted over Microsoft LiveMeeting, which provides the attendee’s the ability to ask questions and get them answered during the Webcast.

I have bookmarked several upcoming geekSpeaks myself. You can view all upcoming geekSpeak Webcasts here: http://www.microsoft.com/events/series/geekspeak.aspx?tab=webcasts&id=liveall.

Looking forward to your questions about Mole on geekSpeak!

Have a great day!

Just a grain of sand on the worlds beaches.

I’ve spent the last week at the Microsoft 2008 MVP Summit.  It was a fantastic learning and sharing experience.  Microsoft took excellent care of us the entire week.  Spending time with other MVP’s and meeting my friends from all over the globe was priceless.

I also spent a good deal of time out of the classroom with members from four different teams.  It was during these times that we had some very healthy,  animated discussions on topics that we are both passionate about.  In the end, we shook hands and parted with deep respect looking forward to our next discussion.

I don’t know about the readers of my blog, but I like passionate discussions.  I like to listen to other developers explain their approaches to problem solving and their solutions.  After the flamethrowers are put back in the armory, I then like time to think about why the other side was presenting their point of view.  Many times the “why” never comes out in the dialog.  That developers life experience normally does not get presented as part of a discussion on the .NET Framework.  So I like to marinade on the facts and work backwards to try to get inside the other persons world to understand why they want to adopt this solution.  This is known as inductive study.  By asking questions of the facts presented, you can many times determine context and then come to an understanding or appreciation of the process that lead to their solution.

The Scenario

I spent several hours talking about the concept of business objects throwing exceptions in the property setters if the value did not pass the validation rules for that property.  If you have read my latest article, WPF Business Application Series Part Three you know that I strongly favor using the IDataErrorInfo interface for business object validation broken rule notification as opposed to throwing exceptions from property setters.

I thought long and hard about the discussions and came to this conclusion, you either favor the Fort Knox or Shopping Cart approach to business object validation.  One is a controlling paradigm the other a trusting relationship.  One takes a very granular approach the other a holistic approach to business object validation.

In discussions, business object validation is normally centered around UI binding scenarios.  This is only one scenario and I would strongly argue that more validation takes place in the business layer processing of objects than direct UI binding.  So proponents of throwing exceptions as a form of broken validation rule notification, must take a step back and look at this notificaiton business from a much higher perspective than just a UI binding scenario.

I realize that there are two schools of thought here.  One states, an object should never be in a invalid state.  The other, allows for temporary broken rules, but verifies object state prior to any actual use of the invalid object.  This notion of absolute control or pure objects is an illusion that does not play well with real world business objects and today’s computer users.  Of course application scope and requirements must dictate how and when business rules are enforced.  As an architect I don’t want the platform to force me to write objects in a certain way just to utilize it, especially when there is no payback and only complicates development and code maintenance.  Framework developers are not responsible for my data, me and my developers are.

WPF is one example of permitting developers to choose a broken validation rule notification technique that suits their application.  It allows developers to use exceptions or IDataErrorInfo for broken validation rule notification to the class binding to it.

Fort Knox	Shopping Cart
Throws exceptions when a validation rule is violated in a property setter.  Guards each property setter with a machine gun, sounding general quarters any time a value does not pass all the rules.  The Fort Knox approach to shopping, would have the store manager walking with you.  Each time you add an item to the cart, the manager would be running your credit card and possibly forcing you to submit to a polygraph.  Your every movement would be recorded on video and watched real time by a security guard, waiting like a cat ready to pounce on its prey at the first sign of weakness. This approach makes validation rules that are dependent on two or more properties, very difficult to implement since the order that the property must be set can now become a factor when trying to avoid an exception being thrown.	Follows a passive validation model that maintains a listing of each broken rule in the object and provides a means to query an individual property or the entire object for its validation status.    The Shopping Cart approach to object validation allows the user to shop the store, place items in the cart and then check out.  In the above example the shopper can get feedback on items and their total as they shop, but are not prevented from adding the item to the cart. This approach only cares about the checkout process and not the act of placing an item in the cart as opposed to the Fort Knox approach that won’t let you place a second item in the cart until the first item is paid for.

Fort Knox Business Layer Problem

The Fort Knox approach can kill business layer code like LINQ queries that attempt to populate that object and the data is invalid for one reason or another.  I’ll use two examples to illustrate this problem.

If you have validation rules that are dependent on one or more property values, developers will now have to write code to set property values in a certain order to avoid an exception being thrown.  This is a crazy requirement and is contrary all .NET class design documentation.  Can you imaging having to wrap EVERY piece of code that sets a property with a try catch block.  Again, what about LINQ queries that are tying to populate objects and unnecessary exceptions are being thrown by property setters.  This makes writing maintainable code MUCH harder and with ZERO payback.  When code is changed over time, a field added, we have to factor in usless exception handling and be cognasent of the order in which property setters are called or change.

I was speaking to one of the team PM’s on Friday.  When I asked him about a certain issue his response was, “stuff happens.”  I agree with him, stuff does happen.  The Fort Knox approach does not allow for (actually tries to prevent) temporary invalid object state.  This all comes full circle to the Fort Knox developers that some how get this false sense of security from exceptions being thrown, as opposed to developers checking an object’s Error property or other properties that expose object state and collections of broken validation rules.  Any developer can read and learn this programming pattern from Rockford Lhotka’s CSLA, Microsoft’s Validation Application Block or Karl Shifflett’s Lightweight Business Object Declarative Programming.

Using the Fort Knox approach does not guarentee a valid object either.  The developer could go through the pains of catching exceptions, but the object is still invalid if it does not pass all the validation rules.

In reality both approaches do allow for tracking broken rules since the developer is free to write any code in each setter and then throw the required exception.  My biggest problem is having to code around what should be a reporting problem.  However, this still means that all business layer processing code would have to be on the look out for a broken validation rule exception each time a setter was accessed as opposed to business layer code checking the object validation state as a whole, prior to persisting or moving an object to another tier.

Close

I welcome your feedback on this topic.  Please comment on your approach to business object broken validation rule notification.  Good discussions lead to better programming techniques and educate all who participate.

Have a great day!

Just a grain of sand on the worlds beaches.

I have been working on a cool Silverlight application and started to run into strange behaviors.  So I stopped and wrote a demo application to show the issues I found.  A small demo also makes it very easy to demonstrate the problems.

Below are two videos that clearly demonstrate the issues.  Please watch the videos to fully understand the problem and the implication of these issues.

Bug Demonstration Videos

The video link require Microsoft Silverlight 1.0. If you do not have it, you will be prompted to install it when you click one of the links. After the short installation is completed, close the browser window that you did the install in and re-click the video you want to watch. You can also download Silverlight here. Windows XP or Vista required.

Silverlight 2 LostFocus Bugs Video 

Silverlight 2 Data Binding Bugs Video 

LostFocus Bugs

The above video covers the LostFocus bugs in great detail. (please watch it)

• Bug:  Wrong control reported in LostFocus RoutedEvent Source when event handler is declared in XAML or by using AddHandler control, delegate ( ex: AddHandler txtName.LostFocus, AddressOf TextBox_LostFocus ).
• Works:  Correct control reported in LostFocus RoutedEvent Source when event handler is declare in code using the Handles syntax.  ( Ex: Handles txtName.LostFocus )
• Bug:  Button control does not honor the IsTabStop property when set to False.  Button will still receive focus even though the Button property IsTabStop=False.
• Works:  GotFocus RoutedEvent Source is correct regardless of where the event handler is set up.  Event handler can be set using Handles, Addhandler, XAML on the control or XAML in a parent container.

Data Binding Bugs

The above video covers the Data Binding bugs in great detail. (please watch it)

• Bug:  First time the TextBoxes are tabbed through in a form and their values are not null, the INotifyPropertyChanged event is raised, even if no changes are made to the TextBox.  On the second and subsequent passes through the form, the event is not raised unless the property is actually changed by the user changing the TextBox.  This does not happen in WPF.
• Bug:  TextBox controls are not updated even if a converter is used in the binding statement.  In WPF, if a converter is used in a binding statement, the convert is run after the data binding takes place and the UI is updated.  This does not happen in Silverlight but should.
• Bug:  If a System.FormatException is thrown when the data binding pipeline attempts to set a property, the exception is caught (but never reported) and then the data binding pipeline sets the property to its default value.  This should not happen.  If a System.FormatException occurs, that should stop all further process and the exception should be reported like WPF. 

Demo Application

Source Code:  After downloading the source code you MUST change the file extension from .zip.DOC to .zip. This is a requirement of WordPress.com.

Download Source Code 612 KB

Close

I have reported the above issues in the Silverlight.net forum: http://silverlight.net/forums/p/14035/45963.aspx#45963

I really love Silverlight so far.  I have moved the Declarative Programming I did in Part 3 of the Business Application Series into Silverlight with almost no changes and no loss of functionality.  Full business object validation and case correcting in Silverlight without code just like in WPF.  Great stuff.

Have a great day!

Just a grain of sand on the worlds beaches.

This is the next sample in the WPF Sample Applications Series. The purpose of the Sample Series is to provide concise code solutions for specific programming tasks. This sample provides a brief description of the problem, the solution and full source code.

I’ve been working on the WPF Business Application Series and wanted to add Windows style task switching to my MDI applications.  Task switching is familiar to Windows users and can help them find a window when they have several open at once.  Also this type of feature “shows” well in demonstrations.

From the above image, you can see that three MDI forms were opened up and then the user opened the task switching dialog by pressing CTRL+TAB.  The user can then continue to cycle through the open forms by pressing CTRL+TAB.  The user can also select a form by clicking the name of the form with the mouse.

Once a form is opened, you can RIGHT CLICK  on the form and select Close Tab from the context menu to close the form.

UI Demonstration Video

The video link require Microsoft Silverlight 1.0. If you do not have it, you will be prompted to install it when you click one of the links. After the short installation is completed, close the browser window that you did the install in and re-click the video you want to watch. You can also download Silverlight here. Windows XP or Vista required.

WPF MDI Task Switching Video 

Program Flow

When the application is started up, the menu is loaded from data.  In this demo application, it is loaded from strings.  In a real world application, the menu data will come from a database, with menu options selected based on the users security content.

When a menu item is clicked, the window OnPetMenuClick event handler dynamically loads the required UserControl into a TabItem that is then loaded into the TabControl and displayed to the user.

The user then decides to use the task switching feature and presses the CTRL+TAB keystroke combination.  This is trapped by the window PreviewKeyDown event handler and the task switching UserControl is brought into view.  When this happens, focus is also moved to the task switching UserControl and is trapped within the control until it closes.  The user can use CTRL+TAB to cycle through their forms, find the one they want and select it.  After selecting the form, the task switcher closes and they are brought to the form they selected.

Program Code

<DockPanel>
    <Border DockPanel.Dock=”Top”>
        <Grid>

            <TabControl x:Name=”tcOpenForms” SelectedIndex=”0″
                TabStripPlacement=”Bottom” />

            <local:TaskSwitcherControl x:Name=”ucTaskSwitcherControl”
                HorizontalAlignment=”Center” VerticalAlignment=”Center”
                Visibility=”Collapsed”>

                <local:TaskSwitcherControl.BitmapEffect>
                    <OuterGlowBitmapEffect GlowSize=”8″