.NET Stuff - Thomas Waldron

New features in Quick Objects 3.x

twaldron — Mon, 10 Mar 2008 18:24:00 GMT

The latest version of Quick Objects includes introduces some nice features, increasing its appeal for both enterprise and small-shop development. The core framework now supports bulk delete and update operations, previously only possible by dropping down to stored procs or custom SQL. Below is an example of the BulkDelete functionality:

   1:  using (AuditEntry entry = new AuditEntry())
   2:  {
   3:      entry.ObjectMode = ObjectModes.Search;
   4:      entry.LogDate.Visible = true;
   5:      entry.LogDate.Value = DateTime.UtcNow.AddDays(-7);
   6:      entry.LogDate.Operator = Operators.LessThan;
   7:      entry.BulkDelete();
   8:  }

The object-generation tool has been enhanced to support command-line execution against a QO project file:
"C:\Program Files\Akal Tech\Quick Objects V3\NET20\BIN\QuickObjects.Designer.exe" "C:\Projects\MyProject\QuickObjects.qos" /r /s /c /gb /gc /int /inc

In the above example, I am specifying that the objects refresh based on the latest database schema, and to include new tables and new columns. This can be especially handy to run in a post-deploy MSBuild target, if your solution includes a VSTS Database Edition project, in order to keep the business objects auto-synchronized with the database schema.

Many developers out there host applications in shared hosting environments, which typically run in Medium Trust. In previous version of QO, the licensing model required that the host make changes to their medium trust file to trust a 3rd-party licensing component, a task that might be difficult to get approved by a web host. QO has now updated its licensing model to support running in medium trust out of the box.

VSTS 2008 DB Power Tools Released!

twaldron — Sat, 16 Feb 2008 16:54:00 GMT

The long-awaited power tools for VSTS 2008 DB edition have been released, which restore the sorely-missed functionality from the 2005 edition power tools, as well as some excellent improvements.

One of the coolest new features is the Data Generation Wizard, which lets you quickly build a data generation plan by pointing to an existing database.

Kick off a data generation plan programmtically

twaldron — Tue, 08 Jan 2008 16:57:00 GMT

In order to integrate VSTS 2008 Database Edition fully into your development lifecycle, one thing you will probably want to do is kick off a data generation plan automatically during certain activities. Luckily, this is built into some scenarios, like running unit tests--by specifying the "test data" configuration, you can optionally choose to have a database deployment and data generation plan execute prior to the tests starting. Sometimes, however, you just want to run a DG plan, and don't want to have to open the file in VS, click the little button, select the database, and answer the "should I truncate the tables first?" question. One great way to get around this is to use a built-in MSBuild task that was provided to run data generation plans. You can incorporate it into a particular build configuration, or just write yourself a small standalone MSBuild project, along with a bat file to kick it off.

Here's a quick sample, stolen and modified from this post in the MSDN forums:

Filename: RunDataGen.proj

Filename: RunDataGen.bat

C:\Windows\Microsoft.NET\Framework\v3.5\msbuild.exe RunDataGen.proj /p:ConnectionString="server=(local);database=MyDatabaseName.Deployed;Trusted_Connection=true";SourceFile="C:\Projects\MyProject\MyProject.Database\Data Generation Plans\LoadTablesForUnitTests.dgen";PurgeTablesBeforePopulate=True

Static Lookup Data Generators for Visual Studio Team System 2008 Database Edition

twaldron — Tue, 08 Jan 2008 16:39:00 GMT

Updated: Now that the Power Tools for VS2008 have been released, I recommend that you use the Sequential Databound Generator, FileBound Generator, and Data Generation Wizard for these scenarios.

A while back, I put up a sample implementation of a custom data generator for VS 2005, to allow the generation of known static lookup values in a data generation plan. This was just something I was using to fill a gap until Microsoft released the Power Tools for VSTS 2005 DB Pro, which came with the Sequential Databound Generator, which was way more robust. When VS 2008 was released, the Sequential Databound Generator was not included. It was intimated that this critical gap would be filled with an updated Power Tools for VSTS 2008 DB release soon, but until that day comes, I have been using an updated implementation of the original sample code, that will work with VS 2008. I've added static value generators to output the following .NET data types: bool, byte[], DateTime, int, string, as well as an installer.

Usage instructions from the original post still apply.

How to install SQL Server 2005 Developer Edition after VS2008

twaldron — Mon, 07 Jan 2008 18:01:00 GMT

