John W Powell : Visual Studio

Subscribe to SharePoint Web Parts using Internet Explorer 8 Web Slices

johnwpowell — Mon, 02 Feb 2009 00:34:00 GMT

One of the new features of Internet Explorer 8 is Web Slices. This feature enables you to subscribe to a section of a web page and notifies you when the content changes. By design, SharePoint Web Parts are a natural fit for this feature, and in this article I’ll show you how to build a Web Part that does just that. I’ll also show you how easy it is to develop a web part using the CTP release of Visual Studio 2008 Extensions for Windows SharePoint Services (VSSWse) 1.3.

About Web Slices

Web Slices enable you to have a very narrow control over the content you subscribe to. When you browse a page that has Web Slice sections, they “light up” when you hover over them:

In addition, the new Web Slice icon on the toolbar lights up, and the menu is populated with all the slices on the page:

When you subscribe to a slice, the web page section is added to the toolbar and is periodically refreshed. The refresh interval is completely customizable and can also be refreshed manually:

Defining a Web Slice Section

Web Slices are defined with HTML tags that have certain CSS classes. You can read the full specification, but here’s all you need to know to build your first Web Slice:

To define a Web Slice section, use the hslice class name:

<div class="hslice" id="1">…</div>

To define the slice title, use the entry-title class name:

<p class="entry-title">Game System - $66.00</p>

To define the slice content, use the entry-content class name:

<div class="entry-content">This auction closes in 4 hours.</div>

The end result looks like this:

<div class="hslice" id="1">

<p class="entry-title">Game System - $66.00</p>

<div class="entry-content">This auction closes in 4 hours.</div>

</div>

Build a SharePoint Web Part

For this example, I’m using VSSWSE 1.3 which you can read about here. I would recommend it not only because it’s easy to use, but also because it is sure to become the de-facto standard. To get started, create a new Web Part project:

Choose if you want to deploy to the GAC or bin directory. We’ll use GAC for this example:

A solution is created with a default web part named WebPart1. Rather than renaming it, delete the WebPart1 folder and add a new Web Part to the project with a more descriptive name:

Next, configure the url of your SharePoint site you want to use to test the Web Part. On the Debug settings, set the start url:

In the Web Part, override the CreateChildControls method:

This code generates the needed HTML and is pretty self-explanatory. I chose to hide the Web Slice entry-title as it would be redundant beneath the Web Part title. To test the code, right-click the solution or project and select Deploy. This will package the Web Part as a feature and deploy and activate it on the site:

Next, add the Web Part to a page in the site and test it.

How I Wished It Worked

Web Slices are powerful, but I don’t really want to develop a bunch of new Web Parts to use that feature. I wish every Web Part were capable of wrapping its content in a Web Slice div tag. I’m sure there is a way to inject this functionality (and there might even be a supported method), but I wish it were built in to the Web Part framework. Every Web Part could then have a Web Slice category with relevant settings:

Wouldn’t that be powerful?

Summary

In this article, I demonstrated how to build a Web Part that users can subscribe to using Web Slices. I also showed you how easy it is to build a Web Part using the CTP release of Visual Studio 2008 Extensions for Windows SharePoint Services version 1.3. Happy slicing!

References and Additional Reading

Language Changes to Chinese While Writing Code in Visual Studio 2008

johnwpowell — Fri, 09 May 2008 02:44:00 GMT

I recently experienced what could be misinterpreted as a bug in Visual Studio 2008. While feverishly typing code, the language "randomly" changed to Chinese. Here's what it looked like:

Of course it's not a a bug--it's a feature! Left ALT + SHIFT is the Windows shortcut for changing the input language, and since I use ALT and SHIFT so frequently in Visual Studio, I occasionally hit the keys at the same time!

You can easily see which language you are in by looking at the language bar:

You can change or disable the keystrokes by right-clicking on the language bar and selecting Settings:

Then select Between input languages and click Change Key Sequence:

If you have fat finger issues like me, you probably want to select Not Assigned.

So next time you find something that seems like a bug, remember, it just might be a feature!

References

Windows Keyboard Shortcuts

Team Explorer Window Won't Open Or Is Blank

johnwpowell — Mon, 05 May 2008 22:00:00 GMT

If recently worked with several developers that were unable to open the Team Explorer 2008 window (or if they did open it, the window was blank). They had pre-release versions of Visual Studio 2008 installed and despite following the instructions on uninstalling previous versions, were unsucessful. Having found the fix for this issue, I thought I'd share it in case anyone else encounters it.

Open a Visual Studio 2008 command prompt and run the following command:

devenv /setup

It will take awhile for this command to complete, but afterwards, the issue should be resolved. Here is documentation on the /setup switch if you would like to know more about it.

