SharePoint

Model View Presenter (MVP) Passive View, SharePoint and Mocking

Matthew Podwysocki — Thu, 20 Dec 2007 18:11:59 GMT

For the past couple of years, the Model View Presenter pattern has gotten a lot of attention on the .NET platform and more in particular to ASP.NET. For a thorough introduction on MVP with ASP.NET, read the article on CodeProject by Billy McCafferty.

Recently, it has come to play that many now favor the Model View Controller (MVC) pattern over MVP. If you're confused about the differences between the two, check out this post which will explain it well. The basic gist is that the MVP pattern gives you the ability to mock the view whereas the MVC pattern allows for the mocking of the entire flow, including the context, request and response. To me, that's a bit of overkill right now for what I need with SharePoint, especially when dealing with Web Parts.

Now the term Model View Presenter (MVP) itself has been retired now for a year by Martin Fowler and split into two new patterns. It has been split into two parts:

So, what's the difference between the two and which to pick?

The Supervising Controller

The Supervising Controller uses a controller to both handle the input response but also manipulate the view to handle the complex view logic. The view is left to simple behavior, only intervening when it cannot be done in the controller. The presentation functionality is split into two parts, the presenter and the view. The model is separate for this design pattern.

The Supervising Controller has two main responsibilities: input response and view/model synchronization. For input response, the controller operates in the presenter style. All actions on the screen are handed off to the presenter which in turn handles all the logic. For the view/model synchronization, the controller relegates much of that functionality to the view. The view uses the typical data binding for populating the data fields.

The Passive View

The Passive View reduces the behavior of the UI components to a minimum by using a controller/presenter that not only handles the responses to events, but also handles the updating of the view. This allows for easier testing to be focused mostly on the controller/presenter and not as much on the view.

With this pattern, the user interface is split into two parts, the view that handles the display and the controller that responds to user actons. The change from the typical MVP pattern is that the view is completely passive and no longer responsible for updating itself from the model. All of the view logic is contained in the controller/presenter and there is no dependency in either direction between the view and the model.

Moving Into SharePoint

There are two different ways to approach this problem as noted above, either the Supervising Controller or the Passive View. For this post, let's go with the Passive View approach. In this example, I will be creating a random quote generator web part part . So, let's define the view first.

public interface IRandomQuoteView
{
     // Quote related fields
     string QuoteCategory { get; }
     string Quote { set; }

     // Status message for errors
     string StatusMessage { set; }
}

As defined above, we need to get the values in our presenter from the view for our random quote generator The presenter is responsible for setting the StatusMessage which indicates whether it passed or failed validation as well as the quote itself. Pretty simple, eh? Now let's go ahead and define the presenter. Remember that we need to connect to a business layer/data layer and will have dependency injection for loose coupling and separation of concerns.

public class RandomQuotePresenter
{
     private readonly IQuoteService quoteService;
     private readonly IRandomQuoteView quoteView;

     public RandomQuotePresenter(IRandomQuoteView quoteView) : this(quoteView, new SharePointQuoteService()) {}

     public RandomQuotePresenter(IRandomQuoteView quoteView, IQuoteService quoteService)
     {
          this.quoteView = quoteView;
          this.quoteService = quoteService;
     }

     public void InitView()
     {
          if(string.IsNullOrEmpty(quoteView.QuoteCategory))
          {
               quoteView.StatusMessage = "Category required";
               return;
          }

          try
          {
               quoteView.Quote = quoteService.GetRandomQuote(quoteView.QuoteCategory);

               if(string.IsNullOrEmpty(quoteView.Quote))
                    quoteView.StatusMessage = "No Quote Found...";
          }
          catch(QuoteServiceException)
          {
               quoteView.StatusMessage = "Data error";
          }
     }
}

Ok, now that we have the presenter created, let's start testing. Well, actually I should have stubbed everything out first and then made it fail, then make it pass, but let's continue. Let's do some unit testing on this piece. I'll be using Rhino Mocks as always to do my mocking.