If you have already installed VS2008, and then try and install SQL Server 2005 Dev, you will probably get an error message about changing versions. If you proceed with the installation, the core database components will still be installed, but you won't get the client tools. This is because VS2008 installs an instance of SQL Server Express called .\SQLEXPRESS (even if you tell it not to it would seem), as well as some form of the client tool components (but not what you need for managing multiple servers). Here is a link to a great blog post that explains how to extricate yourself from this situation:
http://tiredblogger.wordpress.com/2007/05/11/installing-sql-server-2005-tools-after-visual-studio-orcas/

On Windows XP, I was able to get SQL Server 2005 Dev installed by following the instructions in the post to remove the pointless SQLEXPRESS instance, and then the client workstation components. This gets your machine back to the point where the Developer edition installer can run successfully.

"Always Recreate Database" deploys by default in VS 2008

twaldron — Thu, 20 Dec 2007 06:25:00 GMT

I had gotten into the habit in VS 2005 DB Edition of enabling the "Always Re-Create Database" option in database project properties. This allowed me to ensure that the db was being re-created from scratch every time I deployed it. I would only deploy the database locally if I had made changes that I wanted to see, or maybe it would happen when running unit tests if so configured.

I was feeling rather puzzled when VS 2008 kept auto-deploying my database project every time I entered the debugger. However, it turns out that this is due to VS 2008 having a different default value for a setting that prior to today, had never entered my reality: "Only build startup projects and dependencies on Run". All you need to do is check this box, and you're back to only deploying when you want to.

Changing default web browser in VS2008

twaldron — Mon, 17 Dec 2007 22:42:00 GMT

After installing Visual Studio 2008, I noticed that the default web browser was set to Firefox. Although this is probably the correct behavior, Firefox being my system default, I'm pretty sure that prior versions of VS ignored my OS-level selection and made IE the initial default. To select a different browser, open an ASPX page, and select “File” -> “Browse With”, or right-click an ASPX resource in Solution Explorer, and choose “Browse With”. This will open a dialog where you can choose a different browser, and optionally make it the default.

Sequential Data Bound Generator Missing in Visual Studio 2008

twaldron — Tue, 27 Nov 2007 04:41:00 GMT

A while back, Microsoft gave us the excellent Power Tools release for the database edition of VSTS 2005. One of the best things about this release was the Sequential Data Bound Generator, which allows the generation of specific values for lookup tables. This generator filled a crucial gap for teams wishing to incorporate data generation plans in the development cycle--a use case that is so common, it's almost unbelievable that it was not included in the initial release. Once I downloaded the power tools, I quickly migrated my old data generation plans from using a custom generator that performed the same basic function to the superior Sequential Data Bound Generator bundled with the released. After installing Visual Studio Team System 2008 Team Suite, I found that a mind-boggling choice was made not to include this generator with the release (or other features of the Power Tools), even though the enhancements from SR1 are bundled with VS2008. This is confirmed in a post on the team's blog: "The Visual Studio Team System 2008 Database Edition is based on the v1.0 functionality plus the Service Release 1 functionality; "..."The functionality that was made available through Power Tools for 2005, remains inside the Power Tools for the 2008 [sic] release, we are trying to release a new Power Tools release targeting 2008 later this month." Based on this, there may be a couple of hurdles to go through, depending on how your shop chooses to migrate. Hopefully the 2008-targeted Power Tools will be released sooner rather than later.

Data Generation with Static Lookup Tables in VSTS Database Edition

twaldron — Wed, 15 Aug 2007 18:53:00 GMT

Download source files for this post - includes some extra files for supporting techniques in this article

Recently, I've been working a lot with VSTS DB Edition, in the hopes of fully-integrating database projects in my day-to-day development and unit-testing activities. As a whole, VSTS DB is an incredible tool, with a lot of promise. However, there are a few highly-noticeable gaps in this version 1.0 product, that make it slightly challenging to use. One critical missing feature is the ability to use data generation with a table intended to contain specific static lookup values. I found that the following use case was not possible using the out-of-the-box data generators:

Build and deploy the database locally from scratch
Load all lookup tables with static values
Load all other tables with randomly-generated data
Run all unit tests, which exercise code that ultimately expects certain values to be in lookup tables (e.g. an enumeration may map to values in a lookup table.)

The solution to this was to build a custom data generator, to handle static lookup values. To demonstrate this, I'll use a simple database schema with four tables:

User, Product, Category — all considered non-lookup tables (I'm including the Category table in this list, as this will be populated with dynamic information through normal operation of the app, and no code will be written that expects certain values to be in it).
UserType — a lookup table that must be pre-loaded with specific static values for the app to work properly.

To get setup, I import the database schema shown above into a SQL Server 2005 database project inside Visual Studio. I then set the following project properties, under the Build tab:

Target database name: VstsTdd.Database.Deployed
Always re-create database: Enabled

These settings ensure that I can re-build the entire database from scratch using only the SQL Server 2005 project, and that when deploying a local copy of the target database, it will always have a consistent name. I will be using this database as the target, when I run unit tests later.

Data Generation out of the Box

Data Generation Plans are an excellent feature in VSTS DB, that allow you quickly fill tables up with random data. This is accomplished using several built-in data generators, that can load columns with various numeric types or strings, and can even make use of regular expressions. Also, the developers who created the generators solved many gotchas that immediately spring to mind, by gracefully accommodating foreign key and unique constraints, nullable columns, and identity columns. So the first thing to do, is create a new data generation plan, select all non-lookup tables, and configure data generation for each column.

The screenshot below shows a data generation plan against this particular database schema. Demonstrated here are two things:

The plan correctly determined that the User.Username column has a Unique constraint, and will generate data accordingly.
It is impossible to completely disable data generation for the UserType table, due to the foreign key constraint from User. Because of this constraint, the data generation engine will fill the UserType table with random values, even though it has not been marked explicitly for generation.

Workarounds that don't Work so Well

There are a couple of workarounds available using the tools at hand. One of these is to pre-load the lookup tables with the desired values using one of the database projects scripts, such as the post-deploy script. Simply add insert statements to a post-deploy script, right-click the project, and select "Deploy". Now the database has been recreated, and pre-populated with lookup values.

The problem with this approach is that when you run data generation against the UserType table, there is no way to keep just those values in the table. If we look at the different options, none of them quite does the job:

Set the "Rows to Insert" property for UserType to 0, since it has already been pre-loaded with static values. In this case, data generation will fail for the User table, because the data generation engine is not intelligent enough to recognize the existing rows in UserType. Thus, it tries to insert null for User.UserType, and fails.
Leave the default Integer generator for UserType.Id and String generator for UserType.Description, and change "Rows to Insert" to a positive integer. This time, when running data generation, every value stored in User.UserType will correspond with one of the generated values — it will never select one of the pre-created values.

The next approach is look at using the supplied Data Bound Generator. With this generator, you can populate a column based on a connection string and select statement, by pointing it to some other table where your lookup values are stored. The problem is...how do you make it choose each row in that target table exactly one time? One thing you can do is change the "seed" property value, to affect which row the random generator chooses each time — if you painstakingly try every possible value (start at 1, then try 2, then 3, ...) you may be able to get it to choose each lookup value exactly one time. However, this only works with small lookup tables—I'm not sure of the magic threshold, but let's say something like 10 rows. I have tried working around this in myriad ways. For pre-loading, I tried using global and local temp tables, as well as a separate database, pre-populated with scripts. For selection, I tried selecting directly from a table, as well as running through UDFs and stored procedures, moving values in and out of different temp tables, to try and select each value only one time. At the end of the day, all of these methods failed me—it was a battle against the IDE, and the IDE won, often crashing in the process when entering anything non-standard as the select statement value for the data bound generator.

Custom Data Generation

To solve the issues with lookup tables, I built a custom data generator, for providing strings that map to lookup values (you could modify this to generate numeric types as well). The values are generated in the right order by specifying a select statement in the designer to pull them out ordered by the pre-inserted IDs (more on this later). You can download the source code, and binary here. There's not too much to creating one of these:

Inherit from Microsoft.VisualStudio.TeamSystem.Data.DataGenerator.Generator
If you intend to generate unique values (probably so), mark the class with [GeneratorStyles(DesignerStyles=GeneratorDesignerStyles.CanProduceUniqueValues)]
Mark one property with [Microsoft.VisualStudio.TeamSystem.Data.DataGenerator.Output]. This is where the unique values are sent for the data generation engine to pick up.
Add other properties as needed for input through the designer, marking these with the corresponding [Input] attribute. In my case, I added a SelectStatement and ConnectionString property to direct the generator to the right table source.
Override the OnInitialize method to retrieve the lookup values. In my case, I stored these to a field-level Queue.
Override the OnGenerateNextValue method to set the output property with the next value.

After building the custom generator, it needs to be installed. This is a bit of a pain, but here are the steps:

Sign the assembly with a strong name. Create an extensions XML file that references the fully-qualifed assembly name (I have included the sn keypair and xml file that I used in the download)
Copy the assembly to:

the PrivateAssemblies directory, default location = "C:\Program Files\Microsoft Visual Studio 8\Common7\IDE\PrivateAssemblies\"
Sometimes I have added it to the Extensions directory for good measure, not sure if this matters, default location = "C:\Program Files\Microsoft Visual Studio 8\DBPro\Extensions\"

Copy the CustomGenerators.Extensions.xml file to the DBPro directory, default location = "C:\Program Files\Microsoft Visual Studio 8\DBPro\"

Another option is registering the assembly in the GAC.

You will know the custom generator is installed correctly when it shows up in the list of available generators for character data columns.

Now, for it to actually work, we need to put all of the lookup values into a safe place, where we can pull them back out at data generation time. I favor storing these values in a separate database, in normal tables. I use scripting to pre-create this "support database", along with all tables and lookup data. So going back to the LoadStaticValues.sql script that is being run in the post-deployment, phase, it can be edited to perform these functions as shown below. This script is available in the download.

Finally, we are almost done. Going back to the data generation plan, we can set the generator for UserType.Description to a StaticLookupValue generator, with the following property settings:

Unique: True
ConnectionString: server=(local);database=VstsTdd.Database.Support;Trusted_Connection=true;
SelectStatement: SELECT [Description] FROM UserType ORDER BY [Id] ASC

Note the ordering clause on the SelectStatement property is being utilized to generate the values in the same order that they were inserted into the support database. Note also that the data preview will fail in the designer until the support database exists, meaning you have to deploy it first to get a working preview. Finally, be sure and set the "Rows to Insert" on the UserType table to the exact number of lookup values in the table (in our case, 3). Otherwise, it will run out of values (in the StaticLookupValue generator class, I handled this to degrade somewhat gracefully by having it output RanOutOfValues-{ordinal} once all values have been exhausted).

Run the data generation plan:

Click the "Generate Data" button
Select the deployed database connection string for the target (not the support database). In this case, the connection string is: server=(local);database=VstsTdd.Database.Deployed;Trusted_connection=true;
When asked if you want to clear all rows in selected tables, answer "Yes". This is because all necessary values will now be handled by the data generation plan.

When complete, each table should show a successful status, and selecting from the table will bring back the exact lookup values previously specified, in the right order.

Next Steps

Now that data generation is working properly with lookup tables, the next logical step is to have this particular data generation plan run automatically when you start a unit test project. Using the database unit test features that come with VSTS Database Edition, one is able to configure a unit test project to do exactly that, thereby assuring that the database has been reset to pre-defined known state, prior to running the first unit test.

Visual Studio - Always Show Solution

twaldron — Wed, 15 Aug 2007 18:10:00 GMT

In Visual Studio 2005, if you have a solution open, with only one project attached to it, the solution file is not visible in the Solution Explorer window. This can be slightly annoying, since right-clicking the solution file from this window is a quick way to add another project (the alternative being to add one from the File menu). I'm not sure why it took me almost two years to notice this, but there is a setting under "Projects and Solutions" to "Always Show Solution". Enabling this, changes the behavior.

Before...

Change the Setting

After...

Determining the framework version under which an assembly was compiled

twaldron — Mon, 30 Jul 2007 17:44:00 GMT

Here is a quick and easy way to determine the version of the framework, under which an assembly was compiled (code written using SnippetCompiler):

using System;
using System.Collections.Generic;
using System.Reflection;

public class MyClass
{
	public static void Main()
	{
		Assembly a = Assembly.LoadFile(@"C:\PathToFile\AssemblyFile.dll");
		
		WL(a.ImageRuntimeVersion);
		
		RL();
	}
	
	#region Helper methods

	private static void WL(object text, params object[] args)
	{
		Console.WriteLine(text.ToString(), args);	
	}
	
	private static void RL()
	{
		Console.ReadLine();	
	}

	#endregion
}

Installing new Visual Studio SKUs after already installing SP1

twaldron — Thu, 26 Jul 2007 17:55:00 GMT

Since Visual Studio is modular, you can install multiple SKUs on top of each other.

You may run across the scenario where you have already installed the applicable SP1 package(s) for Visual Studio 2005 SKUs on your machine, and then install a new SKU (for example, installing VSTS 2005 Tester Edition after already applying SP1 packages to VSTS 2005 Developer Edition). In this case, it is necessary to re-install the applicable SP1 package(s), as documented here:
http://blogs.msdn.com/heaths/archive/2007/03/22/vs-2005-sp1-update-for-vista-requires-vs-2005-sp1.aspx

There are two different Visual Studio 2005 SP1 packages that apply just to Visual Studio (regardless of OS being used):

Visual Studio 2005 Express Editions SP1
Visual Studio 2005 Team Suite SP1 (works on Microsoft Visual Studio 2005 Standard, Professional, and all Team Editions)

Then, if running Windows Vista, the Visual Studio 2005 Service Pack 1 Update for Windows Vista, must be applied after the applicable patch(es) from the list above.