10 Tips to Boost Your Productivity with C# and Visual Studio 2008

johnwpowell — Sun, 23 Mar 2008 14:48:00 GMT

Learn Key Bindings

It's an obvious and trivial thing, but the timesaving will add up, especially for those actions you perform tens or hundreds of times a day such as building and debugging. Here are some basic bindings every Visual Studio developer should know:

Build: CTRL + SHIFT + B
Word completion: CTRL + SPACE
Start with debugging: F5
Start without debugging: CTRL + F5

Even expert Visual Studio developers can benefit by learning new bindings. Download the Visual C# 2008 Keybinding Reference Poster and hang it in your work area.

Generate XML Comments with GhostDoc

Instead of typing XML comments by hand, let a tool do the work for you. Although macros and snippets are reasonably effective for this, I would recommend Ghost Doc over any other solution. This free add-in uses customizable templates to generate consistent, English-readable documentation based on the current context. To use it, right-click (or use CTRL + SHIFT + D) to document the current element. For example:

This generates the following documentation (note GhostDoc split the property name into words and created a sentence from it):

Auto-Implement Properties

Take advantage of a new feature of C#: auto-implemented properties. Rather than creating a private backing field for your properties, let the compiler do it for you. The following demonstrates the syntax:

Use the code snippet to make this even faster. Type prop (the shortcut for an auto-implemented property) followed by TAB TAB. Then fill in the data type and property name:

Refactor

The refactor feature in Visual Studio is indispensable for many tasks, especially renaming, but one productivity feature I particularly like is Encapsulate Field. If you are unable to use an auto-implemented property, declare a private field and let Visual Studio generate the Property for you. To use this feature, right-click on the field and select Refactor > Encapsulate Field...

The property is created for you:

Add Commands to Visual Studio 2008

Install the PowerCommands for Visual Studio 2008 to add several productivity commands such as:

Close all documents
Copy and paste a class (automatically renames)
Remove and sort using statements project-wide
Copy and paste references (including a project reference)

Install the Team Foundation Server Power Tools to add several TFS productivity commands such as:

Find in source control
Open source folder in Windows Explorer
Work item templates (can be used to set values on multiple work items at once)

Add your own productivity commands. For example, to add Reflector so it automatically opens on the current project.

Select Tools > External Tools
Click Add
Name it Reflector and browse to the executable
Enter $(TargetPath) for the Arguments

Speed up Compilation with Project Configuration

You may build tens of times during a programming session, so don't enable anything that isn't absolute necessary such as code analysis and XML documentation. Develop in Debug configuration, and switch to Release configuration just before check-in to run code analysis and generate XML documentation. In a large solution I recently worked on, this shaved a minute off compilation time.

The following shows code analysis disabled in Debug configuration:

The following shows code analysis enabled in Release configuration:

Let Visual Studio Generate Unit Test Code

Although it can't fully automate unit testing yet (check out Pex), Visual Studio does a good job of generating positive unit test code to give you a jump start. To use this feature, right-click on an element you would like to test and select Create Unit Tests...

Visual Studio generates the following test method:

Use Interface-Driven-Design

You probably never thought of an interface as a productivity feature, but it can be if your development process is driven by contracts instead of implementation. Let me illustrate with a simplified example. One developer owns the business layer and another developer owns the data access layer, and they need to agree on how to communicate to implement a new feature. In some business object designs, business components will instantiate data components (or call a static method). This is a problem from a design standpoint because the two become tightly coupled. It is also a problem from the productivity standpoint because the business layer developer becomes dependent on the data access layer developer's implementation. Interface-driven design (IDD) solves this issue.

Rather than the business component developer waiting on the data component developer, they meet to design and implement the interface. Both developers are then free to go their separate ways and implement the components in parallel. IDD also enables the business developer to mock the data access component, thereby removing any scheduling dependencies. The following illustrates the design:

Make a Mockery of Dependencies

Different developers may own layers or features that your component is dependent on, but don't let that slow you down. Suppose you are responsible for the business layer which depends on the data access layer which in turn depends on database tables and stored procedures. Rather than waiting for dependent layers to be completed, mock the data access layer so you can implement and unit test the business layer. By the way, you should be using mocks anyway; otherwise your unit tests are more than likely integration tests. I recommend Rhino Mocks.

Here is a sample unit test with mocks:

Data Drive Unit Tests

If you have a unit test that multiple inputs to fully test, you could write a test method for every possible combination, but data-driven unit tests are more efficient. When the unit test is run, it loads data from a table and calls the unit test for each row. You can access the data in the current row using the TestContext.DataRow property.

Once the test completes, you can view the results: