Martins BIG Blog...

MIX08 Session: Applications = Designers + Developers for WPF and Silverlight

noreply@blogger.com (Martin) — Fri, 6 Jun 2008 11:07:00 +1000

This is a Big Tutorial. So get a JUG of Coffee Handy.

Last week I reviewed some of the sessions from MIX08.
I was most impressed with the MIX08 CT06 Session: Applications = Designers + Developers held by Celso Gomes and Kirupa Chinnathambi which dealt with Re-Styling a ListBox. The FurnitureShowroom example showed how to completely change the style of a ListBox.
Here's a link to the Video session: MIX08 CT06 Session: Applications = Designers + Developers
Have a look at the Video before attempting this tutorial, it will give you a good overview.
The following screen shot is from Celso's and Kirupa's WPF application with a completly re-styled ListBox (Look Ma! "no scroll bars").

Even though the session gave a good overview of how to create a really nice application using WPF and Expression Blend and Design, I got a bit lost with the Control styling part. I thought that was the most interesting part of the demonstration, but that’s me, I look for the tricky stuff.
Celso had created these styles beforehand so we did not get to see how he did that. But still a fantastic example of WPF power.
I thought I would try and replicate what they did using the fabrikam sample data.
I was able to produce a similar example and also pull apart the ListBox and re-style it.
Here's the low-down on how to re-style a ListBox to resemble Celso's. I didn't write any C# code for this example it was all done using Expression Blend.
Pre-requisites first : I used the following tools.

Expression Blend 2
Visual Studio 2008 (3.5)
Platform Windows Vista Ultimate

Here's a Link to Expression Blend: Expression Blend 2 Download
A bit of an Overview first.
For most controls, there is appearance and behavior. Consider a button: appearance is the raised area that you can press, and the behavior is the Click event that gets raised in response to a click. Sometimes, there may be a control that provides the behavior that you need but not the appearance that you need. You can use style setters to set property values to affect the look of control. However, to change the structure of a control or to set property values on the components that comprise a control, you need to use a ControlTemplate.
The data and UI you see in the above form is really a reconstructed ListBox control with re-styled ListBoxItems. The scrollbars have been disabled and re-styled so we still get the same behaviour as a ListBox but without the look. (We want the Engine but not the Body)
Quote:
Windows Presentation Foundation (WPF) styling and templating refer to a suite of features (styles, templates, triggers, and storyboards) that allow an application, document, or user interface (UI) designer to create visually compelling applications and to standardize on a particular look for their product.
(What a Mouthfull); straight out the book, but basically that’s it in a nutshell.
The question is how? Usually something so powerful as the above quote requires time and patients’ to get real handle on, especially when you are designing a unique UI, you need to understand the technology to do the job right. Well WPF has the power to create any type of UI you can imagine.
But it helps to have HELP.
OK enough babble lets get to work.
I am not going to go into the basics of styles and templating, you can read WPF SDK docs for that information. I just want show how to turn your every day WPF ListBox into something like Celso's.
Below is my application using the fabrikam data. You will notice the default ListBox. Typical ListBox stuff. Scroll bars and Items one below the other.

So to get a UI like the Furnitureshowroom example we need to change the default style.

Go to the end of this tutorial to see the finished product.

In my fabrikam application, we have a ListBox control that is bound to a list of images and text. I used the fabrikam XML file for my data source and the images that are part of the fabrikam tutorial.
In WPF, you use a DataTemplate to define the visual representation of data. Basically, what you put into a DataTemplate determines what the data looks like in the rendered application.
So lets give our ListBox a new DataTemplate so we don't have this list collection look. If you have Microsoft Expression Blend it makes this a whole lot easier. So I will asume you have it and use that tool to change the XAML.
Open up Expression Blend and create a new WPF .exe application named "CustomListBox".
Double Click the LayoutRoot object in Objects and Timelines so it is highlighted yellow.
Click on the the Asset Library and find the ListBox control. Draw a ListBox on the area. Its usually drawn inside a Grid container.
Locate some data. You can use the fabrikam XML file and the images as your data source. You will need to create an images directory in your project and copy the images from the following ZIP file into that directory to map to the fabrikam XML file structure.
Here's a Link to the Fabrikam data
Download the fabrikam XML Data and Images
Once you have your ListBox you need to bind your datasource to it.
Under Projects and in the Data section you will notice the +XML item. If you click that, you can locate your XML data source and attach it to the Project. The new DataSource can now be bound to your ListBox. Expand the +XML datasource untill you see the Product Array item as the following image shows.

Drag the Product (Array) item onto your ListBox. Dont worry all the fields will follow. A small dialog will be displayed, select Bind Product to ListBox and Select Field is ItemSource and Click OK and Click OK again to close this form.
Good your DONE!
Now to the good stuff. Double click on the ListBox control so its is highlighted yellow.
Right click and select the submenus as the following image shows. You need to get to the ListBoxes ItemTemplate.