[Test]
public void NullQuoteCategoryShouldCauseCategoryRequiredMessage()
{
     MockRepository repository = new MockRepository();
     IQuoteService service = repository.CreateMock<IQuoteService>();
     IRandomQuoteView view = repository.CreateMock<IRandomQuoteView>();
     Expect.Call(view.QuoteCategory).Return(null);
     view.StatusMessage = "Category required";
     RandomQuotePresenter presenter = new RandomQuotePresenter(view, service);
     repository.ReplayAll();

     presenter.InitView();
     repository.VerifyAll();
}

Well, that was easy, and we didn't even need a UI to do it. Well, now let's bring SharePoint web parts into the game.

[Guid("357b9668-0f88-4bcb-87a2-c34cc6694e90")]
public class RandomQuoteWebPart : WebPart, IQuoteOfTheDayView
{
     private RandomQuotePresenter presenter;
     private string quoteCategory;
     private string quote;
     private string statusMessage;

     public string QuoteCategory { get { return quoteCategory; } }

     public string StatusMessage { set { statusMessage = value; } }

     public string Quote { set { quote = value; } }

     [WebBrowsable, Personalizable]
     public string QuoteCategoryType
     {
          get { return quoteCategory; }
          set { quoteCategory = value; }
     }

     protected override void OnLoad(EventArgs e)
     {
          presenter = new RandomQuotePresenter(this);
          presenter.InitView();
     }

     protected override void Render(HtmlTextWriter writer)
     {
          writer.write("Quote Category: " + quoteCategory + "<br/>");
          writer.write("Quote: " + quote + "<br/>");
          if(!string.IsNullOrEmpty(statusMessage))
               writer.write("Status Message: " + statusMessage);
     }
}

Sure, I'm simplifying it a bit, but you get the general idea. I'm persisting the QuoteCategory as something configurable through a web part. The rest comes as natural as a standard web part on how to render. The OnLoad is where the magic happens with talking to the presenter to set up the view. Pretty cool, huh? The key is to keep your view as simple as possible and let the presenter do the work for you.

So, is that all that's to it? Well, not really... As you may have noted, my data service really comes from SharePoint, and moreover, a SharePoint list. Let's talk about that now...

Mocking Out SharePoint

As most web developers know, unit tests can be hard for web applications that have dependencies on such things as the HttpContext, etc. Well, in the SharePoint world, it's no different. So, what options do we have to stub out, say the SPContext, SPList and so on so that we're not tightly coupled to the API for our unit tests? It's not super easy due to the fact that there are static members, so interfaces won't suffice there.

We have the following options:

Write interfaces and wrappers for each SharePoint object
Use Duck Typing to create the interfaces and cast the SharePoint objects to them
Use TypeMock.NET to create a recorder and play back
Use Reflector Add-in Doubler to create our test doubles

Let's look at each one.

Wrap each object

In the worst case scenario, you can write all the interfaces for all the classes you wish to mock and create doubles for each by hand. This includes defining the interface for SPContext, SPList, SPWeb, SPSite and the actual implementations. This is not hard, but time consuming and prone to error when dealing with this much code. Not the ideal situation

Duck Typing

Duck Typing itself is not a new concept. This allows you to infer the functionality through interfaces. Duck Typing is available for .NET through the Duck Typing Project. This is more apt for dynamic languages such as Ruby, but let's give it a try here for a SharePoint object.

interface ISPField
{
     object GetFieldValue(string value);
     object GetFieldValueAsHtml(object value);
     // And so on
}

public void ConsumeField(ISPField field)
{
     ...
}

And in my calling code:

SPField field = // Get field
ISPField iField = DuckTyping.Cast<ISPField>(field);
ConsumeField(iField);

Phil Haack has more on the subject here.

TypeMock.NET

Rhino Mocks has a limitation, as do most mocking frameworks of only being able to mock interfaces and abstract classes. Well, SharePoint has that limitation due to all classes being concrete and/or sealed. Enter TypeMock.NET which allows you to record just about any object in the .NET Framework just as if it were the real thing. This allows for mocking of even static members which is something that the others cannot do. Of course this product comes with a price tag, depending on your organization. Another point to make is that it really isn't "abstracting" away your dependencies at all, it's just masking them. I've seen pluses and minuses about it and I just haven't made up my mind yet.

In order to do some mocking, there are some good samples out there including this one on HttpContext using TypeMock.NET.

Doubler

Now let's look at the final one. Doubler is a .NET Reflector Add-in developed by Jay Flowers. The intent of this add-in is to generate code for unit tests, wrappers and stubs.

Install this add-in and simply right-click on any class and you get the following options:

Recording Generator
Wrapper/Interface Generator
Test Generator
Fake Generator
Call Graph

Pretty cool stuff and it just works. This is a highly recommended product for generating your stubs.

Wrapup

Well, this has been a pretty long post on doing development with SharePoint and I hope it helps. There are many hurdles to overcome for doing good design and testing with SharePoint, but I hope this leads in the right direction.

Where do we go from here? Well, we can start looking at IoC containers for our dependency injection for our presenter, we can look at using the Supervising Controller and so on. Plenty of opportunities to explore!

Develop, mentor and inspire!

Visual Studio 2008 and SharePoint 2007 Templates

Matthew Podwysocki — Thu, 13 Dec 2007 21:47:43 GMT

With the recent announcement of WSS/MOSS SP1 and AJAX support, I decided to relook at the Visual Studio 2008 integration again. Sure enough I was surprised to find that Jan Tielens has been working on making it easy once again to develop web parts using templates.

Smart Templates has been put up on CodePlex in order to create more SharePoint project types than are currently available. This includes only Web Parts at the current time.

The web part template allows you to do the following:

Create web part code
Generate the WSP
Generate Setup project for deployment

Future plans include:

Event Handler
Smart Parts (User Controls Web Parts)
Application Page Project

It's been a savior as one of the things holding me back from Visual Studio 2008 was SharePoint templates. Now if they can hurry up on BizTalk...

Forms Server 2007 Presentation Wrapup

Matthew Podwysocki — Wed, 28 Nov 2007 04:59:23 GMT

Sahil Malik gave a great presentation tonight at the CapArea.NET user group meeting tonight. From this discussion he covered quite a few things that involved InfoPath, Forms Server and WF for SharePoint. A lot of the interesting tidbits discussed are available on his blog.

Customizing the default Document Information Panel in which he populates the document properties by using a custom InfoPath form.
Writing SharePoint Workflows in Visual Studio 2005 covers the basic WF scenarios in SharePoint, but also the custom InfoPath solutions you can introduce
Aggregating multiple data sources in a Forms Server Form covers a scenario in which you can load data from a SQL Server Database and store the custom information in a SharePoint list.

As someone who has recently taught a small course on Forms Server 2007, I found this material quite useful in extending and going a little further and deeper on the subject.

SharePoint Tips and Tricks - Traverse and Fix All My Sites Document Library

Matthew Podwysocki — Mon, 19 Jun 2006 23:52:00 GMT

Recently, for a very large customer, I had to fix some issues with regards to SharePoint My Site lists. Destroying and recreating each person's My Site was not an option.

This scenario actually happened due to the fact that should you get the dreaded SPException which indicates a "Save Conflict" while updating a SPList object, it will wipe out some of your properties. I will show an example in code in a Console Application.

So, let's start with the Main method:

[STAThread]

static void Main(string[] args)

{

     // Create TopologyManager
     topologyManager = new TopologyManager();
     site = topologyManager.PortalSites[new Uri("http://myspsserver/")];

context = PortalApplication.GetContext(site);
userProfileManager = new UserProfileManager(context);

// Iterate through users

long userCount = userProfileManager.Count;

IEnumerator profileEnumerator = userProfileManager.GetEnumerator();

while(profileEnumerator.Next())

{

// Set user profile

UserProfile userProfile = profileEnumerator.Current as UserProfile;

// Check for personal site

if(userProfile.PersonalSite != null)

{

// Create Personal Library

CreatePersonalDocumentLibrary(userProfile);

// Reset QuickLaunch and other properties

ResetProperties(userProfile);

} // if - userProfile

} // while - profileEnumerator

} // method - Main

Well, this code looks relatively simple. First, we create the Topology, and from there we eventually get to the UserProfileManager. From the UserProfileManager, we can get all the users for our particular Portal that we are interested in.

I then grab the IEnumeratorfrom the UserProfileManager so that I can iterate over the users. Once I am in the while loop, I need to check whether the Personal Site exists, because there is no need to fix a site that doesn't exist.

Now, let's get back to the issue at hand. We'll go to the place that gave me much heartache when dealing with the ever popular "Save Conflict". Apparently, the SharePoint API does not take too kindly to having the Default View deleted and recreated. This is unfortunate, because from my experience, you cannot modify the default view and you must delete and recreate it instead.

private static void CreatePersonalDocumentLibrary(UserProfile userProfile)
{
     private string listName = "MyLibrary";
     private string listDescription = "My Library Description";

     // Set personal site
     using(SPSite personalSite = userProfile.PersonalSite)
     {
          // Allow unsafe updates
          personalSite.AllowUnsafeUpdates = true;

          // Set rootweb
          using(SPWeb rootWeb = personalSite.RootWeb)
          {
               // Allow unsafe updates
               rootWeb.AllowUnsafeUpdates = true;

               // Create document library
               rootWeb.Lists.Add(listName, listDescription, SPListTemplateType.DocumentLibrary);
               rootWeb.Update();

               // Add document library to Quick Launch and enable versioning
               SPList localList = rootWeb.Lists[listName];
               localList.OnQuickLaunch = true;
               localList.EnableVersioning = true;
               localList.Update();

// Add document library to Quick Launch and enable versioning
SPList createdList = rootWeb.Lists[listName];

// Add custom fields

               createdList.Fields.Add("MyDocID", SPFieldType.Text, true);
               createdList.Fields.Add("MyDocDescription", SPFieldType.Note, false);

               // Create new view columns
               StringCollection viewFieldCollection = new StringCollection();

               // Add field to collection
               viewFieldCollection.Add("DocIcon");
               viewFieldCollection.Add("LinkFilename");
               viewFieldCollection.Add("MyDocID");
               viewFieldCollection.Add("MyDocDescription");
               viewFieldCollection.Add("Last_x0020_Modified");
               viewFieldCollection.Add("Modified_x0020_By");
               viewFieldCollection.Add("LinkCheckedOutTitle");

// Create default view query
string defaultQuery = "<OrderBy><FieldRef Name=\"FileLeafRef\" /></OrderBy>";

               // Get default view information and delete
               Guid oldViewId = createdList.DefaultView.ID;
               createdList.Views.Delete(oldViewId);

               // Add view as default
               createdList.Views.Add("All Items", viewFieldCollection, defaultQuery, 1000, true, true);
               createdList.DefaultView.Update();

               try
               {
                    // Try calling update
                    createdList.Update();
               } // try
               catch(SPException sp) {} // Do Nothing

// Close and dispose personalSite
rootWeb.Close();

} // using - rootWeb

personalSite.Close();
} // using - personalSite
} // method - CreatePersonalDocumentLibrary

Around the try block is where you will always have problems. I haven't been able to find a way around it when doing proof of concept work as of yet. If anyone has, please let me know. The other method called ResetProperties is a small subset of this method which just resets the OnQuickLaunch and EnableVersioning properties to true on the SPList.

This by no means was something I'd put into production, but instead more of dumbed down code for this example. There would be a good amount more code to do checks all over the place to make sure things exist and won't throw other types of exceptions.

SharePoint 2007 E-Learning Courses

Matthew Podwysocki — Tue, 13 Jun 2006 15:26:00 GMT

In my sparse spare time, I have been looking at SharePoint 2007 and what it has to offer. I think that saying that it is a great improvement is a vast understatement. Anyhow, there are some e-learning courses available now from Microsoft to get a head-start on it.

