S e l v a' s B l o g

Google Translater for Indic Web ( Tamil, Telugu, Kannada, Gujarati, Bengali)

2011-06-22T04:23:00.000-07:00

Google now translates in our mother tongue too.. Sounds familiar but there is a new stuff added to the translater complier. yes, the translater actually tries to get the meaning of a word instead of simply converting a word from one language to other...

For example, If you want to convey "thanks" to a tamilian and you know only english. Now its not a problem. Just use google translater and now it translates and finds the exact tamil word for "thanks" from its tamil dictionary. Sounds interesting right? I tried few words to translate and it works.. but still google still holds this in "alpha" version as it couldn't convert a whole sentense from english to Indic languages. The reason is Indian languages often use Subject Object Verb (SOV) order unlike English, which uses Subject Verb Object (SVO) order. see the picture below

More details about Google translator check Indic Web and the URL for you to test the same.

WCF Architecture

2010-08-10T23:05:00.000-07:00

The following figure illustrates the major components of WCF.

Figure 1: WCF Architecture

Contracts

Contracts layer are next to that of Application layer. Developer will directly use this contract to develop the service. We are also going to do the same now. Let us see briefly what these contracts will do for us and we will also know that WCF is working on message system.

Service contracts

- Describe about the operation that service can provide. Example, Service provided to know the temperature of the city based on the zip code, this service we call as Service contract. It will be created using Service and Operational Contract attribute.

Data contract

- It describes the custom data type which is exposed to the client. This defines the data types, are passed to and from service. Data types like int, string are identified by the client because it is already mention in XML schema definition language document, but custom created class or datatype cannot be identified by the client e.g. Employee data type. By using DataContract we can make client aware that we are using Employee data type for returning or passing parameter to the method.

Message Contract

- Default SOAP message format is provided by the WCF runtime for communication between Client and service. If it is not meeting your requirements then we can create our own message format. This can be achieved by using Message Contract attribute.

Policies and Binding

- Specify conditions required to communicate with a service e.g security requirement to communicate with service, protocol and encoding used for binding.

Service Runtime

- It contains the behaviors that occur during runtime of service.

Throttling Behavior- Controls how many messages are processed.
Error Behavior - Specifies what occurs, when internal error occurs on the service.
Metadata Behavior - Tells how and whether metadata is available to outside world.
Instance Behavior - Specifies how many instance of the service has to be created while running.
Transaction Behavior - Enables the rollback of transacted operations if a failure occurs.
Dispatch Behavior - Controls how a message is processed by the WCF Infrastructure.

Messaging

- Messaging layer is composed of channels. A channel is a component that processes a message in some way, for example, by authenticating a message. A set of channels is also known as a channel stack. Channels are the core abstraction for sending message to and receiving message from an Endpoint. Broadly we can categories channels as

Transport Channels
Handles sending and receiving message from network. Protocols like HTTP, TCP, name pipes and MSMQ.
Protocol Channels
Implements SOAP based protocol by processing and possibly modifying message. E.g. WS-Security and WS-Reliability.

Activation and Hosting

- Services can be hosted or executed, so that it will be available to everyone accessing from the client. WCF service can be hosted by following mechanism

IIS
Internet information Service provides number of advantages if a Service uses Http as protocol. It does not require Host code to activate the service, it automatically activates service code.
Windows Activation Service
(WAS) is the new process activation mechanism that ships with IIS 7.0. In addition to HTTP based communication, WCF can also use WAS to provide message-based activation over other protocols, such as TCP and named pipes.
Self-Hosting
WCF service can be self hosted as console application, Win Forms or WPF application with graphical UI.
Windows Service
WCF can also be hosted as a Windows Service, so that it is under control of the Service Control Manager (SCM).

Processing Data Queues in SQL Server with READPAST and UPDLOCK

2010-04-27T03:16:00.000-07:00

Problem
One common processing problem that a DBA can encounter is processing rows from a table used as a data queue. Queue processing is functionality where one or more processes INSERTs rows into a database table representing a work queue with each row representing a business action that must be performed. At the same time, one or more processes SELECTs records from the same queue table in order to execute the business action required by the application while later deleting the processed row so it is not processed again. Typically, the reading processes use polling to interrogate the queuing table for any new rows that require execution of a business action. If done incorrectly, processing data queues can produce unexpected results and/or performance issues.

Solution
The following examples set up a process queue to be processed by two separate processes reading the same queue. This can be extended beyond two processes, but for this example we want to show you how two processes can work against one work queue. We’ll start with examples to illustrate issues that can be encountered.

First, let’s create a sample table and populate it with 10 records to be processed.

-- create an example queue table
CREATE TABLE DBO.QUEUE (
  QUEUEID    INT IDENTITY( 1  , 1  ) NOT NULL PRIMARY KEY,
  SOMEACTION VARCHAR(100))

GO

-- seed the queue table with 10 rows
DECLARE  @counter INT

SELECT @counter = 1

WHILE (@counter <= 10)
  BEGIN
    INSERT INTO DBO.QUEUE
               (SOMEACTION)
    SELECT 'some action ' + CAST(@counter AS VARCHAR)
    
    SELECT @counter = @counter + 1
  END

Encountering unexpected results
Open 2 separate query windows and issue the following statements in each session:

DECLARE @queueid INT

BEGIN TRAN TRAN1

SELECT TOP 1 @queueid = QUEUEID
FROM DBO.QUEUE

PRINT 'processing queueid # ' + CAST(@queueid AS VARCHAR)

-- account for delay in processing time
WAITFOR DELAY '00:00:10'

DELETE FROM DBO.QUEUE
WHERE QUEUEID = @queueid

COMMIT

As you will see, each session processed the same row! This is obviously unacceptable processing behavior, but what can we do about it?

We can eliminate this behavior by adding the UPDLOCK hint to the SELECT statement. The UPDLOCK hint tells the SQL Server query engine “Don’t allow any other reader of this row to acquire an UPDLOCK (“U” lock) because I will be promoting this lock to an exclusive “X” lock later in my processing”. It effectively reserves the row for your processing. However, as you will see, this can cause a new problem to arise.

Encountering blocking
The SELECT statement has been modified to use the UPDLOCK hint.

Open 2 separate query windows and issue the following statements again.

DECLARE @queueid INT

BEGIN TRAN TRAN1

SELECT TOP 1 @queueid = QUEUEID
FROM DBO.QUEUE WITH (updlock)

PRINT 'processing queueid # ' + CAST(@queueid AS VARCHAR)

-- account for delay in processing time
WAITFOR DELAY '00:00:10'

DELETE FROM DBO.QUEUE
WHERE QUEUEID = @queueid

COMMIT

As you can see from the modified example, each session now processes separate rows. Good so far. However, the 2nd session took longer to execute than it did in the first example even though it now processes a separate row. Why is this? It’s because an UPDLOCK (“U”) lock has been placed on the row processed by the first session and the 2nd session is forced to wait on this lock to be released before it is allowed to retrieve the next row for processing. This is highly inefficient since multiple consumers of the queue must all wait until any locks are released. So, how do we get around this?

To get around the blocking encountered in the previous example, a READPAST hint can be used in conjunction with the UPDLOCK hint. The READPAST hint tells the SQL Server query engine “If you encounter any rows that are locked, just skip them… I want whatever is not currently being processed by anyone”.

Incorporating the READPAST query hint
The SELECT statement has been modified to use the READPAST hint in addition to the UPDLOCK hint.

Open 2 separate query windows and issue the following statements again.

DECLARE @queueid INT

BEGIN TRAN TRAN1

SELECT TOP 1 @queueid = QUEUEID
FROM DBO.QUEUE WITH (updlock, readpast)

PRINT 'processing queueid # ' + CAST(@queueid AS VARCHAR)

-- account for delay in processing time
WAITFOR DELAY '00:00:10'

DELETE FROM DBO.QUEUE
WHERE QUEUEID = @queueid

COMMIT

As you can see from this latest example, each session now processes separate rows and the 2nd session is no longer blocked as evidenced by the execution time (both sessions should complete at roughly the same time).

Using the UPDLOCK hint in conjunction with the READPAST hint gives the best performance for processing queues while eliminating unexpected results and blocking.

Putting it all together
Here is an example of the above code that takes it a step further and processes all of the records in the queue. To run this drop table dbo.queue and then recreate it by running the code in the very first code block above that creates the table and loads the data.

Open 2 separate query windows and issue the following statements again.

SET NOCOUNT ON
DECLARE @queueid INT 

WHILE (SELECT COUNT(*) FROM DBO.QUEUE WITH (updlock, readpast)) >= 1

BEGIN

   BEGIN TRAN TRAN1 

   SELECT TOP 1 @queueid = QUEUEID 
   FROM DBO.QUEUE WITH (updlock, readpast) 

   PRINT 'processing queueid # ' + CAST(@queueid AS VARCHAR) 

   -- account for delay in processing time 
   WAITFOR DELAY '00:00:05' 

   DELETE FROM DBO.QUEUE 
   WHERE QUEUEID = @queueid
   COMMIT
END

Next Steps

When processing data queues, use the UPDLOCK hint along with the READPAST hint to get maximum throughput of your data queues.
Read more information about UPDLOCK and READPAST in the SQL Server 2000 and 2005 Books Online under Locking Hints.
Read more about Lock Compatibility in the SQL Server 2000 and 2005 Books Online
Thank you to Armando Prato for providing this tip!

VS2010 Tutorial: Testing Tutorial (Step 2)

2010-03-24T00:06:00.000-07:00

Last time I posted the Step 1 tutorial for creating a WPF application from scratch using Visual Studio 2010. In this post, I’m going to create a test plan and test case for the application using the new Visual Studio Test and Lab Manager project.

For this tutorial, I’m using Visual Studio Team Suite 2010 (which includes all of the roles and TFS access). I’ve already added the demo to TFS so I have full source control. For the sake of demonstration, I’ve commented out the final fix from the walk through so the label does not update:

When I run the application, the label is not updated:

The Tester

To create my test, I’m going to run the Test and Lab Manager tool from the start menu:

The main page has tabs for test plans, tests, and for tracking work items:

First I need to connect to my TFS server by click Add. My server is VLM13267036 (auto generated name by our internal Hyper-V testing tools):

I’ve already got a collection with my code stored in the Projects folder:

Next I’ll select Projects and choose the Connect option. This prompts me to set a context:

I’ll choose “Set context” which brings up the editor for my new context:

I’ll select New:

I can now edit all of the properties:

After all data has been entered, click Save and Close. The new item is now in our list:

Double clicking the item allows me to add a new test case to this test suite:

Here you can fill out all details for the test case:

Steps can now be added by clicking on the “Click here to add a step”:

I’ve added a few steps including launching the application, hitting the buttons, etc:

Now hit Save and Close to go back to the test case list. The Plan is now complete. We can run it any time a new build is produced, for each flavor of build, for different configurations, etc. To execute the test, change focus to the Test tab:

Our test plan and test case are already in the list. Right click the test case and select Run:

This will launch the test case. The manual test runner window docks itself to the left side of my desktop so I can see both the steps I want to run and the full Windows desktop:

The “Start test and record” option allows me to not only do the testing steps, but it will also allow recording a WMV of all the steps I do as well as recording my steps to help me author coded UI tests (big helper with automation). This is really handy if you want someone to see exactly what you did to produce a bug and automate testing in the future.

In this case I will select “Start test”. Notice the Test Runner now shows the steps I created above:

The first step is to “Launch the PicViewer application” which I’ll do by running the application. Since that worked, I’ll press the combo box status item behind the step and select ‘Pass’ from the drop down:

The item is now marked as passing:

I’ll repeat the process for the next two steps, so far so good:

When I get to my last step, I discover the file path isn’t actually set. That makes this item a failure. Select the drop down box and choose ‘Fail’ from the list. I’m automatically asked for comments on the failure:

Since I didn’t record a video of my steps, I would like to give the developer a screen shot of what went wrong. Select the camera tool bar button:

This will bring up a capture tool turning the cursor into a cross hair that allows me to select a region of the screen. I’ll select the top of the application to demonstrate the busted label:

Notice that the failed test now has a .png file added with the image:

I’ve got enough supporting data now so I’ll create a new bug using the toolbar:

I’m now prompted to create my bug with a description, etc:

Notice the detailed test steps I’ve taken have already been added to the bug:

As has my screen shot (the .png file):

I’ll now do a Save and Close which will commit the bug to TFS as a Work Item. Finally I’ll do End Test then Save and Close the test runner. This will return us to Test and Lab Manager.

as a tester, I could now double click the test case and see all of the same data I just saved for the failure:

I can also select My Bugs and see the bug filed for this issue (since I conveniently assigned it to me):

And just to show how everything is wired together, I can open Visual Studio, Team Explorer and look for bugs assigned to me there as well:

At this point my job as a tester is now done.

The Developer

As a developer, I can now open the bug and read through the issue. If I select Other Links I’ll find the .png which I can open to see the issue:

Sure enough, the label is not updated. If a WMV had been recorded, I could have actually watched the testing steps in action. Because the bug is quite simple to find and fix (some idiot commented out the update line!) I can simply make my fix and test it.

Now that things are fixed, I want to check in the bug fix and resolve the work item at the same time. Click on the Pending Changes tab in VS and select the correct work item:

Now we can Check In the fix:

I can now verify the bug has been Resolved:

In Summary

A key goal for Visual Studio Team System 2010 was to reduce the number of times a tester and developer wind up in a ‘no-repro’ situation. There are several things I’ve demonstrated in this tutorial which help:

Test case steps are documented and set up for repeatable execution
Pass/Fail steps are outlined and stored in bugs automatically
Video capture is allowed to see all steps taken, and screen snapshots are easy to acquire and file with a bug
System information including build number, OS, etc are recorded for you (System Info tab)
Although not shown, I could also have collected all of the historical debugging traces from the run as well
All data from test cases, results, work items, and source code are kept in TFS and can be shared by test and dev

I hope you’ll pick up Beta 1 and try this set of tutorials for yourself. Let us know how well it works for you and if you have any suggestions. I should also point out the work item tracking, auto resolve, etc are all part of VS 2008 so a great way to get prepared for the new version is to get TFS deployed today and get your projects into the system.

Enjoy!

VS2010 Tutorial: Build a WPF App (Step 1)

2010-03-24T00:05:00.001-07:00

For this post I’m going to build a WPF application from scratch using VS2010 Beta 1. Along the way I’m going to show off a few new features of the product. I built this demo using the Beta 1 build on Windows 7 RC, but it should work fine on other systems as well.

If you haven’t already downloaded the software, you can find a great walk through of how to do that on Channel 9 from Brian Keller. Brian explains how to install the entire product, including TFS. TFS is not required for Step 1 (this tutorial), but will be for Step 2.

First we’ll start off in Visual Studio 2010 and do a File, New Project. I’m going to select “WPF Application” and call my application PicViewer (this is the new Beta 1 dialog):

This will give us the default project template including a Window with a Grid and my default C# project code:

To start, I’m going to drag the Window out to be larger which you can do by dragging the actual window in the designer or you can edit the XAML Width=”” tag. I’ll make mine 700:

At the top of the application we want a button to display the Previous and Next pictures in the list. We also want to display the full path so we’ll need a label. Step 1 is to add a row to the grid. In this case I’ll select the label and move the cursor to where I want the row:

When I make the row, it also adjusts the XAML for this page as follows:

Let’s adjust the first row Height to “35” instead of “29*” just to make sure my buttons are of reasonable size. The aesthetics are really up to you.

We want WPF to do the layout of the buttons and the label. To do this, create a bound to Grid.Row=”0”. The StackPanel by default flows items vertically so let’s change the Orientation to “Horizontal”. You can do this either by using the XAML editor or by dragging the items from the ToolBox. Your final markup should look like the following:

Let’s drag a button onto the Row from the Toolbox:

I want this to be the Previous button. I’ll do this by editing the settings in the Properties window:

First change the Name field to “buttonPrev” and then change the Content setting to “Prev”. Repeat this process by dragging another button to the right of the Prev button and edit that item to Name “buttonNext” and Content “Next”. You should see the following:

This is functional, but doesn’t look good. We can add some white space around the buttons in the StackPanel by setting the margin which defines how much space should be around an item. Select the Prev button and change this setting:

which will give the button a Margin of 5 on all sides (you can independently set left|right|top|bottom as well). Repeat the same for the Next button. At this point you’ll see the following:

Finally drag a label to the right of the Next button making the Name “labelPath” and set the Width to “400”. When you are done, your XAML markup should look as follows (you can edit the text if it isn’t just right):

To display our pictures, we will need to have an Image control in the bottom. To do this, drag an Image control from the ToolBox to the bottom of the grid. This will do the following:

This is a case where having the Smart Tag feature of Windows Forms would be really handy. This is on the feature list but not yet in the WPF Designer. In this case I’m going to edit the XAML itself to remove everything the designer added except the Grid.Row, Margin, and Name settings. Make your settings look like the following and the image control will now fill the bottom of the grid with a nice white space border:

Now the look of the application is coming along and we need to add some code to make it work. To start, double click on the title bar of the Window to create a load handler:

Repeat this process by double clicking on the Prev and Next buttons. This will give you the following code outline:

For this picture viewer, I’m going to get a list of jpg files from my Windows 7 user directory and display those. What I’d really like to do is write the view code in Window1.xaml.cs in a way that makes sense to me, then go write the underlying logic. To get started, I’m going to declare a new instance of a class that doesn’t exist yet:

Because the class doesn’t exist yet, I am getting the red squiggles under the type. That’s ok, we’ll create the class in a minute.

The next step is to stub out all the view code in this file. We’ll start with the Window_Loaded() method. Notice that even though the class has not been defined, Intellisense will include the type after the new keyword so you can use it:

We want to initialize the list and display the first picture when the application starts. The code is as follows:

Once again I have parse errors for items which don’t exist which is ok. Move on to the Previous button handler and start typing in that method. When I get to the DisplayPicture function call, you’ll notice the function doesn’t show up in the IntelliSense window because it doesn’t exist yet.

If you hit ++Space you’ll change the mode into “consume first” which means I want the editor to give me these names while I’m typing. Now when I start typing, my new (and undeclared) function shows up in the list so IntelliSense doesn’t auto-complete on items already in the completion list:

My code then looks like the following:

I’m happy with this basic view logic. Now I need to actually create the support class that finds my pictures. Let’s start by placing the cursor on the PictureList class declaration then press the key and the period (+.) at the same time to expand the smart tag. You’ll get the following pop up:

Select the first menu item, “Generate class for ‘PictureList’”. This will add a new file, PictureList.cs, to the project and generate the class PictureList in that file. Now that the class has been defined, the squiggles go away:

You will then notice all the methods you have invoked on the class are showing up as syntax errors. Put your cursor in the Init() method and press +. to get the following:

Select the menu item so the code is generated for you. Repeat this process for the Peek(), Prev(), and Next() methods. If we then open PictureList.cs file, you will find the following code stubbed out for you:

Notice that because the code we wrote to consume methods like _PicList.Peek() expect a string back, the editor has automatically given the methods a return type of ‘string’.

Now I’ll add the logic to retrieve a list of jpg’s from the Windows install and give me the ability to walk through them:

The last step is to write the DisplayPicture method in Window1.xaml.cs. I can do this once again by selecting the method name and hitting +. and then fill out the code as follows:

This code will take the jpg and convert it into a BitmapImage that can be displayed. The next line of code sets the Source of our XAML image contorl to this bitmap so it can be displayed on the screen.

The program now builds cleanly. I will set a breakpoint in the Peek() method as well as the DisplayPicture method. Do this by placing the cursor on those functions and hitting the F9 button (notice the red breakpoint circle in the margin):

Now let’s run the application by hitting the F5 button. Our first breakpoint in the Peek() method is now hit:

You’ll find your breakpoint marked in yellow where we stopped. In addition you’ll find the traditional Call Stack view in the lower right. Because I’m using Visual Studio Team System, I also have the “Debug History” view on by default:

The default settings have captured interesting information about the execution of my program so far including all of the Registry accesses my program has made (either by me or the underlying system) and system events (like breakpoints, exceptions, etc).

If I hover my cursor over the _PicList variable in the editor, I get a pop up watch window. If I hover my cursor over the little square at the end and click:

then you will get a sticky DataTips window in the editor (the arrow is just to demonstrate the result, it isn’t in the editor):

This is a simple example of using the new WPF editor. The sticky DataTips window is a WPF adornment to the text buffer tied into the debugger. You can use it like a normal watch window by expanding the array contents, etc.

Let’s hit F5 and continue the program. My application now works including the Prev and Next buttons:

The only issue is the name of the file is not being updated. Click the Next button again to our break point in DisplayPicture(). There is no code to update the label in this method:

To fix this, let’s add a new line of code:

With the Edit & Continue feature you can make new code changes while the application is running. Update the code to the following:

Now press F5 to continue and the path is updated:

There are a couple of fit and finish things I’d like to change. Let’s stretch the image to fit by adding Stretch=”Fill”:

Next let’s add a rectangle to frame the picture:

You can then select the rectangle and set the Fill property to give it a color. This brings up the new inline color palate:

I chose a blue/black color and you get the following:

The final XAML markup then looks like the following:

This sample could be improved in a number of ways, including using data bound controls to enumerator classes, adding all the proper try/catch logic, etc. But my main goal here was to show off some editor / designer features so I’ll leave that as an exercise to the user.

Enjoy!

Tutorial: Getting Started with TFS in VS2010

2010-03-24T00:02:00.000-07:00

Earlier this month we announced the new Basic configuration for TFS. This configuration gives you an easy to set up version of TFS that supports source control, work items, and builds. It is a great place to migrate your Visual Source Safe assets and pick up new features in the process. Now that we have released the formal Beta 2 bits for VS2010, I wanted to do a walk through on how to get started using the system.

This post will be most helpful for those of you who have not installed or used TFS before. TFS can support sophisticated environments that include reporting, SharePoint integration, support across multiple domains, distributed databases, etc. I’m not going to cover any of that here. Instead my goal is to help you understand “why TFS” and how you can get started using the system. In a future post I will walk through the process to convert a Visual Source Safe database into TFS in case you are coming from a VSS deployment today.

First let’s talk about “why TFS?” The goal of Team Foundation Server is to create a central repository with a set of tools that make it really easy to collaborate between roles. You could try to stitch together multiple disparate systems as follows:

In this case each system has its own storage, own set of identity for assets, own commands and tools. Getting this going is like trying to hook up a set of custom stereo components: you can pull it off but it’s going to be a lot of work and you are missing out on some stuff.

What I’d rather have is a system which can integrate these items together and then enable my default work flow through the system:

This integration enables some very common scenarios. In a typical day I’m going to edit source code, build the product, test it, file bugs, fix them, lather/rinse/repeat. When the entire work flow is supported with one integrated repository then all items can be related to each other. As an example when I check in bug fixes I’d really like to see those defects resolved with the change set recorded (see sample below).

The Basic configuration of TFS allows you to do precisely this which is a big improvement over just having source control. The full version of TFS then adds new features including automated testing, virtual lab deployment, and architectural validation (to name a few). This expands your work flow as follows:

You can decide which of these new components you add when you use the Visual Studio Premium and Ultimate SKUs.

There are many ways to access TFS. As an engineer your most typical access point will be a version of Visual Studio. But if you are a tester you can use the new Test and Lab Manager product (no VS install necessary). If you are a project manager, you can also use the Web interface, Excel, Microsoft Project, or (new for VS2010) MOSS support for dashboards. More on this later.

In the rest of this post I will give you some step by step instructions on how to get going with TFS using the basic configuration for your first project.

Getting Started

Now that you have the conceptual level it’s time to hook things up. You should start by doing the steps listed in Brian Harry’s TFS post here. This will get all the required software on your machine with a default collection, creatively enough called DefaultCollection.

At this point we can connect to the TFS collection from Visual Studio. The easiest way to accomplish this is to use the Team Menu (you can also use the link from the home page):

You will be asked to find the Server where TFS lives. In this case my Windows 7 machine is called JLZB2REL. Add the server to the list using the Add button, then click Close:

At this point you can select the server from the combo box and then the DefaultCollection, then click Connect:

The Team Explorer tab will now have your server connection and DefaultCollection, but we don’t yet have a TFS Project to store anything in yet:

For this tutorial I have created a new Windows Form project to act as our sample solution (File, New Project, Windows Forms). If you try to add this new code project to source control, you will get an error. For example:

After you select the “Add Solution to Source Control” menu item you get the error “No team project source control folders are available.”:

The error isn’t that intuitive (especially given the word project is used for both TFS and inside your VS code solution but are different things). The error means you must create an actual TFS project to contain all of the assets for your work. In the Team Explorer, right click your collection and choose New Team Project:

In this case I’m going to create a TFS project for an Accounts Payable system. This project will contain all of the solutions, data, etc required for the overall system. After entering the data, click Next:

The Agile template is the default but you can also select CMMI. You can find more details on MSDN about the project template types. If you are using any agile methodologies (like TDD) this is a fine choice. After making a choice, just click Finish:

You will get various status updates as the project is being created:

After success, click the Close button:

Team Explorer will now have the project ready to hold Work Items, Builds, and Source Control:

At this point you can update the project collection. Let’s add the new solution to TFS again. Right click the project in the Solution Explorer and select Add Solution to Source Control:

At this point you could create a new folder in TFS for the solution or just take the default. When you are happy, click the OK button:

Upon success the Solution Explorer will now show the files are under source control (see the ‘+’ symbol in front of the files):

You will also see the list source control actions taken to publish the solution. Add a comment and then click Check-In:

Confirm the check-in by clicking Yes.

At this point your new solution is in TFS and ready for Work Items.

Work Items

You can create work items directly inside Visual Studio using the Team Explorer, through the web front end, and the Test and Lab Management tool. To look at your work items, open the Team Explorer and expand the Work Items, Team Queries item. You can then double click any query (such as Active Bugs) to see any items available to you:

Our TFS project is empty so there are no active bugs in the list:

Let’s create a new item just to get us in business. Select the Team, New Work Item menu. Here you can create several types of work items to track features, defects, etc. We’ll select Bug to get going:

Enter any data you want for the new bug and click Save Work Item to commit it to the database:

If you now refresh your active bug query list, you will see the new bug:

Let’s add a real bug to fix our project. In my example I just created a default Windows Forms application. We’ll want to update the title:

Now we need to fix the bug. Navigate back to the Solution Explorer, select Form1.cs then choose Check Out for Edit:

Click the Check Out button to confirm:

The file will now have a check mark next to it so you know it is open for edit:

As you update the Text property of the main window, VS will automatically check out any dependent files for you:

This is a Windows Forms application but it works on all solution/project types. Now that we are happy with the code change, select the Pending Changes tab in the bottom of VS:

In this case we are fixing a bug, so click the Work Items icon button:

Select bug #2 which tracks our title error. We are going to resolve it with this check-in:

Add any comments you want and click Check-In, then Yes to confirm:

If you refresh bug #2, you will now see the status changed to Resolved and the history is updated:

Notice the change set (the set of source control changes) have been automatically included in the history.

At this point you could continue to create and fix bugs as required to ship your solution.

Other Ways to Explore TFS

I mentioned that you don’t have to use VS itself to access the TFS repository. We’ve done a lot of deep integration with other clients like the Web and Office. As an example, I can simply pull up my web browser and go right to my server by using the server name (where 8080 is the default port): http://jlzb2rel:8080/tfs/

At this point I can explore my collections and projects. If you select the new AccountsPayable project we just created then the Continue button, you get more details. In this case by navigating to the Work Items tab I can find the bugs in the system including our newly resolved bug:

This is a really easy way to explore your project from any machine with no setup required. There is similar support for using Excel, Microsoft Project, etc. This kind of access makes it easy for all people working on your project (engineers and project managers) to work together.

At this point you have a very useful set of assets you can use to get your job done. For those of you using VSS today, you might be very happy with just this level of support. You can put down this tutorial now and come back later if you want to try some advanced features, for example the testing scenario I showed using beta 1 in this tutorial.

Build Support

The next typical part of your work flow will be to automate your builds for the product. Assuming you followed Brian’s installation instructions, you now have local build support on your machine with TFS Basic. The first step is to navigate to the Team Explorer, right click on Build Definitions, and select New Build Definition:

This will give us a set of definitions to fill out, just like a code project property page:

The Trigger page allows us to decide when builds are kicked off. You have many options to pick from:

By default this is manual which is the option we will use. We will have to kick of our own builds with this option.
Continuous Integration is very helpful when you want to have a new build after every check-in. This allows you to validate new changes right away rather than waiting later when many check-ins get mixed together.
Rolling builds give you a way to batch changes together which is very handy when builds are starting to take a while and you can’t afford to do every one.
Gated Check-ins allow you to ensure all check-ins build before they are committed to TFS. This makes sure you never expose a build break to other members of your team.
Scheduled builds are useful for getting a daily build out for the entire team to try out.

You can create and use many different build definitions which allow you to employ different build types for different purposes.

You can explore all the tabs at your leisure (each is fully documented with the product). But we need to resolve the yellow warning sign on Build Defaults by giving the build a place to store our new build, in this case a public UNC I created on my machine:

Now you can save the build definition to TFS. If we go back to the Team Explorer we can queue a build of the project:

We’ll get a confirmation dialog where we can just select the Queue button:

This will then queue off a build on my machine as shown by the status page:

If you double click the queued build you will get the detailed status of the build:

From here you can see warnings and errors, view the log file, navigate to the drop, etc. As an example if you select the “View Log File” link you can see the executed build script (subset):

If you select the Open Drop Folder link you will be taken to our drop location:

Now anyone can pick up the build and do their daily testing, release to a customer, etc.

At this point you really have everything you need to make full use of the Basic configuration of TFS.

In the future I will do a tutorial on how to hook up the Virtual Lab system (part of Visual Studio Ultimate) which allows you to deploy complex applications to a Hyper-V environment and do automated testing.

Creating a New TFS Collection

[Note this section is totally optional] You can store all of your work in one TFS Collection if you like. If you are a Visual SourceSafe user today, this is just fine and you can skip this whole section. But if you want to create a new top level collection, it is pretty easy. The first step is to start then Team Foundation Administration Console:

After the console starts, select the Team Project Collections item and click the “Create Team Project Collection” link:

Fill in a name for the project collection and any description you want, then click Next:

Accept the defaults for the data tier, then click Next:

The Basic configuration for TFS does not support Lab Management, so just click Next on this step:

At this point all the required data is configured and you can click the Verify button:

The verification step will ensure the collection can be created:

Once it passes, click the Create button:

This will provision all the required pieces of the TFS store per our configurations. Click Next and you are done:

You will now see the new project collection with the default version:

Sample: Get Calendar Data Using Exchange Web Services (C#)

2010-03-23T23:59:00.000-07:00

When someone asked my former manager what he did on a daily basis his answer was “Go to meetings and delete email”. Unfortunately that often describes my life as well. It is always challenging to manage your time. I want to ensure I’m spending enough on technology, people, customers, etc. To make this easier, I’m using the Categories feature of Exchange to code each meeting I have (these are my custom categories):

At a glance I can then tell what kind of meeting I’m headed to next. But I still need a way to understand how I’m spending my time every month. What would be great is to collect all the category data from all my meetings and then get the ratios. This blog covers a sample that does that.

There are several ways you can get your calendar data. In this case the task is very simple: collect all calendar items in a given month including the category setting. The easiest way to do this is to use Exchange Web Services support to ask the server for the data directly. The sample has a library which can be used to connect to EWS and collect all the calendar items and a console application which provides an easy way to drive the program logic. The following shows the overall structure of the sample code (click for larger image):

The diagram was generated using new Generate Dependency Graph feature of Visual Studio Ultimate. The graph is created by shredding the binaries themselves so we find everything.

There are a few key areas to look through for EWS code. The first is the GetExchangeProxy helper which sets up the connection to Exchange using ExchangeServiceBinding. In this case we are using integrated Windows security so that a userid/password is not required (you could supply them as an alternative):

The next interesting helper method is BuildQueryFilter which is responsible for creating a FindItemType filter class. This class allows you to construct a query for the server to find the data we care about. The code builds up a series of arguments to scope calendar items between the start and end dates. For example, this snippet of code sets a criteria of all dates greater than or equal to the start date:

A similar block of code sets the filter for less than or equal to the end date. Finally these two conditions are combined with an And clause to essentially mean “>= start AND <= end”:

Once the filter is set, we can retrieve all of the calendar items we asked for. In this case I’m returning the array in our own CalendarItemList which will allow us to enumerate the data from the client code. The GetNextItem method will then strip the full Exchange calendar item (with over 100 fields) down to just a handful we care about and return the data in a CalendarItemData instance. There are a huge number of fields available for return. You can use the DebugTraceCalItem helper method to dump the entire type if you are interested in pulling back more data.

The console application then becomes pretty easy: parse and validate all the arguments, connect to the exchange server, then write each calendar item out in a comma separated view (CSV) format. The output can either be written directly to a file or to the console for redirection to other locations. At that point it is very easy to simply open the file directly in Excel where you can edit it, create charts, analyze it, etc.

I’ve included a sequence diagram in the project which demonstrates the core logic of the Run method (click for larger image):

(Note that generating a sequence diagram with VS Ultimate is very easy: just place your cursor in the method and right click to run “Generate Sequence Diagram”)

Running the application is now very simple:

timespent /start:9/1/2009 /end:9/30/2009 /out:c:\temp\sept09.csv /mailpath:https://mydomain/ews/exchange.asmx

“mydomain” in this case is the domain address for your Exchange server. You can get this from your exchange administrator (it will likely match the path you are using on your phone to sync your mail over the air).

You can download the Exchange SDK from MSDN here. You can download a full copy of the source code here.

Enjoy!

Custom Profile Properties

2010-03-23T23:52:00.001-07:00

.NET Framework PropertyGrid Control and supporting API

Most of the “magic” that is enabling this example has been in the .NET framework for a number of years now. Check out this article for a broad overview of what is required to display properties in the .NET PropertyGrid. Thisold article and this one are also good for background information.

The three main .NET types that I made use of to create this example are:

TypeConverter – I derived a type off this class in order to proffer up the actual property that was used to expose my new type instance. This derived type is also responsible for converting the custom type to other types as needed.
PropertyDescriptor – Derived off this type in order to handle the actual setting and getting of the binary property information.
UITypeEditor – Derived off this type in order to display the custom editor seen in the above image

With that, we’re ready to get going!

Step-by-Step Overview

Here are the steps required to add a custom stereotype property instance to an existing profile. ( In this example, I add a new property to the “C# class” stereotype, found in the “C# Profile” that ships in the box. ):

Create a new VSIX extension to ensure assembly load and to ease testing
Add new property to profile
Create a new C# class that holds the data of our new property
Derive a new type from TypeConverter
Derive a new type from PropertyDescriptor
Derive a new type from UITypeEditor
Create a new Dialog to edit the values of your custom property

1) Create a new VSIX extension

I talk about creating VSIX extensions a little here, and Peter goes into detail here. The code I’m going to show you below is actually code running on the very-soon-to-be-made-public Release Candidate. The RC is so close to shipping, that I figured I’d show code targeting that build rather than Beta2, as it will also be correct for the RTM bits. But if you just can’t wait, you should be able to figure out how to make this code work on Beta2 bits without much hassle, especially after reading the two posts I just mentioned.

All that said, create a new VSIX project, add a new class, and throw in this code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Modeling.ExtensionEnablement;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml;

namespace CustomProfilePropertyTest
{
[Export(typeof( ICommandExtension))]
[ClassDesignerExtension]
class CommandExtension : ICommandExtension
{
public void Execute(IMenuCommand command)
{
}

public void QueryStatus(IMenuCommand command)
{
}

public string Text
{
get { return typeof(CustomProfileProperty).AssemblyQualifiedName; }
}
}
}

This extension is really just designed to bootstrap your new property type assembly into Visual Studio, as well as give you a quick way of seeing the fully qualified Assembly name by putting it into a menu item on the class diagram. So on my box, my menu item, given the above code, looks like this:

You’ll notice that this project has been signed. This is very important. Your custom TypeConverter ( more later ) will not be loaded by Visual Studio if it is not contained in a signed assembly. Don’t forget, or you won’t see the right results!

Easiest way to sign your assembly is to bring up the property editor of your project, click on the “Signing” tab, and click the appropriate settings:

2) Add new property to profile

Now open up the CSharp.profile file found here: %Program Files%\Microsoft Visual Studio 10.0\Common7\IDE\Extensions\Microsoft\Architecture Tools\UmlProfiles\CSharp.Profile. We’re going to add a new property to the “C# class” stereotype. You need to modify this file in two places.

The first place is in the “properties” section of the “C# class” stereotype element. Here’s a shot of my property, right after the “Is Partial” property:

Take note of the property name ( “CustomProperty” ), the display name ( “Custom Property Example”, which is what the user will see in the property editor ), and the name of the externalTypeMoniker element. This is the most important part of this example. This is where the fully qualified assembly name comes in.

The second place is is the propertyTypes section. You need to add a new “externalType” entry, like so:

Again, make sure you get those two entries right, or things won’t work right.

3) Create a new C# class that holds the data of our new property

Now create the type that will represent your new stereotype property. Here’s what I used:

[TypeConverter( typeof( CustomProfilePropertyTypeConverter ))]
[Serializable]
public class CustomProfileProperty
{
public string Name { get; set; }
public int Age { get; set; }
public DateTime Birthday { get; set; }
public Color HairColor { get; set; }
}

You’ll notice that I have applied two attributes to the new type, both quite important. The TypeConverter attribute associates the “CustomProfilePropertyTypeConverter” with the “CustomProfileProperty” type. The framework now knows what type of TypeConverter to use when dealing with a CustomProfileProperty. ( We’ll be creating the TypeConverter in our next step, so hang tight! ).

The “Serializable” attribute is also important, as I make use of the BinaryFormatter object later on. This makes serializing the instance data of this type real simply, allowing us to store that data in a string variable associated with the stereotype property instance ( again, more later ).

4) Derive a new type from TypeConverter

Now let’s create that new custom TypeConverter. Here’s the code:

public class CustomProfilePropertyTypeConverter : TypeConverter
{
public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, System.Type destinationType)
{
// We're only looking for conversion to the String type, and then only if the value coming in
// is of type CustomProfileProperty. This will be an indicator to the user that the "complex"property
// has actually been set.

if (destinationType.Equals(typeof(String)) && value is CustomProfileProperty)
return "Property Set";

return base.ConvertTo(context, culture, value, destinationType);
}

public override bool GetPropertiesSupported(ITypeDescriptorContext context)
{
// Need to return true here in order for the GetProperties method to be called
// by the framework

return true;
}

public override bool CanConvertTo(ITypeDescriptorContext context, System.Type destinationType)
{
// Need to respond true for conversions to String in order for the ConvertTo method to be called. See above

if (destinationType.Equals(typeof(string)))
return true;

return base.CanConvertTo(context, destinationType);
}

public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context,object value, Attribute[] attributes)
{
if (context != null && context.Instance is IEnumerable)
{
IEnumerable props = (IEnumerable)context.Instance;
var propInstance = (from i in props where i.Name == "CustomProperty" select i).First();

PropertyDescriptorCollection collection = new PropertyDescriptorCollection(
new PropertyDescriptor[] {
new CustomProfilePropertyDescriptor(propInstance, "Custom Property Example",new Attribute[] { new BrowsableAttribute(true) })
});

return collection;
}
return null;
}
}

I put comments explaining most of the simple methods, but let me describe what’s going on in the GetProperties method. When examining an element out of the UML store, you can find out what Stereotypes are applied to a particular element which returns you a collection of IStereotypeInstances. Each IStereotypeInstance can have many IStereotypePropertyIntance objects. Hopefully the following image will make this more clear, and show how these types equate to what you see in the CSharp.profile file:

So the first line of substance in this method is looking for the the IStereotypePropertyInstance named after our custom type we added in step 2. Once we find it, then we create a new instance of our CustomProfilePropertyDescriptor passing in the IStereotypePropertyInstance object that ultimately owns this custom property. By creating this custom property descriptor, we are essentially adding an entire new hierarchy of values that are ultimately stored on the root IStereotypePropertyInstance ( in this case called “CustomProperty” ).

In the example above, I’m only creating one property, but you could create as many as you need.

5) Derive a new type from PropertyDescriptor

Here’s the code that shows my derived type off of PropertyDescriptor:

public class CustomProfilePropertyDescriptor : PropertyDescriptor
{
public CustomProfileProperty CustomProfileType{ get; set; }
private IStereotypePropertyInstance Instance {get; set; }

public CustomProfilePropertyDescriptor( IStereotypePropertyInstance instance, string name, Attribute[] attrs)
: base(name, attrs)
{
Instance = instance;
}

public override bool CanResetValue(object component)
{
return true;
}

public override Type ComponentType
{
get { return typeof( CustomProfileProperty); }
}

public override object GetValue(object component)
{
return CustomProfileType;
}

public override bool IsReadOnly
{
get { return false; }
}

public override Type PropertyType
{
get { return typeof(CustomProfileProperty); }
}

public override void ResetValue(object component)
{
CustomProfileType = null;
}

public override void SetValue(object component, object value)
{
if (value is CustomProfileProperty)
{
CustomProfileType = value as CustomProfileProperty;

using (MemoryStream stream = new MemoryStream())
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, value);

byte[] contextBytes = stream.ToArray();
Instance.Value = System.Convert.ToBase64String(contextBytes);
}
}
}

public override bool ShouldSerializeValue(object component)
{
return false;
}

public override object GetEditor(Type editorBaseType)
{
return new CustomProfilePropertyUITypeEditor();
}
}

Most of the methods are self explanatory, but I’ll call out a couple. In the SetValue method is where the data that the user has provided for your the new property gets set back onto the IStereotypePropertyInstance object associated with the Class element. Ultimately, that data is serialized back into an XML file, so you can’t just set the Value property on Instance to some XML markup, as Value is stored as an XML attribute. So we’ll just serialize the object to a MemoryStream, then convert into a string value. This works great in this instance, as Visual Studio will later use BinaryFormatter to rehydrate the serialized object when reading the information back from disk at a later time.

You’ll also notice the GetEditor method, which is where you can return you’re derived type off of UITypeEditor, which I’ll show you now.

6) Derive a new type from UITypeEditor

Here’s the code:

public class CustomProfilePropertyUITypeEditor : UITypeEditor
{
public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
{
return UITypeEditorEditStyle.Modal;
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider,object value)
{
CustomProfilePropertyEditor editor = new CustomProfilePropertyEditor( context.Instance asCustomProfileProperty);

IUIService uiService = provider.GetService(typeof(IUIService)) as IUIService;

if (uiService != null)
{
if (uiService.ShowDialog(editor) == System.Windows.Forms.DialogResult.OK)
{
return editor.CustomProfileType;
}
}

return null;
}
}

The key in this type is to return UITypeEditorEditStyle.Modal from the GetEditStyle method in order to get the browse button ( the button with the “…” as the caption ) on the property grid for the property. Then when the user clicks on that button, the EditValue method is called. In our case, we new up our new dialog, use the IUIService provided by Visual Studio to show that dialog, and if everything went ok, return the newly modified custom property.

7) Create a new Dialog to edit the values of your custom property

The dialog used to modify the custom properties can literally be anything. I created that simple WinForm dialog in no time by leveraging the Data Sources window to add a Object data source type to the form and binding it to the CustomProfileProperty type we created in step 3. But just for completeness sake, here’s the code:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace CustomProfilePropertyTest
{
public partial class CustomProfilePropertyEditor : Form
{
public CustomProfileProperty CustomProfileType { get; set; }
public CustomProfilePropertyEditor( CustomProfileProperty customType )
{
InitializeComponent();

CustomProfileType = customType ?? new CustomProfileProperty();

customerProfileBindingSource.Add(CustomProfileType);
}

private void OKButtonClicked(object sender, EventArgs e)
{
CustomProfileType.Name = nameTextBox.Text;
CustomProfileType.Birthday = birthdayDateTimePicker.Value;
Close();
}
}
}

Summary

So that’s it! I hope you can make use of this technique, as it is an easy way to add more complicated types and data to your modeling data that doesn’t require any new serialization strategies, and participates nicely with the Visual Studio undo / redo mechanism without you having to be aware of the details. Cheers!