The next image shows the current DataTemplate.
Notice the StackPanel item. It has a group of TextBlock controls under it.
This is your DataTemplate.

Our data from the fabrikam sample has real images but you will notice that the default ListBox shows the text path of the image not the image itself. How about we change that first. Delete the TextBlock item in the StackPanel that holds the image path details and replace it with an Image control, you find the Image control in the Asset Library. Next we need to bind the Source property of the image control to the Image element in the XML Datasource.
Your StackPanel should look like the one below. The Image control replaces the TextBlock.
Next select the Image control and under Common properties click the little yellow icon on the right to bring up the DataBinding Menu.

Click the Data Binding menu item to display the Create Data Binding form.

Click the Image element in the Products Array and click Finish.

Cool your almost there.
Test it. Select Control + S to save your Project and Press F5 to run.
Should see something like the following screen shot.

But still nothing Like Celso's style right.

OK I'll get to the point.
We need to create a new DataTemplate to hold our list items. Go to the Project tab and right click on the Project name and select Add New Item. We will add a new Window to hold our template. Once the new window is created double click on the LayoutRoot object and Delete it. Next add a new Canvas to the Window object (Canvas's are in the Asset Library). We are going to add 4 new controls to the Canvas item of the new Window. First double click the Canvas item so it is highlighted yellow. Then right click on it and rename it to NewTemplate. While it is still highlighted add 3 new TextBlocks and 1 new Image control. Rename the controls to match the following screen shot. It should look like the following.

Next right click on the NewTemplate and copy it to the clipboard. Go back to our main Window where the ListBox is and confirm we are still in the ItemTemplate of the ListBox. If somehow the breadcrumb has vanished double click on the ListBox control so its is highlighted yellow. Right click and select the submenus as the following image shows. You need to get to the ListBoxes ItemTemplate.

We should by now have an empty ItemTemplate, you can remove this altogether and replace it with your own. Delete the StackPanel with all its controls. It will look like the following shot. Don't Delete the ItemTemplate we will want that to hold our DataTemplate.
Now with the ItemTemplate selected right click and Paste the the NewTemplate we created in the new window into the ItemTemplate. Resize the new template to fit in side the layout of your panel. Your Objects and Timelines view should look like the following shot.

Now this where the fun begins. If you run it here you will not see any data because we have not bound the template controls to the datasource. Remember this is a new DataTemplate we are building, the bindings we had before were lost when we deleted the old stackpanel. So we have to bind the controls in the NewItemTemplate to our DataSource.
Its pretty easy.
Click on the Name TextBlock. Under the Common Properties section in the Properties Editor, locate the Text attribute and click the little yellow icon on the right. Click the Data Binding menu item and the Create Data Binding form will be displayed. Expand the fields tree untill you see the Name field, click it, and select Finish. Do this for all the TextBlock controls. With the Image control its the same proceedure but the binding is done with the Source property.

With all the Controls now bound to their datasource counterparts you can run the application, Press Control+S to Save and F5 to Run. It should resemble the following shot.
I know, it doesn't look much different than the previous one. I just wanted to demonstrate how you can create a new DataTemplate. I'll leave the Bells and Wistles to You.

If you scroll you will only see one item at a time, not the list as in the first instance.
So we have finished creating a new DataTemplate and assigned it to the ListBoxes ItemTemplate. A new DynamicResource named ProductTemplate exists and below is the syntax on the assignment to a ListBox. Itemtemplate="{DynamicResource ProductTemplate}" Click on the following image to see the DataTemplate XAML.

Not Finished YET. We now have to create a new ItemContainerStyle. In WPF, the ControlTemplate of a control defines the appearance of the control. You can change the structure and appearance of a control by defining a new ControlTemplate for the control. I am not going to copy the design of the FurnitureShowRoom but I will try to copy the behaviour. That is, we will create a ControlTemplate for a TargetType="{x:Type ListBoxItem}" and also pull apart the ListBox VerticalScrollBar and extract the bits we need and hide the rest.
First thing to do is get rid of that selection background when we click on a list item. The blue color can be changed to any color you like. But I think we wont need it because we are not going to use the scrollbar at all. At least not the way you think.
What we need to do so we don't have the blue background when an item is selected is change the Background color on the IsSelected Trigger property.
To drill down to the ItemContainerStyle Click on the ListBox and select the menu items in the screen shot below to get down to that level.
(TIP: To get back to the ListBox root, click the icon in Objects and Timelines).

Next right click on the ItemContainerStyle and select the menu items as the following screen shows.

Next click on the ContentPresenter object in the Template and then click the IsSelected property in the Triggers section. You will see in the Properties when active section displayed and the Bd.Background = #FF454545 property. We need to set this value to either an opacity of 0% or change the value to your background color of choice. If you click on the Bd.Background property you will see the main properties in the Properties Editor change to reflect the current state.
TIP: If you want to get to a particular property you can search for it by typing the property name in the search textbox provided, as shown below. This will display the Properties editor where you can modify the values. For now set the A color of the Background color to 0%.
Press Control+S to and F5 to test your changes. you should see no change in the Background of the selected item. If you need to roll back to the original settings keep pressing Control+Z until you get back to the start. If you have a neutral background leave it there and get back to the ListBox.
TIP: To get back to the ListBox root, click the icon in Objects and Timelines.
Open up the XAML code view and search for the new ControlTemplate of TargetType="{x:Type ListBoxItem}, this is your new style for the Selected ListItem. The following screen shot shows the XAML that was created from the previous exercise.

At this point you might want to get another Jug of Coffee.

Next we will grab the Up and Down buttons that a part of the VerticalScrollBar and replace them with our own. Like in the FurnitureShowRoom screen shot.
We want to re-style the control below so as to use the Commands for the up and down repeatbuttons but be able to locate those buttons any where on our form and not in the scroll bar itself. That means we have to hide the scroll bar and re-style the templates that hold the repeatbuttons. So we will need to drill doen to the PART_Track of vertical scroll bar.

First: Click on the ListBox object in Objects and Timelines so it is highlighted. In the Properties Editor type scroll in the Search box. This will display the Layout properties for the Horizontal and Vertical Scroll bars. Select the HorizontalScrollBarVisibility property and Disable it. This will prevent the bottom scroll bar from being displayed.

Next: We are going to create a new ControlTemplate of TargetType="{x:Type ListBox}" and re-style the ScrollBars particularly the ScrollViewer by creating a ControlTemplate of TargetType="{x:Type ScrollViewer}"
We are going to create a Style resource with a Key named ListBoxStyleScrollBarModify.

Right click on the ListBox control in Objects and Timelines and follow the menu selection in the screen shot below.

Type Name the style as follows.

Basically what we need to do is set the ScrollBarBackground to Transparent, hide the Thumb and re-style the RepeatButtons.
With our ListBoxStyleScrollBarModify created lets begin.

First: we will set the ScrollBarBackground to no brush and hide the Thumb.
Right click on [ScrollViewer] and select the following menu items.

Click OK to the Control Template Resource name ScrollViewerControlTemplate1.
Now we should see a Grid with the PART_VerticalScrollBar. We need to hide the Background of this part.
Next: right click on the "PART_VerticalScrollBar" and select the menu items as follows;

Except the ScrollBarStyle1 name and press OK.
We should now be at the level that makes up the Control Parts.

Click on "Bg" under Template, and in the Properties Editor locate the Background brush and select No Brush. This will make it Transparent. You may have to click on the the little icon on the right of Background Brush and select Reset in the context menu, but basically you need to have the Background set to No-Brush.

Click on the Part_Track.
Go to the Properties Editor and scroll down untill you find the Visibility property.
Set it to Collapsed.
If you run the application now all that should be visible are the two RepeatButton controls.
Next: right click on the RepeatButton and follow the menu selection below.

The Template for the RepeatButtons is as follows.

Next: Click and delete the default style named "Chrome".

Now there is one problem. We have an empty Template so we can't just add our new Buttons to it, we have to add a container first. So double click on the Template object and select a new Grid control from the Asset library.

We will add a Grid to the Template. You can either draw the Grid in the Template or double click on the Grid control from the Asset library so it is placed inside the RepeatButton's Template.

It should look like the following screen shot.

Next: I created a Path object to represent my new RepeatButtons.
It is basically the Left Arrow from Celso's FurnitureShowRoom sample.
Click on the following image to view the Path XAML.

You can use this to place inside the Grid container.
Let's create a temporary window to hold this piece of XAML.

First: Select the Project name "CustomListBox" right click and Add New Item. We are going to create a new window and replace the Grid XAML with something like the above image.
If you use the above XAML and go to design view you will see an arrow.
This is going to be our new RepeatButton ControlTemplate Style.

Next: With your arrow created and while in design view, click on the arrow_left object and Copy it to the clipboard (Make sure you don't grab the attached Grid). We only need the arrow_left XAML object.

Next: Go back to the RepeatButton Grid in your main form and double click on the Grid under the Template and Paste the arrow into the Grid.

I do it this way so we are not working in XAML view. Its easier to do this stuff in design view.
It should look like the following screen shot.

Zoom in on the top RepeatButton area by holding down the Control Key and then use your mouse wheel to Zoom in or Out.

If you can't see the Arrow in the Grid, Zoom out and Right Click on the Arrow and Select Auto Size/Fill from the context menu. Drag it into the Grid if required. But it should be a sub-control in the Grid of the RepeatButton Template.

The following screen shot is what you should see. Our new Arrows are the RepeatButtons.

Next: We need to make a few changes. They are both Left Arrows, we need to make one a Right Arrow, and they are still in the wrong location. Lets fix that NOW.

Click on the RepeatButton as the following screen shot shows.

The Arrow should now be hightlighted like the one below.

Next: Drag the Arrow over untill it resembles the following screen shot.

Next: Repeat the proceedure for the Right Arrow. Drag it over untill it is lined up on Top edge but about 50mm apart.

Next: While the right arrow is still highlighted Flip it Horizontally. The following screen shot shows how.

This is only required to display it correctly, it's behaviour is already set. Right Arrow = Down , Left Arrow = Up.

Before we get to carried away we need to change the cursor to Hand and the rollover area on the Arrow needs to be a larger.

First: Right click on the RepeatButton and select Edit Control Parts (Template)/Edit Template, then double click on the Grid.

In the Properties Editor, change the Background on the Grid (NOT the Arrow) but the Grid, to have a Background Brush of Black or some color.
With the Background Brush set, change the the A color of the Background to 0% opacity.
We need the background to have a 0% opacity otherwise the Arrow may be hidden by the Color.

Next: Find the Cursor property on the Grid and change it to Hand.

Now when you MouseOver the Arrow it should respond without being exactly over the Arrow.

You should only need to do this on one of the Arrow Grids, as the other Grid will inherit the changes.

OK Your ready to Roll.

Test it: Control + S to Save and F5 to Run.

Your form should resemble the following.
If you click on the Arrow's you should get the same up and down behaviour as the default scrollbar.

Summary:

We started with a default ListBox, that displayed a typical list view.

XAML gave us the flexibility to completly change the UI of the ListBox control.

By Creating a new DataTemplate we could display an Image in our list.

Then we created an ItemContainerStyle to modify the IsSelected trigger so we didn't see the default blue background when a list item is selected.

And finally we created a new Style to override the ScrollBar UI.

By doing these three tasks we were able to completly change the appearance of the ListBox UI without any C# or VB.Net code.

Conclusion:

Expression Design has a Template for the Fabrikam layout. By exporting that template to XAML I added some bells and whistles to the above form and ended up with the following.

Goto a Fabrikam Product Tutorial

WPF Custom ListBox (Background Removal Style)

noreply@blogger.com (Martin) — Tue, 3 Jun 2008 15:03:00 +1000

The following Style removes the background selection color from a ListBox in WFP.

Assign this style to the ListBoxes ItemContainerStyle property.
eg:. ItemContainerStyle="{DynamicResource ListBoxItemStyleNoBackGround}"

Where ListBoxItemStyleNoBackGround is the name you gave the Style.
This is usful when you don't want the ListBox to show the default blue background when an item is selected.

ListBox with default Background Selection.

ListBox with Background Selection hidden.

For your Regular Expressions needs goto;

http://regexlib.com/

WindowsClient.NET

noreply@blogger.com (Martin) — Fri, 18 Apr 2008 17:14:00 +1000

WindowsClient.NET

Design Guidelines, Managed code and the .NET Framework with SilverLight

noreply@blogger.com (Martin) — Fri, 18 Apr 2008 17:12:00 +1000

SilverLight and NET 3.5 stuff

ASP.NET Community

noreply@blogger.com (Martin) — Tue, 8 Apr 2008 11:20:00 +1000

ASP.NET Community

Open Source Web Design

noreply@blogger.com (Martin) — Tue, 8 Apr 2008 10:50:00 +1000

Open Source Web Design

Display Images From the NorthWind Categories Table using LINQ

noreply@blogger.com (Martin) — Sat, 5 Apr 2008 14:42:00 +1100

ASP Side;

HttpHandler to return the binary image.

CategoryImages.ashx?CategoryID=1
You can use this call in a src... attribute of the HTML img control or any an ASP.NET Server control that can display images.

Code behind ;

Create a HttpHandler Class called CategoryImages

Create the NorthwinDataContext LINQ to SQL class and add the Category Table to the DataContext layout.

/************************************************************/
public class CategoryImages: IHttpHandler
{

// Implement the ProcessRequest method
public void ProcessRequest(HttpContext context)
{
HttpRequest req = context.Request;
string categoryID = req.QueryString["CategoryID"].ToString();
// Get information about the specified category
NorthwinDataContext db = new NorthwinDataContext();
var category = from c in db.Categories
where Convert.ToInt32(c.CategoryID) == Convert.ToInt32(categoryID)
select c.Picture;
int len = category.First().Length;
// Output the binary data
// But first we need to strip out the OLE header
int OleHeaderLength = 78;
int strippedImageLength = len - OleHeaderLength;
byte[] imagdata = new byte[strippedImageLength];
Array.Copy(category.First().ToArray(), OleHeaderLength, imagdata, 0, strippedImageLength);
if ((imagdata) != null)
{
MemoryStream m = new MemoryStream(imagdata);
System.Drawing.Image image = System.Drawing.Image.FromStream(m);
image.Save(context.Response.OutputStream, ImageFormat.Jpeg);
}
}
}

/*************************************************************/

LINQ to SQL

noreply@blogger.com (Martin) — Sat, 5 Apr 2008 10:28:00 +1100

http://weblogs.asp.net/scottgu/archive/2007/09/07/linq-to-sql-part-9-using-a-custom-linq-expression-with-the-lt-asp-linqdatasource-gt-control.aspx

LINQ to SQL visualizer plug-in

ASP.NET Podcast

noreply@blogger.com (Martin) — Sat, 5 Apr 2008 09:37:00 +1100

http://aspnetpodcast.com/CS11/search/SearchResults.aspx?u=2100&o=DateDescending&PageIndex=2

Using the osql Utility

noreply@blogger.com (Martin) — Sat, 5 Apr 2008 08:36:00 +1100

http://technet.microsoft.com/en-us/library/aa213090(SQL.80).aspx

SQL Server 2000 Sample Database Files

noreply@blogger.com (Martin) — Sat, 5 Apr 2008 08:32:00 +1100

Updated SQL Server 2000 Sample Database Files
December 15, 2004
© Copyright Microsoft Corporation, 2004. All rights reserved.
The SQL Server documentation team cannot answer technical support questions, but welcomes your suggestions and comments about this readme documentation. You can quickly and directly send e-mail feedback using the link below. Please send feedback in English.To submit written feedback about this document, click here: Submit feedback.
Introduction
The Microsoft® SQL Server™ 2000 Sample Database Files include:
· New versions of two scripts included with SQL Server 2000:
· Instpubs.sql creates the pubs sample database.
· Instnwnd.sql creates the Northwind sample database.
· Pre-built database files that can be attached to an instance of SQL Server 2000:
· Pubs.mdf and pubs_log.ldf are the data and log files for the pubs sample database.
· Northwind.mdf and northwind.ldf are the data and log files for the Northwind sample database.
These copies of the scripts or database files are the same as the versions included with SQL Server 2000, except for these changes:
· The script for creating pubs, instpubs.sql, has been modified to install pubs and all of the pubs data in one step. The original version of instpubs.sql included in SQL Server 2000 does not load in some of the pubs data, and customers were required to run batch jobs to install some of the larger data values.
· The scripts have been brought into compliance with recent Microsoft samples security guidelines. Instpubs.sql no longer creates a “guest” user and no longer grants rights to “guest” or “public”. All dates that are used to populate the databases now express the full four-digit year, such as 1992.
· The pre-built database files include all of the changes incorporated in the new script files.
SQL Server 2000 Desktop Engine (MSDE 2000) customers can also use these copies of the files to install pubs and Northwind.
Note If the instance of SQL Server 2000 was installed with a case-sensitive collation, always type pubs in all lowercase letters, and Northwind with an initial capital "N" followed by lowercase letters. Sample applications and the code samples in SQL Server Books Online might not work correctly if the database names are not created exactly as shown in the examples.
Sample Files Prerequisites
The user attaching the pre-built database files must be a member of the SQL Server sysadmin or dbcreator fixed server roles.
The user running the SQL Server 2000 Sample Database Scripts must be a member of the SQL Server sysadmin or dbcreator fixed server roles, or have been granted CREATE DATABASE permissions.
The files can be used with the following versions of SQL Server 2000:
· SQL Server 2000 Service Pack 3 (SP3) or later.
· SQL Server 2000 Desktop Engine (MSDE 2000) SP3 or later.
· SQL Server 2000 Desktop Engine (MSDE 2000) Release A.
Downloading and Extracting the Files
The SQL Server 2000 Sample Database Files are available as an installation file, SQL2000SampleDb.msi, which can be downloaded by following the instructions on the download website.
After downloading SQL2000SampleDb.msi, extract the sample database files by double-clicking SQL2000SampleDb.msi. SQL2000SampleDb.msi extracts the database scripts and this readme file into this folder by default:
C:\SQL Server 2000 Sample Databases
Installing the Sample Databases
To install the sample databases
1. Either run a script to build a sample database, or attach the pre-built database files for that database.
2. To grant another person access to the sample database, you must grant permissions on the database objects to that person.
SQL Server 2000 customers can perform these tasks using either the osql utility or the two graphical utilities SQL Query Analyzer and SQL Enterprise Manager. MSDE 2000 includes only the osql command prompt utility.
Caution Instpubs.sql drops any existing version of the pubs sample database and Instnwnd.sql drops any existing copy of the Northwind sample database before creating the new copies of the database.
Attaching the Pre-built Files by Using Enterprise Manager
To attach the pre-built files by using SQL Query Analyzer:
1. From the Start menu, point to All Programs, point to Microsoft SQL Server, and then click the Enterprise Manager icon.
2. Right-click Databases and select All Tasks/Attach Database.
3. Either enter C:\SQL Server 2000 Sample Databases\northwind.mdf or C:\SQL Server 2000 Sample Databases\pubs.mdf as the MDF file of database to attach, or click Browse (…) to search for the file to attach.
4. Click Verify to ensure the selected MDF file is correct.
5. Specify Northwind or pubs in Attach as.
6. Specify the database owner.
7. Click OK.
Attaching the Pre-built Files by Using osql
To attach the pre-built files by using osql:
1. Open a command prompt window.
2. From the command prompt, use the cd command to navigate to the folder containing the SQL Server 2000 Sample Database Scripts: cd c:\SQL Server 2000 Sample Databases
3. Run osql using the -Q switch to execute sp_attach_db to attach either the pubs or Northwind pre-built database files. Here are some examples:
Note Enter the osql commands on one line in the command prompt window. These examples split the commands across two or three lines to make the examples easier to read.
· To attach the Northwind database to a default instance on the same computer: · osql -E -Q "EXEC sp_attach_db N'Northwind', N'c:\SQL Server 2000 Sample Databases\northwind.mdf'"
· To attach the pubs database to a default instance on a different computer: · osql -E -S ComputerName -Q "EXEC sp_attach_db N'pubs', N'c:\SQL Server 2000 Sample Databases\pubs.mdf'"
· To attach the Northwind database to a named instance: · osql -E -S ComputerName/InstanceName· -Q "EXEC sp_attach_db N'Northwind', N'c:\SQL Server 2000 Sample Databases\northwind.mdf'"
Running the Scripts Using SQL Query Analyzer
To run the scripts using SQL Query Analyzer:
1. From the Start menu, point to All Programs, point to Microsoft SQL Server, and then click the Query Analyzer icon.
2. Connect to the instance of SQL Server 2000 on which you want to create the sample database.
3. On the File menu, click Open, and navigate to the c:\SQL Server 2000 Sample Databases folder. Select either Instpubs.sql or Instnwnd.sql.
4. On the toolbar, click Execute Query.
Running the Scripts Using osql
To run the scripts using osql:
1. Open a command prompt window.
2. From the command prompt, use the cd command to navigate to the folder containing the SQL Server 2000 Sample Database Scripts:
3. cd c:\SQL Server 2000 Sample Databases
4. Run osql specifying either Instpubs.sql or Instnwnd.sql as the input file. Here are some examples:
· To install the Northwind database on a default instance on the same computer: osql -E -i instnwnd.sql
· To install the pubs database on a default instance on a different computer: osql -E -S ComputerName -i instpubs.sql
· To install the Northwind database on a named instance: osql -E -S ComputerName/InstanceName -i instnwnd.sql
Assigning Permissions
The logon you use when creating or attaching a database becomes the owner of the sample database, and of all the objects within the database. That login and any login in the sysadmin fixed server role will have permission to access the data and objects in the sample database. All other logins must be granted permissions before they can access the sample data and objects.
Granting a Login Access to a Database
You can grant access to the sample databases using Enterprise Manager or the sp_grantdbaccess system stored procedure. Only a database user that is a member of at least one of the following roles can grant access to a database: the sysadmin fixed server role, the db_accessadmin fixed database role, or the db_owner fixed database role.
To grant access using Enterprise Manager:
1. Expand the server group and then expand the server.
2. Expand Databases and select the sample database.
3. Right-click Users, and then click New Database User.
4. Complete the Database User Properties form.
To grant access using sp_grantdbaccess
Having connected to the server with either osql or SQL Query Analyzer, you can use sp_grantdbaccess to enable a domain user to access the database. For example, the following commands grant access to pubs to a domain user named Hamid:USE pubs;GOsp_grantdbaccess 'CORPORATE\hamid', 'hamid';GO
For more information about granting logins access to a database, see the following topics in SQL Server Books Online:
Granting a Windows User or Group Access to a Database
Granting a SQL Server Login Access to a Database
Granting User Accounts Permissions
Once a login has been associated with a user account in the sample database, you must grant that user account permissions to access database objects. Only a database user that is a member of at least one of the following roles can grant access to database objects: the sysadmin fixed server role, the db_accessadmin fixed database role, or the db_owner fixed database role.
To grant account permissions using Enterprise Manager
1. Expand the server group and then expand the server.
2. Expand Databases and select the sample database.
3. Expand the category for type of object, such as stored procedures or views.
4. Right-click the object, point to All Tasks, and then click Manage Permissions.
To grant account permissions using the GRANT statement
In either osql or SQL Query Analyzer you can use the GRANT statement to grant permissions on database objects. First execute a USE statement.
To grant execute permission on a stored procedure, use the following statement:GRANT EXECUTE ON [dbo].[database_object_name] TO [database_user_account];GO
To grant data read and modification permissions, use the following statement:GRANT SELECT , INSERT , DELETE , UPDATE ON [dbo].[database_object_name] TO [database_user_account];GO
For more information about granting permissions in a database, see the following topic in SQL Server Books Online:
Granting Permissions

NVIDIA Direct3D SDK

noreply@blogger.com (Martin) — Thu, 27 Mar 2008 10:38:00 +1100

NVIDIA Direct3D SDK

BizTalk Utilities

noreply@blogger.com (Martin) — Mon, 3 Mar 2008 10:21:00 +1100

BizTalk Utilities

IIS 6.0 Documentation (IIS 6.0)

noreply@blogger.com (Martin) — Mon, 3 Mar 2008 09:07:00 +1100

IIS 6.0 Documentation (IIS 6.0)

Windows Core Networking APIs and technologies such as Winsock, TCP/IP stack, WFP, IPsec, IPv6, WSK, WinINet, Http.sys, WinHttp, QoS, and System.Net

noreply@blogger.com (Martin) — Mon, 3 Mar 2008 09:05:00 +1100

Windows Core Networking APIs

XML in the .NET Framework

noreply@blogger.com (Martin) — Fri, 11 Jan 2008 10:10:00 +1100

Extensible Markup Language (XML) is a meta-markup language that provides a format for describing structured data. XML enables a new generation of Web-based data viewing and manipulation applications. XML is the universal language for data on the Web. XML gives developers the power to deliver structured data from a wide variety of applications to the desktop for local computation and presentation.

XML in the .NET Framework

ASP.NET Tracing

noreply@blogger.com (Martin) — Tue, 8 Jan 2008 15:46:00 +1100

ASP.NET enables you to view diagnostic information about a request for an ASP.NET page. Tracing also enables you to write debug statements directly in your code without having to remove them from your application when it is deployed to production servers. You can write variables or structures in a page, assert whether a condition is met, or simply trace through the execution path of your page or application. You can view tracing information appended to the end of a page, or in a separate trace viewer, or both.

The topics in this section describe how tracing works, how to manage tracing, and how to integrate ASP.NET tracing with .NET system diagnostics.

ASP.NET Tracing
Application-level Trace Logging
diagnostics Element

TopXML

noreply@blogger.com (Martin) — Thu, 3 Jan 2008 13:45:00 +1100

General XML Tutorials

Top XML

XML Schema Part 0: Primer Second Edition

noreply@blogger.com (Martin) — Thu, 3 Jan 2008 09:50:00 +1100

XML Schema Part 0: Primer is a non-normative document intended to provide an easily readable description of the XML Schema facilities, and is oriented towards quickly understanding how to create schemas using the XML Schema language. XML Schema Part 1: Structures and XML Schema Part 2: Datatypes provide the complete normative description of the XML Schema language. This primer describes the language features through numerous examples which are complemented by extensive references to the normative texts.

XML Schema Part 0: Primer Second Edition

JSON (JavaScript Object Notation)

noreply@blogger.com (Martin) — Fri, 21 Dec 2007 10:35:00 +1100

Introduction to JSON

JSON is a lightweight data-interchange format. It is particularly useful because it can be 'decoded' easily by web page JavaScript into object form.
AJAX-based web pages use XmlHttpRequest to receive data from a server in response to a user action. While the returned data is normally in XML format, it can also be returned in JSON string format and processed more easily in JavaScript.
Many applications may store information in XML format. However they may want to send data to a client using JSON.
To achieve this, they must convert their XML data into JSON format.
JSON Site: JSON

How to convert XML to JSON in ASP.NET C#
ASP.NET Podcast on JSON

.NET Framework 3.0

noreply@blogger.com (Martin) — Thu, 20 Dec 2007 14:08:00 +1100

When speaking to developers about WinFX one question that repeatedly comes up is, “WinFX sounds great, but what happens to .NET?” .NET Framework has become one of the most successful developer platforms in the world.
The .NET Framework has always been at the core of WinFX, but the WinFX brand didn’t convey this. The WinFX brand helped us introduce the incredible innovations in terms of Windows Presentation Foundation (WPF), Windows Communication Foundation (WCF), Windows Workflow Foundation (WF) and the newly christened Windows CardSpace (WCS) formerly known under the codename “InfoCard.” The brand also created an unnatural discontinuity between previous versions of our framework and the current version.
With this in mind we have decided to rename WinFX to the .NET Framework 3.0. .NET Framework 3.0 aptly identifies the technology for exactly what it is – the next version of our developer framework.
The change is in name only and will not affect the technologies being delivered as part of the product. The .NET Framework 3.0 is still comprised of the existing .NET Framework 2.0 components, including ASP.NET, WinForms, ADO.NET, additional base class libraries and the CLR, as well as new developer-focused innovative technologies in WPF, WCF, WF and WCS.
The .NET Framework 3.0 will still ship with Windows Vista, and will be available down-level for Windows XP and Windows Server 2003 as planned. This change doesn’t affect in any way the ship schedules of either Windows Vista or the .NET Framework 3.0 itself.

C# 3.0: An Introduction

.NET 3.5

With the release of .NET 3.5 is Language Integrated Query (LINQ).
LINQ essentially is the composition of many standard query operators that allow you to work with data in a more intuitive way regardless of the data source.

You can query in-memory collections, Relational Data and XML.

For an introduction to LINQ goto : .NET 3.5 LINQ

XSLT - Simple HTML Table

noreply@blogger.com (Martin) — Wed, 19 Dec 2007 12:38:00 +1100

In this example we will convert a simple XML file to HTML

The HTML output
The goal is to generate the HTML output shown below using the XML document as the source of the information.

XSLT will help us to do this.
Add this line to your XML file.

Here's the people.xsl (XSL) file that produces the HTML.
Every XSL file needs to specify the XSL namespace so that the parser knows which version of XSLT to use.

Here's a break down of the XSL file.
The namespace prefix xsl: is used in the rest of the XSL file to identify XSL processing statements. If a statement isn't prefixed with xsl:, then it's simply copied to the output without being processed. This is the way to add HTML statements to the output. When we are working with XSLT, the context for a query is the node in the source XML document currently being processed. So in the template xsl:template match="/", we are in the context of the root of the XML document. This isn't the PEOPLE element, it's the whole document, above the PEOPLE element.
When you're debugging XSL, the first question you should ask is, "What context is being processed?".

The backslashes are not part of the syntax.
<\xsl:template match="/"\>

Before processing can begin, the part of the XML document with the information to be copied to the output must be selected with a XPath expression. The selected section of the document is called a node and is normally selected with the match operator. If the entire document is to be selected, match the root node using match="/". Another approach is to match the document element (the element that includes the entire document). In our example, the document element can be selected using match="PEOPLE". (If you use this alternative approach, don't include PEOPLE in the 'for-each' selection below.)

The backslashes are not part of the syntax.
<\xsl:for-each select="PEOPLE/PERSON"\>

The expression xsl:for-each finds all 'PERSON' elements in the 'PEOPLE' element context using the XPath expression 'PEOPLE/PERSON'. If the selected node contains all elements in the root, all of the 'PEOPLE' elements will be selected. Since we want to include all 'PERSON' elements in our output document, we have used this expression.
The 'for-each' expression is a loop that processes the same instructions for these elements.

The backslashes are not part of the syntax.
<\xsl:value-of select="NAME"/\>
<\xsl:value-of select="ADDRESS" /\>
<\xsl:value-of select="TEL" /\> etc...

When the xsl:for-each expression has selected a 'PERSON' element, the xsl:value-of expression extracts and copies to the output file the value stored in the selected element. In this case, the value stored in the 'NAME' element is copied to the output. This call is made for each value you are extracting.

This will produce the html required that can then be displayed in the clients browser.

AJAX .Net Wrapper

noreply@blogger.com (Martin) — Tue, 18 Dec 2007 15:55:00 +1100

Asynchronous JavaScript and XML (AJAX)

Ajax: A New Approach to Web Applications

Download the Ajax DLL from:
Ajax.NET
Add the Ajax.dll reference to your application.
Add the using Ajax; namespace to your page.
Add the httpHandler to your web.config.

Sample Code to try.

Ajax can return custom classes. All that is required is that the class be marked with the Serializable attribute. Given the following class:

[Serializable()]
public class User
{
private int _userId;
private string _firstName;
private string _lastName;
public int userId{ get { return _userId; } }
public string FirstName{ get { return _firstName; } }
public string LastName{ get { return _lastName; } }

public User(int _userId, string _firstName, string _lastName)
{
this._userId = _userId;
this._firstName = _firstName;
this._lastName = _lastName;
}
public User(){}

[AjaxMethod()]
public static User GetUser(int userId)
{
// The userId would normally be a value to use in a DB call.
return new User(userId,"Elvis", "Costello");
}

We would register the GetUser proxy via a call to the RegisterTypeForAjax
private void Page_Load(object sender, EventArgs e)
{
Ajax.Utility.RegisterTypeForAjax(typeof(User), this.Page);
}

Allowing us to asynchronously call the GetUser in client-side code with code such as:

The value returned in the response is actually an object which exposes the same properties as a server-side object (FirstName, LastName and UserId).

Remote Desktop

noreply@blogger.com (Martin) — Tue, 18 Dec 2007 15:52:00 +1100

mstsc.exe

Make your Site OffLine in IIS

noreply@blogger.com (Martin) — Tue, 18 Dec 2007 15:42:00 +1100

Add the following file app_offline.htm in the physical directory of your internet site and when the url for the site is requested the app_offline.htm file will be loaded instead of your default page.

HTM Contents can be any thing you want.

Sample contents.
This application is currently offline. To enable the application, remove the app_offline.htm file from the application root directory.