Course 3370: Getting Started with Microsoft Office SharePoint Server 2007 (Beta)

In this clinic, you'll explore the 2007 Microsoft Office System to understand how it provides many benefits to an organization, including enhanced collaboration, personal productivity, and an effective enterprise content management solution. You will also explore the design goals and features of Office SharePoint Server 2007 and learn how to manage documents and Web content using Office SharePoint Server 2007.

Course 3369: Getting Started with Windows SharePoint Services 3.0 (Beta)

This clinic covers the benefits and business value of deploying Windows SharePoint Services, provides an understanding of how Windows SharePoint Services contributes to the collaboration solutions from Microsoft, and outlines the skills and knowledge required for an organizational deployment.

Stay tuned to this site for more e-learning courses coming soon at the Microsoft Office 2007 Learning Portal.

Automating SharePoint Deployment Through Post-Build Events

Matthew Podwysocki — Thu, 01 Jun 2006 20:25:00 GMT

When working on enterprise level applications and even smaller ones, I tend to automate everything for my builds as much as possible. My recent experience with an enterprise SharePoint rollout is no different. I'll walk through a basic scenario where I can deploy my web part library to my local instance through build events.

The prerequisite of this of course is that you have the templates installed. If you do not, they can be found here: http://www.microsoft.com/downloads/details.aspx?FamilyID=cac3e0d2-bec1-494c-a74e-75936b88e3b5&DisplayLang=en

Let's walk through a simple example of how you can automate the deployment. First, launch Visual Studio 2003 and create a new Web Part Library project. In this example, I will call my library ExampleWebPartLibrary. This will create for you the following files:

* Manifest.xml

* WebPart1.dwp

* WebPart1.cs

Sign the assembly by using the sn -k to create the strong name key and then place in the AssemblyInfo.cs. Next, we will create a text file and place it in our project. Right-click on the project and add new Text File. Call this file MakeCabParams.txt.

The file must contain the following text:

.OPTION EXPLICIT
.Set CabinetNameTemplate=ExampleWebPartLibrary.cab
.set DiskDirectoryTemplate=CDROM
.Set CompressionType=MSZIP
.Set UniqueFiles="OFF"
.Set Cabinet=on
.Set DiskDirectory1=.

.\bin\debug\ExampleWebPartLibrary.dll
WebPart1.DWP
Manifest.xml

If you notice in the above, we specify the name of our .cab file as ExampleWebPartLibrary.cab. We also specify which files it includes, including the debug version of my dll, the dwp and manifest.xml. If you need to add any additional files, just add more files after manifest.xml.

Now, let's take a look at the post-build event. Go to Project Properties and then navigate to Build Events. Click the elipsis next to the Post-build Event Command Line and enter the following text:

cd $(ProjectDir)
makecab /f MakeCabParams.TXT
"c:\program files\common files\microsoft shared\web server extensions\60\bin\stsadm.exe" -o addwppack -filename ExampleWebPartLibrary.cab -globalinstall –force

As you note from the above text, we use the text file we created called MakeCabParams.TXT. We also specified the name of the cab file to install. After we do all of this, it is time to build the project. Build the project and note the text in the output window.

Here is what you should expect:

------ Build started: Project: ExampleWebPartLibrary, Configuration: Debug .NET ------

Preparing resources...
Updating references...
Performing main compilation...

Build complete -- 0 errors, 0 warnings
Building satellite assemblies...
Performing Post-Build Event...
Microsoft (R) Cabinet Maker - Version 5.2.3790.0
Copyright (c) Microsoft Corporation. All rights reserved..

Parsing directives
Parsing directives (MakeCabParams.TXT: 1 lines)
17,850 bytes in 4 files
Executing directives
  0.00% - ExampleWebPartLibrary.dll (1 of 3)
  0.00% - WebPart1.DWP (2 of 3)
  0.00% - Manifest.xml (3 of 3)
100.00% - Manifest.xml (3 of 3)
  0.00% [flushing current folder]
94.43% [flushing current folder]
  4.09% [flushing current folder]
100.00% [flushing current folder]
Total files:               4
Bytes before:        17,850
Bytes after:          3,203
After/Before:            17.94% compression
Time:                     0.04 seconds ( 0 hr 0 min 0.04 sec)
Throughput:             435.79 Kb/second

examplewebpartlibrary.cab: Deploying to http://mydevserver/.
Operation completed successfully.

---------------------- Done ----------------------

   Build: 1 succeeded, 0 failed, 0 skipped

If you look in the GAC, you should see the that there is indeed an entry should you browse to C:\Windows\Assembly.

There is another way to do this without dealing with DWPs and such by using InstallAssemblies, which I have posted about before. In order to utilize InstallAssemblies for your post-build event, simply change your Post-Build Event Text to the following:

"C:\Program Files\Web Part Toolkit\InstallAssemblies\InstallAssemblies.exe" /assembly:ExampleWebPartLibrary.dll

Of course it isn't the most elegant solution in the world because it pops up the UI during the middle of my build process and doesn't capture any of the information in the output window, which would be preferred.

Either way works really, but it is preferred to create the cabs for moving builds from environment to environment.

Free SharePoint Tools - CAML Builder

Matthew Podwysocki — Fri, 19 May 2006 19:34:00 GMT

In some of my SharePoint experience, I have had some cases in which CAML is necessary. So, I scoured the web looking for references when CAML Builder from U2U was pointed to me. The tool is quite easy to use, as I will show you down below.

First off, let's go through the login screen. You must specify at this point the URL of the SharePoint instance you wish to connect. For this example, I will be looking at the personal site of TestUser. You also have the option of connecting to the SharePoint instance either through Web Services or the API. With the Web Services option, you have the ability to specify custom credentials, whereas with the API, you're pretty much stuck with the currently logged in user. Let's take a look at the screen in detail:

Now that we have established our connection, let us take at the functions we can do in the CAML Editor. Once you log in, the left hand navigation will display the lists available to query against. In this instance, we will query against the Private Documents. I stored documents in this library of Foo.doc and Bar.doc. So, I will use the query tool to find only Foo.doc. As you click on the list you wish to query, the fields available will be populated. So, click the first Name instance, click the Where checkbox and fill out the Value as Foo.doc. Let's take a look at that screen now:

Now let's take a look at the CAML that it created for me in the bottom frame of the tool:

This of course is all well and good, but unfortunately, the drag and drop up above does not allow for specifying which ViewFields to include. You must at least from what I can see, enter them manually. Maybe I'm missing something somewhere. So, I click the Test and sure enough my data comes back as I expected as noted below:

We can specify dynamic parameters as well. Check the U2U blog for more things you can do with this tool:

http://blog.u2u.info/DottextWeb/patrick/archive/2005/05/29/3522.aspx

SharePoint - Creating a custom document library through ListTemplates

Matthew Podwysocki — Tue, 09 May 2006 20:15:00 GMT

I am currently on a rather large SharePoint implementation and over time I have gathered a lot of tips and tricks for SharePoint. Quite frankly, if you took any XML configuration files from SharePoint and really dissected it, it would take weeks to fully understand what each does.

Today, I am writing about how to create a custom document library through the ListTemplate and such. In my example, we will create a custom document library to store resumes from the standard document library on the personal site. First off, what we need to do is browse to the <Install Drive>\Program Files\Common Files\Microsoft Shared\web server extensions\60\TEMPLATE\1033\SPSPERS directory. From this directory, we will notice that there are several folders here, XML (which we will get into later) and LISTS.

The next step is to browse into the LISTS directory. Create a folder named "RESUMEDOCLIB". Since this is a simple document library with not much documentation there, we will copy the contents of the DOCLIB folder into the newly created RESUMEDOCLIB. Your new folder should have the contents of the following:

- AllItems.aspx

- DispForm.aspx

- EDITDLG.htm

- EditForm.aspx

- FILEDLG.htm

- SCHEMA.XML

- Upload.aspx

- webfldr.aspx