Sneak peek at the first “Feature Pack” for VS2010 Visualization and Modeling Tools

2010-03-23T23:51:00.001-07:00

What’s in this “Feature Pack”?

There are three major areas that this “Feature Pack” is designed to address:

Increased Visualization Support
1. Visualize your native ( C++ ) code
2. Visualize your WAP or Web Sites or ASP.NET MVC code
Increased UML support
1. Code Generation from UML Class diagram
2. Rapid population of Modeling Store from Architecture Explorer
3. XMI 2.1 Import
Increased support for Layer Diagram Extensibility

Increased Visualization Support

In the RTM release of VS2010, we have great visualization support for managed assemblies. We don’t have any support for native developers, nor did we have first class support for Web projects or Web Sites developed inside Visual Studio.

With this “Feature Pack”, you now have some great functionality for both native and web projects in Visual Studio 2010.

Native Code Visualization

All of the visualization features in the RTM version of VS2010 support managed code ( runtime versions 1.1 on up ). This “Feature Pack” will now allow you to visualize your C++ projects, as well as supporting C++ images ( .dll or exe ), with extra support if you also have the PDBs with those images. The support is in three forms:

Architecture Explorer – allows you to explorer your solution just like you would with managed code via the cascading browser
#include dependencies – pick a header file, and visualize the include dependencies associated with that header file. This is great stuff when you are trying to determine just how bad touching a particular header file will mean to your already taxed build times!
Inter-binary dependencies – drag a native DLL or EXE onto the DGML document surface, and we’ll crack those images and tell you how they are related.
Standard Graph Support – if you select the Generate Dependency->By Assembly menu with a C++ project loaded, you’ll get a very similar look graph that you are used to on the managed side. Here’s a shot of a simple MFC application showing dependencies on the ATL CString type:

Web Application and Web Site Project Visualizations

If you are using Web Site, Web Application Projects, or taking advantage of the latest ASP.NET MVC framework, we’ve got some great stuff coming for you as well!

We will show you not only how your pages are dependent on each other, but how they are also dependent on controls, and how they are related to the code-behind logic behind them, if applicable. And of course, the ability to drive right into your pages, master templates, and code directly from the graph will be supported.

Visual Studio 2010 and .NET Framework 4 Beta 2!!!

2010-03-23T23:48:00.001-07:00

WooHoo!!!

There have been simply a *ton* of changes to the product since last we chatted, both from a functionality perspective ( we’ve made lots of progress that I can’t wait to tell you about! ) to changes in the Visual Studio SKU structure, to logo and name branding, and pricing changes. MSDN itself has been redesigned!

But first and foremost, if you are an MSDN subscriber, stop what you are doing and go down load Beta2 and the .NET Framework 4 bits from this link. I really think you’re going to like what you see! And Beta2 is a “Go Live” release, which means we are encouraging you to use the product in production, with an implied understanding that if serialization formats or what have you change between now and RTM, we’ll provide a way to move your data and artifacts forward so that you don’t lose any work.

If you aren’t an MSDN subscriber, general availability for the release will happen on October 21st.

To get more information on the new packaging and licensing details, please visit this link. But here’s a taste of the new Visual Studio 2010 logo:

And to top everything else off, the official launch date for Visual Studio 2010 and .NET Framework 4 is March 22nd, 2010!

SKU Structure Change

A couple words about the changes that you can read more about here. The Architecture Edition, along with many of the features of the Team System 2008 Development box, are now part of the Visual Studio 2010 Ultimate product.

The Visual Studio product line has moved to more of a “Russian Doll” model in regards to how the features are represented in each version of the product. At the top of the stack, including all the features and functionality of Visual Studio 2010 Premium and Visual Studio 2010 Professional, is the capabilities found in Visual Studio 2010 Ultimate. Going forward, I’m going to be spending my time with posts describing the Modeling and Visualization technologies in Ultimate, as that is what I know best, as that is what my team does. :)

But quickly, here’s a general view of the capabilities found in the new SKU structure. Please understand that from a feature perspective, Ultimate contains everything you see in this list ( all the Premium + Professional features ), plus the Ultimate specific features.

The features in red are the ones my team is responsible for delivering. Those features are the ones I will continue to blog about in depth in the days and weeks ahead.

Microsoft Visual Studio 2010 Ultimate ( includes all features from Premium and Professional SKUs ):

IntelliTrace
UML Modeling
Layer Diagram & Architectural Validation
Architecture Explorer
Web Testing
Load Testing

Microsoft Visual Studio 2010 Premium ( includes all features from the Professional SKU ):

UI Test Automation
Test Impact Analysis
Performance Profiling
Static Code Analysis
Code Coverage
Code Metrics
Database Change Management
Database Deployment
Database Unit Testing
Test Data Generation
Read-Only UML, Layer, and DGML Graphs

Microsoft Visual Studio 2010 Professional:

Silverlight Tools
Multi-Core Development
Sharepoint Development
Cloud Development
Web Development
Windows Development
Generate from Usage
Office Development
New WPF Editor
Customizable IDE

So stay tuned, as I’m planning on a number of posts that are designed to drill into the new features available in this beta 2 release of Visual Studio!

“First-time Experience” with Arch Tools

2010-03-23T23:46:00.000-07:00

Ok, you’ve downloaded the Beta 2 bits of Visual Studio 2010 and .NET Framework 4.

Now you want to explorer the new Modeling and Visualization tools. This post will help you make those first couple of steps.

1) Launch Visual Studio

Notice the new top-level menu item called “Architecture”:

With no solution open, selecting the menu item simply results in the following:

2) Select “New Diagram…”

After a couple of seconds, a dialog box appears, which looks like this:

This dialog makes it very easy to see all the diagrammatic capabilities that are new in 2010. You see the ability to create a total of five different UML diagrams, a Layer Diagram option, and last but not least, the Directed Graph Document.

I’ll go into detail on all these later, but for now, just accept all the defaults and hit the OK button.

Now, because you do not have any solution open, you will see the following dialog:

( You’ll see the same dialog even if you have a solution open, but no Modeling projects exist in the solution ).

BUG ALERT:

Unfortunately, a little bug slipped through the cracks that I want to point out so you don’t waste your time logging a bug that has already been fixed.

If you hit the cancel button at this point, you’ll see this dialog:

You can hit the OK button and no harm will be done, but not quite the experience we’re looking for. ;)

Take the defaults and hit the OK button. You should see something similar to what you see in the image below ( minus my red annotations of course ):

At this point, your ready to start adding items to the class diagram to your hearts content. This is a pretty common first couple of steps that you will take as you start using VS 2010 Ultimate to model your problem domain using the various UML diagrams.

The steps above are very similar if you have an existing solution already open, but I do want to point out a couple of differences. The steps below are quite common when you are looking to the tool to help you understand an existing code base.

3) Open an existing solution

Just open any solution you’ve got within reach. I’m going to open up the old standby, Petshop 4.0. ( This will result in the current solution being closed, but don’t worry about that. )

Once your solution is opened, you’ll see some new additions to the “Architecture” menu item:

Go ahead and try one of the menu items out. I selected the “Generate Dependency Graph->By Assembly” menu item, which resulted in a graph that looks like this:

Don’t worry about the details on this yet. We’ll be diving into those details in future posts. For now, we’re just kicking tires.

One last thing to point out before calling this post done.

4) Open up a source file

In my case, I’m going to open up the Order.cs file in the OracleDAL project.

Find a decent size method in your class, right click in the text editor, anywhere within the method and select …

5) Generate Sequence Diagram

You’ll see this dialog:

Just take the defaults and hit OK. In my case, a diagram is generated that looks like this:

Again, I’m not going to go into any more detail on this than I have just done. I just wanted to point out a few very common ways into some of the new features in the product.

As I pointed out in this previous post, I’ve got a lot of topics I’m going to nail down for you. I don’t have any specific order that I’m committed to following, so if you have some preferences of which topics I do first, please let me know!

UML Profiles and Visual Studio 2010 Ultimate

2010-03-23T23:44:00.001-07:00

By now, you’ve all got the Beta2 version of VS 2010. This post will discuss some basics that you need to know about profiles, and why they matter. My next post will discuss how to create your own.

Let me first start by pointing out the excellent documentation around this feature, found here. Almost everything I’m going to discuss is found there and the various references therein. I’m just going to hilite the essence of the feature.

What the heck’s a Profile?

A profile, as defined by the UML spec, is a

“…mechanisms that allow metaclasses from existing metamodels to be extended to adapt them for different purposes.”

( Clear as mud right? :) Think of a profile as a container of new meta data with all the constraints that restrict or allow that new meta data to be applied to particular types in your UML model. What this then allows you to do is apply that Profile, and then apply a stereotype to a particular element type that then exposes some new fields or what have you. In its simplest form, this would result in some new fields in the property editor for that type that you can then manipulate. In a more complex form, this could restrict what relationships a type could play in, etc.

A quick example to drive this home.

Here’s a shot of a property editor for a selected class:

Notice there are no properties under the Stereotypes property, but if I apply a stereotype, suddenly a bunch of new properties appear, as seen below:

I’ve circled the changes that have occurred to that class after applying that stereotype. Lots of new properties plus an annotation on the class element on the diagram indicating that the stereotype called C# class has been applied.

Applying a Profile

You can apply any profile, be it a custom made or standard profile that ships in the box, on any UML Package or package derived type. So for example, if you create a UML Project and select the root element in the UML Model Explorer, you’ll notice two things: 1) That the project element is actually a UML element of type Model ( which is ultimately derived off of Package ), and 2) that two standard profiles are already applied on that element.

We will ship three profiles in the box by the time we ship VS 2010 Ultimate. Two profiles that are standard to UML ( Standard Profile L2 and Standard Profile L3 ) and one specific to C# ( named, surprisingly enough, C# Profile:) ).

You apply ( or remove ) a profile to a Package ( or package derived type like Model ) by selecting that element and setting the profile property. So if I select the “ProfileExample” in the UML Model Explorer as seen above, here’s what the Profile property looks like with the currently available values:

Notice that the values are check box entries, allowing you to check or uncheck that profile. Apply or remove, your call.

Profile applied, now what?

Once you’ve applied a prototype to a package, a number of new stereotypes become available to any and all contained elements in that package dependent on the type of the element. As I mentioned earlier, by default the two standard UML profiles are automatically applied to the Model element that represents your modeling project. So in our example above, when I select “ProfileExample” and then expand the Stereotypes property, here’s what I see:

If I selected “Sub Package One”, which is contained by “ProfileExample”, I see this:

Notice how “metamodel” and “systemModel” are not present in the list. That is because the “Sub Package One” element is a UML Package, where as the “ProfileExample” element is a UML Model. The list of stereotypes is completely dependent on element type. To further the example, if I select “Class1” contained in “Sub Package One”, I see this:

And to just make sure everyone is on the same page, if I go back up to the “ProfileExample” element and uncheck every profile, then select “Class1” again, I will get no stereotype options.

Stereotype applied, now what?

Once you apply a stereotype to a particular element, a number of things can happen. If you look back up to the second image in this post, I’ve applied the C# Class stereotype to “Class1”. That results in a stereotype adornment on the element itself, as well as a number of properties that are now made available on the element.

Important to note that these new properties are now made available to any element that the stereotype is applied to, but the individual properties exposed by those stereotypes ( e.g., the “Is Partial” property for the “C# Class” stereotype ) and the values associated with them are stored on the individual instance of the applied element.

Ok, got it, but why does all this Profile / Stereotype stuff matter?

Fundamentally, this is just another way to extend the semantic meaning of your models. It allows you to add more information to your models without having to invest in something more powerful ( like building a new DSL ) when all you want is a few boolean fields added to your elements! And once that new data is there, you can also lean on that added information in other scenarios, such as controlling how code is generated from the model based on applied stereotypes and the values therein.

With the extension capabilities in the product, this becomes quite trivial. For example, if you follow the steps outlined in Peter’s post here, you can quickly add a menu item that manipulates those stereotypes of selected elements. The code below adds a menu item to the UML class diagram, looks for selected UML classes, and pulls the stereotype that matches the “C# class” stereotype if applied:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.VisualStudio.Uml.Extensions;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Modeling.ExtensionEnablement;
using Microsoft.VisualStudio.Uml.Presentation;
using Microsoft.VisualStudio.Uml.Classes;
using System.Windows.Forms;

namespace ExampleUMLExtensions
{
[Export( typeof( ICommandExtension ))]
[ClassDesignerExtension]
public class MenuGesture : ICommandExtension
{
// IClassDiagramContext
[Import]
public IDiagramContext Context { get; set; }

public void Execute(IMenuCommand command)
{
var selectedClasses = Context.CurrentDiagram.GetSelectedShapes();

var stereotypeInstance = (from shape in selectedClasses
where shape.Element is IClass
from stereotype in shape.Element.ApplicableStereotypes
where stereotype.DisplayName == "C# class"
select stereotype).Fist();

// Party on the Properties property collection of the found stereotype instance
// ...

}

public void QueryStatus(IMenuCommand command)
{
command.Enabled = true;
command.Visible = true;
}

public string Text
{
get { return "Manipulate Stereotype"; }
}
}
}

Next time…

Like I mentioned at the start of this post, next time I’ll dig a little deeper into what is needed to create your own profile, and how you can make that profile available to your friends and neighbors. :)

Visualizing large code bases with VS2010

2010-03-23T23:42:00.001-07:00

Chris Lovett has just posted a *great* video on how to manage larger code bases with the new visualization tools in VS2010.

He shows techniques on how to use the “Custom…” dialog ( below ) to control how a DGML document is created as well as numerous techniques involving the cascading browser we call the “Architecture Explorer”, and layout strategies.

The video is 20 minutes that is highly leveraged, so please take the time and check it out! You’ll not only learn some great techniques on visualizing your larger code bases, but other little tips and tricks, such as hitting Ctrl-Alt-Shift-F12 twice inside Visual Studio will force the runtime to garbage collect! Great stuff! :)

Layer Diagram

2010-03-23T23:40:00.000-07:00

At TechEd2008 this year, the Rosario April CTP version of the VSTS Architecture Edition bits were demo'd during BillG's keynote by Brian Harry. Brian demonstrated the Architecture Explorer and the Layer Diagram. The Architecture Explorer is part of the April CTP, but the Layer Diagram did not make that CTP. I've received so many questions about that designer that I wanted to elaborate on the features of the diagram that you saw in the keynote, and describe the problem that diagram is out to help solve.

The Layer Diagram is designed to allow you to specify the various layers that make up your system's architecture. It is a way to describe what you believe your architecture is, and then provides you a way of discovering what it really is. :)

The diagram itself is very simple in notation, with only two main tools in the Layer palette, the "Layer" shape and the "Dependency" link. You can name those layers, describe allowed dependencies between those layers ( more on this later ), map your existing assets ( code, docs, what have you ) onto those layers, and validate that your architecture is conforming to the diagram.

Here's a very simple layer diagram that shows a typical system with a UI or Presentation, Business or Domain Logic, Data, and Logging layer:

Here is that same diagram "annotated" a bit, to describe some of the capabilities in the diagram:

There are a number of ways you can approach this diagram, below is one:

1. Create a new Layer diagram from scratch

2. Draw the various Layer shapes and name them appropriately

3. Use the Dependency connector to indicate the direction of allowed dependencies. As I mentioned in the annotated image, the lack of dependency links is also meaningful, in that you are indicating to the system that dependencies between two layers is not allowed.

4. Specify additional constraints per layer that you would like to see enforced. As an example, you will be able to indicate on a per layer basis what namespaces are allowed in that layer, and which are not allowed.

5. Map your physical assets to your specified layers. You map your assets ( code, documentation, entire projects or solutions ) via drag & drop from the Architectural Explorer and Solution Explorer. ( Later in the cycle, there will be more capabilities added around this step. )

6. Validate your architecture

This last step is where things get interesting. Steps 1-5 were all about specifying what you believe your architecture is and should be. Step 6 is all about telling you what it is.

But when does validation occur, and what do violations look like?

Validation can be done via a simple context menu gesture ( right click on the diagram and select "Validate" ), or as part of a check in policy, and as part of your build. The product will examine your Layer diagram ( you can have many by the way ), discover what assets are mapped and what constraints are being specified, and then analyze those assets with those constraints in mind.

A violation ( currently ), shows up in the Error window.

This should give you a better idea of what this diagram is all about, and you'll be able to take it for a test drive in our next CTP this fall.

Favorite VS2010 Features: Layer Validation

2010-03-23T23:38:00.000-07:00

Building a Layer Diagram

We’ll pick up from the last post using the Tailspin Toys sample application. Now that I understand the basic structure of the application, I want to make it adhere to my architecture. In this case the application was written as a model view controller (MVC) style application. Let’s make sure it is actually implemented that way. To start with, let’s create a new layer diagram using the Architecture menu:

This will give me an empty Layer Diagram surface where I can specify the layers of my architecture. With a little bit of work, we can get all the basic layers we are ok with on the form:

This is a reasonable architecture, but we need to figure out how the physical implementation actually maps into this logical architecture. To do this we can drag the actual class implementations into the corresponding layer they implement:

After all you have placed class implementations into the right layers, you can ask the system to figure out the dependencies by right clicking on the design surface and choosing Generate Dependencies:

Once you’ve completed the process you wind up with a diagram like the one below. The Layer Explorer can be used to see contents of each layer:

Updating Your Implementation

At this point we have a diagram describing what has physically been built. I have one problem with it though: in the MVC pattern we don’t want the View (‘Web’ in this case) talking directly to the Model. This most often happens when someone writes code which directly accesses a data layer without going through the proper business logic (an easy enough mistake to make). Let’s fix this by deleting the line in question:

After we delete the line, we can right click the graph and choose Validate Architecture:

At this point Visual Studio will analyze all dependencies looking for any which violate the layer diagram. Errors will then show up in the error list:

I can now go through and fix my code, repeating the Validate Architecture step until things are clean.

Enforcing Layering in the Build

At this point I have a clean architecture and an implementation which matches. We all know what could happen next: as tasks are implemented and bugs are fixed, the code is going to drift from the architecture again. We need a way to keep things in sync.

To solve this, we’ll add a new TFS Build Definition which uses Gated Check-in to enforce the architecture:

When you use Gated Check-in, all changes you submit to TFS must first pass all the normal tests (build clean, pass test cases, etc). In this way if you have errors, the changes aren’t applied and never get out into your build. In this case we’ll add one more step in the Process tab:

Now the build will also do the architectural validation step preventing any violations from getting checked into TFS.

Summary

There are a few key concepts:

If you are doing brand new code, you can start with the logical design and work your way towards implementation
If you are starting with existing assets, you can also discover what you have and work towards an ideal logical design
Once you get physical and logical in sync, you can enforce that through automation (such as gated check-in) which avoids “drift”

Building Web Based N-Tier Applications using C#

2010-02-15T23:23:00.000-08:00

Building Web Based N-Tier Applications using C#

This article explores the N-tier and Distributed Application Architecture. Over the last decade, the way applications are designed has evolved and come a long way. We have stand-alone applications, server based applications, client server applications, web based applications, n-tier applications, distributed applications, Peer-to-peer apps, service-oriented Architectures, component based Development and the list goes on. This article discusses the advantages, disadvantages of n-tier applications and methods to implement web based n-tier Applications using C#, .NET

Why N-Tier Applications?
N-Tier Applications can easily implement the concepts of Distributed Application Design and Architecture. The N-Tier Applications provide strategic benefits to Enterprise Solutions.
While 2-tier, client-server can help us create quick and easy solutions and may be used for Rapid Prototyping, they can easily become a maintenance and security night mare.

The N-tier Applications provide specific advantages that are vital to the business continuity of the enterprise. Typical features of a real life n-tier may include the following:

1) Security: Application has Appropriate Authentication, logging and monitoring mechanisms

2) Availability and Scalability: Application should be reliable and should have sufficient fail-over mechanisms ( redundancy) such as fail-over clusters

3) Manageability: Application should be designed to have the capability to Deploy, Monitor and troubleshoot. Methodology to handle Errors, log Errors and provide useful information for problem resolution

4) Easy Maintenance: This is generally achieved by adopting coding standards, deployment standards, modular application design, ‘data abstraction’ and application frameworks.

5) Data Abstraction: Easily make changes to the functionality, business rules with the least amount of impact to the entire applications

The above mentioned points are some of the Key design goals of a successful n-tier application that intends to provide a good Business Solution.

What does it take to build the n-tier Application?
The single most important factor that decides the success of the n-tier application is a through business or domain knowledge.

The second most important access is the technical and design know how. N-tier applications require us to put in a sufficient amount of thought to successfully distribute the overall functionality of the application in the appropriate ‘tiers’.

When n-tier Applications should not be used?
Building and implementing a successful n-tier application requires a lot of Effort, Skill, experience, commitment and Organizational Maturity.

It also implies cost.

Hence a favorable Cost-Benefit Ratio is necessary before you decide to go ahead with the n-tier Application.

What is a n-tier Application?
Simply stated, an n-tier application helps us distribute the overall functionality into various tiers or layers.

For example in a typical implementation you can have one or more of the following layers
1) Presentation Layer
2) Business Rules Layer
3) Data Access Layer
4) Database/Data store

In certain scenarios some of the layers mentioned above may be split further into one or more sub layers.

Each Layer can be developed independently of the other provided that it adheres to the standards and communicates with the other layers as per the specifications.

This is one of the biggest advantages of the n-tier application.
Each layer can potentially treat the other layers as ‘black-box’

In other words, each layer does not care how the other layer processes the data as long as it sends the right data in a correct format.

Building them with C#, .NET:
C#.NET provides us an excellent, robust feature rich platform.
C# being Object Oriented Programming Language it helps in practically laying down the standards. For instance you could create a base class with standard functions and require that all new classes should be derived from this base class. Please see the article on “Inheritance” in this series.

.NET provides type safety, automatic Garbage Collection which is very important in implementing good n-tier apps.

The Logical Building Blocks

The above diagram describes the logical building blocks of the Application.

1) The Presentation Layer: Also called as the client layer comprises of components that are dedicated to presenting the data to the user. For example: Windows/Web Forms and buttons, edit boxes, Text boxes, labels, grids, etc.

2) The Business Rules Layer: This layer encapsulates the Business rules or the business logic of the encapsulations. To have a separate layer for business logic is of a great advantage. This is because any changes in Business Rules can be easily handled in this layer. As long as the interface between the layers remains the same, any changes to the functionality/processing logic in this layer can be made without impacting the others. A lot of client-server apps failed to implement successfully as changing the business logic was a painful process.

3) The Data Access Layer: This layer comprises of components that help in accessing the Database. If used in the right way, this layer provides a level of abstraction for the database structures. Simply put changes made to the database, tables, etc do not effect the rest of the application because of the Data Access layer. The different application layers send the data requests to this layer and receive the response from this layer.

The database is not accessed directly from any other layer/component. Hence the table names, field names are not hard coded anywhere else. This layer may also access any other services that may provide it with data, for instance Active Directory, Services etc. Having this layer also provides an additional layer of security for the database. As the other layers do not need to know the database credentials, connect strings and so on.

4) The Database Layer: This layer comprises of the Database Components such as DB Files, Tables, Views, etc. The Actual database could be created using SQL Server, Oracle, Flat files, etc.
In an n-tier application, the entire application can be implemented in such a way that it is independent of the actual Database. For instance, you could change the Database Location with minimal changes to Data Access Layer. The rest of the Application should remain unaffected.

Many packaged n-tier Applications are created so that they can work the same with SQL Server, Oracle, UDB and so on. In the above pages we have seen the background and the logical design of the n-tier application. Large enterprise apps are typically designed as n-tier applications and large portion of them are web based applications. Therefore they can be viewed in a secure manner, from any PC with a browser. This is a good combination of ease of use and security.

How do the Layers communicate with each other?
Each Layer comprises of one or more components. Each component being a part of the app may communicate with one or more component. The component may “speak” to the other components using one of the many protocols, HTTP, FTP, TCP/IP and mechanisms such as XML/RPC, SOAP, REMOTING etc. The data as such may be “passed” across in many formats such as binary, string , XML. For the purpose of this article we will use XML format for passing data between the components.

Communication Techniques in n-tier ‘.NET’ Apps :
The different layers of the n-tier applications can be located on physically different machines.
Various techniques can be used to communicate between the various layers and components. The most common include

XML Web Services
.NET Remoting

A Web Based N-Tier Application

In the diagram above we observe that the Presentation Layer is made of Web Pages, Web Components and Web Server such as IIS. The end user sees the web pages on a Browser such as IE.

To create a web based n-tier Application using C#, .NET the following steps need to be followed:

1) Define what the Application should do. In other words the functionality of the application.

2) Segregate the application logic. The logic related to the User Interface or presentation layer will be part of the presentation layer, The logic related to the Business Rules goes to the Business Layer and so on.

3) Design the Database Structures, such as Tables, Views and so on. The Database design is a very crucial step and it effects the overall application performance, reliability and usability

4) After this you can design the Data Access Layer. This Layer comprises of code to access the database. The Data Access Layer components may typically be called by the Business Layer Components. The Design also defines how this call should be made. This includes the interface definition, Inputs, Outputs, Data Structure Definition and so on.

5) Similarly Business Application Layer design will define the Components that are part of this layer. Specifications for each component should include the Interface Definition, Inputs, outputs and Data structures (example XML DTD).

6) The Presentation Layer is designed keeping in mind the ease of Use. The User Interface should be intuitive and pleasant. The Presentation Layer may comprise of Web Pages such as .aspx,HTML, and compiled components.

Each of the layers can typically be located on physically separate machines for various reasons such as reliability, security and scalability.

To understand the actual coding aspects for building an n-tier application or a distributed application architecture refer to our articles on Creating Components in C#.

Summary:
In the above article we discussed the evolution of various architectures and specifically n-tier applications and distributed application Architecure.

24 JavaScript Best Practices for Beginners

2009-06-18T00:42:00.000-07:00

Click here to find out the 24 Best Javascript Coding Practices for Beginners.. Enjoy..

Save Earth

2009-05-27T05:47:00.000-07:00

It is well-known fact that we, as a generation of Indians are at the threshold of the most humongous threat to our environment. It is imperative that we take as many steps as feasible to reverse this damage. As citizens of the planet, and as Indians. If we don't then who will?


1. There is a cute small round press button at the bottom right corner of almost all monitors: Please make use of this,




2. Stop printing out Harry Porter, Jeffrey Archer and other e-books. This is a classic example of paper wastage.



If you have forgotten to give double-side prints, make sure you make use of the empty sides as scribbling pads or for your kids' imposition

!




Take two minutes from your busy schedule before hurrying back home to shut down the computer.






All of us are big time Googlers. Have you heard of the Blackle search engine? Blackle http://www.blackle.com (Google powered) is a search engine designed all in Rich Black so that your system consumes less power. So change your homepage.

Plastic bags these days indeed come in bright and flamboyant colours and tempt us to take them home with us. But the saying, "Appearances are deceptive" holds true for these plastic things too. Next time, hold back or go prepared to counter temptation with a cloth bag.






Roses, Jasmine, Hibiscus and Peas; All these saplings cost hardly between Rs 10 - 20 each. Can't we afford to plant these in and around our houses? Also, more importantly, caring and maintain them as they grow?







Try to segregate the different kinds of waste into Bio-Degradable (Fruit or vegetable waste) , Recyclable (waste Paper, paper products) and Electronics (Floppy disks, CD-ROMS ). Once you have segregated your thrash, look for specialized trash cans to throw them away.




Try to minimize the use of horns. Honking drastically increased and this adds to the noi
se pollution and does not provide a conducive environment to live in.




Use rechargeable batteries though it's an expensive product, it's one-time purchase. Recharge when required. (Same applies to cell-phones, MP3s, iPods and Laptops)





The best pens to use would be ink ones. Though if you have to use a ball point pen, buy refills instead of buying new pens. Pencils are much better for rough use! (That's why we used it at school!!!)






Remember to close water taps before preening in front of the mirror. Of course you are beautiful, but Water is a precious resource!






Let's not just wake up and walk out of finished meetings and conferences with a sigh of relief, let us remember to turn off the lights and projectors too.





Take few minutes to learn about topics like 'Global Warming' , 'Air / Noise /Land / Water Pollution ' etc apart from constant surfing of News, Latest Gadgets, Movies and Music.






Spread this message; to your friends and foes. They too can make a difference.




The Earth has already become a dangerous place to live in for the animals and birds. Soon it might be our turn. So let's pledge to save our beautiful planet so that you and your future generations can live happily and peacefully ever after.

Step by Step to Sharepoint..

2009-05-15T22:56:00.000-07:00

In these SharePoint screencast tutorials, get step by step instructions on all the features included in SharePoint hosting
and how to optimize your site. The tutorials cover topics from Alerts and Creating Web Parts to
Creating Meetings, Project Team Sites and Wikis

http://www.sharepointhostingprovider.com/sharepoint-tutorials/

A New Look for Visual Studio 2010

2009-05-14T23:39:00.001-07:00

At the PDC and TechEd EMEA last year we described our new editor support built on the WPF technology in .NET Framework 4.0. Today I’m happy to reveal the new UI for Visual Studio, also built on WPF:

In this image you can see several areas of concentration:

Reduced clutter and visual complexity by removing excessive lines and gradients in the UX and modernized the interface by removing outdated 3D bevels
Placed focus on content areas by opening negative space between windows and drawing attention to the current focus with a dominant accent color and a distinctive background
Added an inviting new palette to make VS 2010 more distinctive

In the following image you can see floating documents which allows you to utilize multiple monitors while designing your project and writing code:

This image shows new support in the editor for outlining:

Triangle glyphs in the margin are used to collapse or expand your code blocks
Collapsed sections of code are marked with an empty triangle (pointing straight) as well as a set of ellipses
Colors on the margin indicate edits that have been made

The New Project dialog has also gotten an update to include online template viewing, a search box, and easier navigation. Multi-targeting remains in this version but now with .NET Framework 4.0 included as an option:

Visual Studio has a very broad and rich ecosystem of extensions written by our partners and folks like you. In VS2010 we wanted to make it easier for you to find those extensions and install them. We’ve enabled the new Extension Manager for this purpose:

With the Extension Manager you will be able to browse for templates and tools online and install them easily into the Visual Studio environment. The next public release of VS will have this new functionality and we’ll be hooking up the online capabilities through theVisual Studio Gallery as part of the final release.

These designs were developed and tested for user feedback by our User Experience team and implemented by the VS Platform team (excellent job!).

We hope you like the new look and feel of Visual Studio 2010. You’ll be able to play with these bits when we release Beta 1 which we are working hard on right now (no formal announce date just yet, stay tuned).

Enjoy!

Visual Studio .NET 2005 Keyboard Shortcuts

2009-05-08T05:09:00.000-07:00

You may find this link handy when using VS 2005:

http://www.codinghorror.com/blog/files/Visual%20Studio%20.NET%202005%20Keyboard%20Shortcuts.htm

Interviewing with Microsoft India

2009-04-25T05:57:00.001-07:00

"What to expect in the interview" I've had this question from candidates that I have referred or distant relatives or friend's friend (you get the idea!) who are appearing for an interview with Microsoft . Somehow people still get to hear that Microsoft asks riddles. Though this was true way back but now these questions are rarely asked as they indicate very little about the candidate's potential.

I have been through interviews with some leading companies as an interviewer or interviewee and IMO Microsoft's interview process is a bit different. So here goes a list of what to expect and be prepared for in a technical interview with Microsoft.

Unlike some other companies, Microsoft takes people from a lot of diverse background. E.g. if you are from C++ compiler development background you can be easily considered for the VS IDE's intelli-sense development if your interviewers think that you can fit in.
Your dress really doesn't matter. You can expect to see your interviewer in shorts and he can't care less about what you wear.
The interview process is loooooong. Expect multiple people to interview you one after the other. So when you get the lunch break, eat well.
Put things in your resume only when you know about them well. People in Microsoft comes from diverse background (see above) and their is every possibility that your interviewer will be very aware about the technologies you have mentioned in your resume and will ask you about them.
Know your past projects well.
You will be asked to solve technical problems and write pseudo-code for the solution.
Whether you are interviewing for Software development role, a test role or a lead/manager role you will be asked to code. The reason is simple, in Microsoft leads and development/test managers and even PUMs in some case (Program Unit Managers) code.
Think aloud when solving problems, approach is as important as the final solution.
When giving a solution, find out the fallacies your self and try to come up with better alternatives.
Its an interview, so ask questions about Microsoft and the position/role you are being interviewed for.
This is not true :)

Aspect Oriented Programming using .NET

2009-04-25T04:58:00.000-07:00

What is AOP

Aspect Oriented Programming or AOP is an interesting concept that can be applied to many of the programming problems we solve everyday. In our Visual Studio team system code we have a lot of web-services and remoting code that essentially does the following

public void MyMethod(int parameter)
{    Trace.EnteredMethod("MyMethod", parameter);
    SecurityCheck();    // Bunch of processing
    Trace.ExitMethod("MyMethod");
}

This is not just peculiar to our domain but is seen across different domains. In OO programming classes and methods are designed for performing specific operations and common/duplicate functionality are factored out into common classes. However, there are cross-cutting concerns that span accross all classes and methods, like logging and security checks. OOP only partially solves this problem by requiring users to define separate classes for logging and security checks and requiring each class/methods needing these services to call them. AOP targets and solves this problem elegantly.

AOP divides code into base-code (code for your functionality) and a new construct called aspect. Aspect encapsulates these cross-cutting concerns using the following concepts

join-points: The points in the structure of base-code where the cross-cutting functionality needs to execute. This is typically when specific methods are entered or exited or properties are accessed.
point-cut: A logical description of join-points using some specific syntax
advice: additional code like logging and security check that each of these methods need to perform

The most mature AOP language is probably AspectJ which adds AOP extensions to Java. However, for this blog, I'd stick to .NET languages like AspectDNG, Aspect# and C#.

Language support for AOP

AOP support has to be built in to the language and/or framework because it is based on method call interception. Whenever a methods is called the framework needs to provide a stub to call some other piece of code. Though .NET CLR has this capability, but it is intrusive as you need an object to extend fromMarshalByRefObject or ContextBoundObject to allow method-interception. This is a serious limitation because each class needs to be written so that it supports AOP. Many AOP languages or language-extensions get around this limitation by using various techniques. The techniques generally fall into two broad categories runtime or dynamic weaving, compile-time or static weaving.

Aspect# is AOP language which uses static compile time weaving. It uses its own proxy (and not CLR's proxy) called DynamicProxy. DynamicProxy is generated compile time and works differently while proxying interfaces (generates dynamic class and delegates method calls to the target of invocation) and proxying classes (generates stub class that inherits from the target).

Aspect# provides syntax to define point-cut and call method-interceptors or advice for them. It's done as follows

import YourCompany.CMS.ContentProviders in YourCompanyAssembly
import YourCompany.CMS.Aop.Interceptors
aspect SecurityAspect for RSSContentProvider
     include Mixins.SecurityResourceImpl in MyMixinsAssembly     
    pointcut method(* MyMethod(*))
           advice(TracingInterceptor)
     end



end
public class TracingInterceptor : IMethodInterceptor {    public object Invoke(IMethodInvocation invocation)    {        // Trace using information from IMethodInvocation
      // like Method, MethodInvocationTarget        return invocation.Proceed();    } }

The important bits are marked in bold. The first block is the point-cut in a Ruby like syntax which specifies all methods with the name MyMethod to be included in the join-points. The second block is the interceptor (advice) TracingInterceptor. The TracingInterceptor is a class that has to implement theIMethodInterceptor. It can call invocation.Proceed to continue with the method invocation once it's done with the tracing. So whenever the MyMethod is called TracingInterceptor.Invoke gets called.

Other languages like AspectDNG (.NET based AOP language-extension) accomplishes this using something called IL weaving. In this the target or base-code is coded in any language that can be compiled into MSIL like C#, VB.NET, J#. So the target code can look like

using System;
 public class MyClass {
    public int ProcessString(String s, out string outStr) {
        // ...  
    }
}

There is no special code or any type of modification needed on the base-code as evident from above which is plain-vanilla C# code. The aspect code is written as follows which can also be C# code and needs some additional assembly reference and attribute decoration for AspectDNG to pick them up

using DotNetGuru.AspectDNG.MetaAspects;
using DotNetGuru.AspectDNG.Joinpoints;
using System;
public class AspectsSample{
    [AroundCall("* MyClass::ProcessString(*)")]
    public static object YourMethodCallInterceptor(JoinPoint jp) {
        Console.WriteLine("Code before calls to '.. MyClass.ProcessString(..)'");
        object result = jp.Proceed();
        Console.WriteLine("Code after calls to '.. MyClass.ProcessString(..)'");
        return result;
    }
}

Here point-cut is specified using attributes like AroundCall, AroundBody. Both the base-code and the aspect code are separately compiled into different assemblies using respective compilers like csc into Target.exe and aspect.dll. Then the aspectdng.exe tool can be used which uses reflection to reach to the attribute in the aspect code to weave call to them so that a new assembly called Target-weaved.exe is created. In target-weaved.exe AspectDNG directly puts in calls to the aspects around the target code by inserting/replacing IL code wherever required.

There are some AOP languages like Encase which apply the aspects at run time. These languages use AOP frameworks which reads in configuration files for point-cuts and at runtime generate proxy classes that intercept calls, allows advice of the aspect to execute first and then invokes the actual target. The benefit is that there is not edit-compile cycle but it faces performance issues.

AOP in C#

Till now we were talking about non-mainstream languages to get AOP done. However, by doing a bit extra work we can get the same functionality in C# as well. The limitation with CLR is that it allows method interception only when the classes containing the methods inherit from MarshalByRefObject orContextBoundObject. When a class inheriting from ContextBoundObject is activated, the .NET interceptor comes into play. It creates a trasparent-proxy and a real-proxy. The transparent-proxy gets called for all invocation of the target. The transparent proxy serializes the call stack and passes that on to the real-proxy. The real-proxy calls the first message sink which is an object implementing theIMessageSink interface. Its the duty of this first message sink to call the next until the final sink goes and calls the actual target. In this sink chaining we can insert objects which can execute our aspect advice.

Another limitation with C# is that there is no way in C# syntax to specify join-points. We will circumvent these two limitations by inheriting the target classes from ContextBoundObject. We'll use attributes on specific classes so that all methods and field-setters in them become included into the join-points.

using System;
// Include the aspect framework
using Abhinaba.Aspect.Security;
[Security()]
public class MyClass : ContextBoundObject {
    public int ProcessString(String s, out string outStr) {
        Console.WriteLine("Inside ProcessString");
        outStr = s.ToUpper();        return outStr.Length;
    }
}

Here Security is an attribute defined in our Abhinaba,Aspect.Security namespace which pulls in our support for AOP and includes the current class and all its methods in the join-points. The whole AOP framework looks as follows. All the important parts are marked in bold.

using System;
using System.Diagnostics;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Contexts;
using System.Runtime.Remoting.Activation;
namespace Abhinaba.Aspect.Security
{    internal class SecurityAspect : IMessageSink {
        internal SecurityAspect(IMessageSink next)
        {
            m_next = next;
        }         private IMessageSink m_next;
            #region IMessageSink implementation
        public IMessageSink NextSink
        {            get{return m_next;}
        }
        public IMessage SyncProcessMessage(IMessage msg)
        {
            Preprocess(msg);            IMessage returnMethod =
                             m_next.SyncProcessMessage(msg);
            return returnMethod;
        }        public IMessageCtrl AsyncProcessMessage(IMessage msg,
                                 IMessageSink replySink)
        {            throw new InvalidOperationException();
        }        #endregion //IMessageSink implementation

       #region Helper methods
        private void Preprocess(IMessage msg)
        {            // We only want to process method calls
            if (!(msg is IMethodMessage)) return;
            IMethodMessage call = msg as IMethodMessage;
            Type type = Type.GetType(call.TypeName);
            string callStr = type.Name + "." + call.MethodName;
            Console.WriteLine("Security validating : {0} for {1}",
                         callStr, Environment.UserName);
        }        #endregion Helpers
    }    public class SecurityProperty : IContextProperty,
                                   IContributeObjectSink
    {        #region IContributeObjectSink implementation
        public IMessageSink GetObjectSink(MarshalByRefObject o,
                                           IMessageSink next)
        {            return new SecurityAspect(next);
        }        #endregion // IContributeObjectSink implementation
        #region IContextProperty implementation
        // Implement Name, Freeze, IsNewContextOK
        #endregion //IContextProperty implementation
    }    [AttributeUsage(AttributeTargets.Class)]
    public class SecurityAttribute : ContextAttribute
    {        public SecurityAttribute() : base("Security") { }
        public override void GetPropertiesForNewContext(
                              IConstructionCallMessage ccm)
        {            ccm.ContextProperties.Add(new SecurityProperty());
        }
    }
}

SecurityAttribute derives from ContextAttribute and MyClass derives from ContextBoundObject, due to this even before the ctor of the class is called the framework instantiates SecurityAttribute and calls the GetPropertiesForNewContext passing it a reference to IConstructionCallMessage.SecurityAttribute creates an instance of SecurityProperty and adds it to the context. This addition makes the framework call the various IContextProperty methods that SecurityProperty implements and then calls the ctor of MyClass.

After this the first time any MyClass method or variable is referenced it calls GetObjectSink method ofSecurityProperty through its IContributeObjectSink interface. This method returns a newly created instance of SecurityAspect. Till this you can consider everything as initialization code andSecurityAspect implements our main functionality for AOP advice.

When the instance of SecurityAspect is created its constructor is passed a reference to next message sink so that all the sinks can be chained and called one after the other. After this SyncProcessMessage is called which is our main method interceptor and where all processing is done. After doing all processing like security verification the code calls the target method. Then it can refer to the return value and do post-processing. With this we have AOP implementation albeit some intrusive code as the target codes needs to be modified for AOP support.

Possibilities

AOP is a very generic programming method and can be used in a variety of situation. Some of them are as follows

Factoring out common cross-cutting code like logging, security verification
Design by contract verification
Non-intrusive profiling

Sample code

The sample solution (VS2005) including all sources are available here. It contains sources for two different aspects, one for security and one for tracing both applied on the same class. I have applied conditional compilation attribute to the tracing aspect so that on release build tracing gets disabled.

True object oriented language

2009-04-25T04:49:00.000-07:00

Today I was spreading the goodness of Ruby and why I love it so much (and you can expect multiple posts on it). SmallTalk programmers can sneer at me, but hey I wasn't even born when SmallTalk came into being and hence I can be pardoned for pretending that Ruby invented this :)

Languages like Ruby are "truly" object oriented. So even a number like 2 is an instance of the FixNum class. So the following is valid Ruby code which returns the absolute value of the number.

-12345.abs

Taking this to an extreme is the iteration syntax. In C# to write something in a loop "n" time I'd be needed to get into for/foreach syntax, however in Ruby I can do the following

5.times { puts "Hello"}

Which prints Hello 5 times.

However, I actually lied about having to use for/foreach statement in C#. With the new extension-method/lambda goodness we can very well achieve something close in C#.

For that first we create the following extension method

public static class Extensions

{

public static void times(this int n, Action a)

{

for (int i = 0; i <>

{

a();

}

Then we can call "times" on an int as easily (well almost as I still need some lambda ugliness).

5.times(() => Console.WriteLine("Hello"));

// Or

6.times(delegate { Console.WriteLine("Hello"); });

How do you name your computer

2009-04-25T04:44:00.000-07:00

Windows gives examples of "Kitchen Computer" or "Mary's Computer" for setting the name of a computer (Computer Name tab in System Properties). But I'm sure that most people don't name their computers that way and show off a bit of creativity in it.

Previously I used to use names from Asterix like GetAFix for my main dev box. Now I exclusively use names from Hitchhiker's Guide to the Galaxy. Some of the machines I use are named as below

traal: My test box
Krikkit: My dev box
Vogon: A old vintage machine I have at work which I use to test some perf scenarios (Vista on 512mb RAM :^) )
Hooloovoo : My personal laptop
Bugblatter: Another laptop

What name do you use?