Before we get started, we need to make sure we are familiar with the field tables for default lists within SharePoint. Here is a good list of them from Microsoft: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/spptsdk/html/tsovFieldsTable_SV01084251.asp

The file that we are interested in now is the SCHEMA.XML. Open the file in a text editor (I prefer Textpad) and let's start going through it. Locate the line with <List which is around line 4. In this example, I will add a couple of fields to the list. We will add, Resume Name, Resume Short Description and Resume Long Description. Here is what it should look like when we are finished.

After adding these fields, we should also change the default view so that they can be easily viewed containing our new items. Do a search for ViewFields within this document. For me, it took me to line 984. We need to modify the FieldRef tags to show the fields we want. For example, we want to show DocIcon, LinkFileName,

Resume Name, Resume Short Description, Resume Long Description, Last Modified, Editor, and LinkCheckedOutTitle. Here is what the XML should look like after we are finished.

Save the file and let's move onto the ONET.XML. Browse back up to the SPSPERS\XML folder and open the ONET.XML file in your favorite text editor. In there, look for the <ListTemplate> XML Element. Now what we need to do is add an XML Element that describes our new document library. You can use the <ListTemplate> for doclib as an example. Our new XML Element should look like the following:

Now one last thing we need to do is create a list using this template. Do a search for <Lists> and it should put you near the location where we define lists. From here, we need to add an XML Element <List> for our new item. Below is the example of how we do this:

As you can see, it is not hard to do these things, but you must become familiar with the SharePoint XML which at times can be confusing. It is also quite nerve racking when you are dealing with XML configuration files this big. I hope that's a good start on where to go from here.

Free SharePoint Tool of the Week - InstallAssemblies

Matthew Podwysocki — Thu, 04 May 2006 20:54:00 GMT

While working on a large SharePoint deployment for a major corporation, I came across many interesting tools to make my life easier. During the development process, I found it to be a hassle to deploy WebParts to the server over and over again, going through those many steps. During my searching for tools, I discovered InstallAssemblies which is a wonderful tool to allow the easy deployment of WebPart libraries to a SharePoint server. The tool can be found as part of the Web Part Toolkit: http://www.bluedoglimited.com/Downloads/Files/1/Web%20Part%20Toolkit%20-%20v1.6.0.2.zip

I found this tool to be very simple to use and rather straightforward. This tool gives the user the ability to deploy a WebPart library and generate the dwps and the web part package. It also allows for the selection of the installation, whether it be the local bin or the Global Assembly Cache (GAC). This tool is great for local development on a Virtual PC or a VMWare image. I would never suggest to use this in any sort of production environment.

Now that we covered the basics, let's try running through this once. First, launch Visual Studio (In my case it is Visual Studio 2003 since my major clients still use it) and create a WebPart library. For this example, I used MyFirstWebPartLibrary as the WebPart library. Assign a strong name key to the assembly using the standard "sn -k MyKeyFile.snk" and use the file name in the AssemblyKeyFile attribute. Build the application into the local bin.

Next, launch the InstallAssemblies application from the location that you unzipped the archive file from above. Once the application is open, select the Web Part Deployment and select the Generate dwps and Save Web Part Package options. For this example, we will choose to install the application in the GAC and Generate SafeControl entries. Your screen should look like the following:

The neat part about this tool is to also view the generated dwp file. Click the View dwps button and it will launch a directory to view the directory which contains the dwp files. From that directory, I opened the dwp file in TextPad (my favorite text editor) and here are the results:

<?xml version="1.0"?>

<WebPart xmlns="http://schemas.microsoft.com/WebPart/v2">
<Assembly>MyFirstWebPartLibrary, Version=1.0.0.0, Culture=neutral, PublicKeyToken=233a0b797fd607df</Assembly>
<TypeName>MyFirstWebPartLibrary.WebPart1</TypeName>
<Title>WebPart1</Title>
</WebPart>

The only part left is to click the Install button in the upper right. Once the button is clicked, the status message area will be filled in with the results. Like I said, very easy tool to use and very handy during development.