Brian Wilson : How To

Event Handlers - Part 3: Register Event Handlers plus free Site Settings – Manage Event Handlers Add-on solution

Brian Wilson — Sun, 18 Mar 2007 21:31:00 GMT

This post is the third post of a 3 post series.

Post 1: Everything you need to know about MOSS Event Handlers

Post 2: Developer Solution Starter Kit (Building and deploying event handlers to MOSS)

Post 3: Registering Event Handlers plus Site Settings - Manage Event Handlers

In the first post, I discussed the benefits of using Event Handlers in Microsoft Office SharePoint Portal Server 2007 (MOSS).

In the second post, I discussed how to develop and deploy Event Handler solutions for Microsoft Office SharePoint Portal Server 2007 (MOSS).

In this post I will discuss the various mechanisms to attach (register) your event handler assembly to a site, list, or content type. The "Site Settings – Manage Event Handlers Add-on" solution is hosted on CodePlex. Here is the link:

Codeplex Project : http://www.codeplex.com/SPSCustomAdmin/

(If any of you are interested in getting involved, I am interested in building more Site Settings addons. Please email me at brwil at microsoft dot com if you would like to get involved in expanding this framework. I will discuss the ideas i have in more detail in a future blog post.)

Overview

So you have deployed the assembly to the farm, now what? How do I register an event in your assembly for a Site, List, or Content Type?

I will describe three ways to deploy your assembly’s events.

1) Manage EventReceivers via Code

2) Deploy event handlers using the Feature framework of MOSS 2007

3) A cool custom Site Settings Application I built to manage (view, add, edit and delete) event handlers.

Managing EventReceivers via Code

The site (SPWeb) object, the list (SPList) object and the Content Type (SPContentType) object expose a collection called EventReceivers based on the SPEventReceiverDefinitionCollection class.

This collection maintains a set of SPEventReceiverDefinition objects (events) attached to a site, list or content type.

Adding Event Handlers (SPEventReceiverDefinition)

This class provides an “Add” method to attach a new SPEventReceiverDefinition (We created and deployed these to MOSS in Post 1 and 2.) The Add method asks for three bits of information:

· SPEventReceiverType: This tells SharePoint the type of event receiver we are adding to the EventReceiver collection.

· Assembly name: The name of the assembly. E.g. “Litwarehandlers, Version 1.0.0.0, Culture=neutral, PublicKeyToken=a6ab42c509981682”

· Class name: The name of the class. E.g. “Litwarehandlers.SiteHandlerClass”

(An easy way to get this information is to use our trusty old friend, Lutz Roeder’s Reflector application. Simply reflect the class and copy and paste the information you need.)

Once attached, the site, list or content type will now start picking up these events and executing your assemblies code.

Modifying Sequence Numbers

Another important property you may want to set for each event you attach is the Sequence Number. The sequence number determines the order your event assemblies’ fire. This is especially important when you have created multiple assemblies that are all attached to the same Site, List or Content Type event.

To modify the Sequence Number, you need to retrieve the SPEventReceiverDefinition object from the EventReceivers collection.

· Site: site.EventReceivers

· List: list.EventReceivers

· Content Type: site.ContentTypes[content type name].EventReceivers

A suggested best practice (and only my opinion), do not use sequence numbers below 10000 as SharePoint uses event handlers extensively to run SharePoint Workflows, etc. These event handlers use Sequence Numbers, starting at 1000.

Deleting Event Handlers (SPEventReceiverDefinitions)

When removing definitions, here is what you have to do:

Site:

· Attach to the site (SPWeb)

· Lookup the SPEventReceiverDefinition object in the site.EventReceivers collection.

· Use the delete method of the SPEventReceiverDefinition object to remove it from the collection.

· Call the site.Update() method.

List:

· Attach to the site (SPWeb)

· Retrieve the list : (site.Lists[GUID or listname])

· Lookup the SPEventReceiverDefinition object in the list.EventReceivers collection.

· Use the delete method of the SPEventReceiverDefinition object to remove it from the collection.

· Call the list.Update() method.

Content Types:

· Attach to the site (SPWeb)

· Retrieve the SPContentType (site.ContentTypes[SPContentTypeId])

· Retrieve the SPEventReceiverDefinition object : (SPContentType.EventReceivers[GUID])

· Use the delete method of the SPEventReceiverDefinition object to remove it from the collection.

· Call the SPContentType.Update() method.

Managing assemblies using Features

It is possible to create a feature that deploys your event handler to the assembly.

MSDN has an example on how to achieve this: http://msdn2.microsoft.com/en-us/library/ms453149.aspx

See screenshot of the xml you need to write to deploy an event via the features framework:

Limitations:

· It is difficult to see what event handlers are installed and the sequence they are firing for a site, list or content type. To modify, requires rebuilding the feature with the correct settings.

· Using a feature, “hardcodes” the event handler to an individual list or Content Type. Each time you want to use the SAME event handler, you are forced to write another feature to register it.

In my opinion, wrapping functionality as a feature is cool, but is overkill for registering event handlers. This is my reason for building a view, add, edit and remove application via Site Settings. See below! J

Managing EventReceivers using Site Settings application assemblies

Features

The Manage Event Handler site settings application provides you with the ability to view all events that have been associated to a site, any list of that site, and all Content Types for that site.

You can add event handlers, edit the sequence numbers and delete events registrations. Once the feature is activated, it is accessible from the Site Settings of any site

Feature – Event Handler Screenshot

Site Settings Event Handlers Screenshot

Manage Event Handlers" style="WIDTH: 916px; HEIGHT: 844px" height=844 alt="Site Settings > Manage Event Handlers" src="http://blogs.msdn.com/photos/brian_wilson/images/1909625/original.aspx" width=916 mce_src="http://blogs.msdn.com/photos/brian_wilson/images/1909625/original.aspx">

View Event Hhandlers Screenshot:

Add Event handlers Screenshot:

Edit Event handlers Screenshot:

Delete Event handlers Screenshot

Firstly, download the solution deployment code and wsp file from CodePlex here, and install in your SharePoint environment. (If you pick up any issues or have feature requests, please let me know so that I can add these to future releases.)

How to install

1. Follow the steps in my previous post in the "Deploying your assembly to staging and production" section. It provides step by step instructions on how to install a wsp file.

2. Navigate to any site and open Site Settings.

3. Open “Site Features” under the Site Administration column.

4. Activate the new feature called “Manage Event Handlers”. This enables event handler management application for this site.

5. Navigate back to Site Settings. A new option is now available under the “Site Administration column” called “Manage Event Handlers”. Select this option.

Notes

I have removed the ability to edit or delete native SharePoint generated event associations as this may affect the stability of SharePoint Out-Of-The-Box functionality. Only YOUR events can be managed.

Content Types (and their associated event handlers) can only be managed via the root site of the site collection.

In case you are wondering how to go about building your own site settings applications I have posted the code on CodePlex. I am planning on building an additional site settings administration application to manage and configure site properties.

Summary

If you have any questions, add a comment and time permitting, I will try to respond as soon as possible.

Event Handlers - Part 2: Building and Deploying Event Handlers (Including Event Handler Starter Solution Kit)

Brian Wilson — Sun, 18 Mar 2007 17:04:00 GMT

This post is the second post of a 3 post series.

Post 1: Everything you need to know about MOSS Event Handlers

Post 2: Developer Solution Starter Kit (Building and deploying event handlers to MOSS)

Post 3: Registering Event Handlers plus Site Settings - Manage Event Handlers

Overview

In the first post, I discussed the benefits of using Event Handlers in Microsoft Office SharePoint Server 2007 (MOSS). Today I intend to discuss how to develop and deploy event handlers to your farm environment.

I have used CodePlex to host the Event Handler Solution Starter Kit Project. The solution starter kit contains two projects, one project that contains the assembly and another that contains a solution deployment package builder project.

Download the EventHandlerSolutionStarterKit.zip to get started.

(In the third post, I will discuss the various mechanisms to attach (register) your assembly to a site, list, or content type. I will also share a cool add-on I developed for MOSS that allows you to manage event handlers via a custom Site Settings Administration Application).

Building Event Handlers for SharePoint

Development Environment

I recommend building a Virtual PC that has MOSS 2007, and Visual Studio 2005. There are numerous posts out there on how to build your environment, so I won’t go into that.

One point I will make is to keep a copy of virtual hard disk once you have finished building it. I find MOSS 2007 Virtual PC’s degrade over time due to defragmentation, dev, etc. It is easier to make a copy of your original hard disk and continue developing.

Steps

Use the following steps if you want to create your solution from scratch otherwise download the starter kit and continue from Step 7.

1) Open Visual Studio 2005.

2) Create a new class library project.

3) Reference the Microsoft.SharePoint assembly.

4) Rename the default class to the name you want to give your event handler class. E.g. ItemHandler

5) Add your “using” statement: “using Microsoft.SharePoint;”

6) Inherit from the following SharePoint base classes depending on what type of event handler your want to create:

a. Site : SPWebEventReceiver

b. List Columns : SPListEventReceiver

c. List Items : SPItemEventReceiver

d. Email : SPEmailEventReciever

7) In your class, type “override” and let IntelliSense provide you with a list of events to override.

8) Implement the logic in the overridden method(s).

9) Compile, fix errors, recompile until build succeeds.

10) Strongly name your assembly ( sign your assembly )

a. Right Click your Class Library Project

b. Select Signing Tab

c. Choose a strong name key file:

i. <browse> = select a previously created key file.

ii. <new> = create a new key file.

Deploying your Assembly to staging and production

Steps

1) Create a solution deployment file (*.wsp file)

A solution deployment file is simply a cab file with a manifest file. It contains all the files and information of your solution. The manifest file tells SharePoint what to do with the files in your solution.

To get started, download my solution starter kit. This contains a visual studio deployment file creator project based on Vincent Rothwell’s fantastic visual studio deployment project template to create the *.wsp file. Have a look at his blog and codeplex project for more information on using this functionality:

· Blog: VS.Net SharePoint Solution Template on CodePlex

· CodePlex: http://www.codeplex.com/sptemplateland/

NOTE: I have customized the CreateManifest.vbs script in the deployment project so that it only creates the relevant entries to deploy the assembly dll to the GAC.

If you want to build your own deployment project from scratch or learn more about this feature of MOSS, have a look at the following articles on the Microsoft Developer Network (MSDN):

· Solutions Overview

· Creating a Solution

· Deploying a Solution

· Upgrading a Solution

· Retracting a Solution

· Localizing a Solution

· Solution Schema

2) Register your wsp file using stsadm.exe with SharePoint

Once you have created your SharePoint solution deployment file, you need to tell SharePoint about this. Here are the steps you need to follow to register your solution in SharePoint:

· Open up Command Prompt (Start > Run > cmd.exe)

· Navigate to the location of stsadm.exe utility in the “12” hive by typing the following into the command prompt (assuming default installation to C: drive)

o cd\

o cd C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\BIN

· Run the following command

stsadm.exe –o addsolution –filename C:\replacewithpathtofile\filename.wsp

3) Push solution to SharePoint farm

You have two options:

· Navigate to Central Administration >Operations > Solution Management. You should see your newly added solution in the list.

o Click on it to view the solution details page.

o Select Deploy Solution on the toolbar.

· Alternatively, you could replace the option above and deploy the solution via the command prompt using the following command:

stsadm.exe –o deploysolution –name filename.wsp –local –allowgacdeployment –allcontenturls

Summary

A sign of a great developer is the ability to put the finishing touches on the development effort. When it comes to deployment, you aim to achieve the following goals:

1. Simple to deploy!

o Use SharePoint solution deployment (*.wsp) files

o Script the installation to deploy your wsp files

o Document (Readme) files for any settings/ procedures to install/ “gotchas”.

2. Simple to maintain!

What maintenance tasks must be performed by SharePoint Administrators? Is it documented? If you or they left the company, would your solution degrade and die a horrible death (which would inevitably be blamed on you)? Where are you storing your maintenance documentation? Have you thought of adding tasks to SharePoint Central Administration Task List to remind people of administrative tasks?

3. Simple to upgrade!

This is something that we often forget to think about upfront, resulting in loss of our solution’s future agility. All solutions are developed in phases. The first phase is normally the core of the solution. Subsequent phases add on functionality to your solution. These need to be deployed to replace/ add on to your solution. SharePoint Solution Deployment manages this for you, so know and use this feature of MOSS 2007.

4. Consistency and Repeatability!

This applies to how your solution is deployed to staging and production environments. You will not always be the person deploying it! Follow a standard pattern of deployment to minimise mistakes or random variations in the deployment process.

If you have any questions, add a comment and time permitting, I will try to respond.

Goodluck!

Event Handlers - Part 1: Everything you need to know about Microsoft Office SharePoint Server (MOSS) Event Handlers.

Brian Wilson — Mon, 05 Mar 2007 13:07:00 GMT

This post is the first post of 3 posts.

Post 1: Everything you need to know about MOSS Event Handlers

Post 2: Developer Solution Starter Kit (Building and deploying event handlers to MOSS)

Post 3: Registering Event Handlers plus Site Settings - Manage Event Handlers

Overview

Today I want to talk in depth about a feature of Microsoft Office SharePoint Server 2007 (MOSS) that shows you just how extensible the SharePoint 2007 platform is! That feature is the ability to add custom event handlers to sites, lists, items and content types in your portal.

What is a custom event handler? A custom event handler is a .Net assembly that contains the additional business logic you need to run when the event occurs in SharePoint.

Why did I pick this feature? Well, no portal or business application ever really lives in isolation to your other Line of Business (LOB) applications, and shouldn't! Your portal solution needs to be dynamic, expect change and work seamlessly with the other systems in your environment. So, you may ask, what does this have to do with Event Handlers?

Well, event handlers allow you to add [SOMETHING] your business needs into the functionality of SharePoint. [SOMETHING] examples:

o Retrieve information from a database such as filling in the remaining fields of a list based on a CustomerID (assuming you don't have an enterprise license for BDC)

o Call a web service

o Start a workflow

o Perform list data validation

o Convert document to PDF and store in alternative list.

o Access data in another list.

The possibilities around writing custom event handlers to perform an action based on an event in SharePoint 2007 are endless!

Event Types

Here is a list of events that you can hook into:

· Microsoft.SharePoint.SPWebEventReceiver : "Site Level"

SiteDeleted	Occurs after a site collection has been deleted.
SiteDeleting	Occurs when a site collection is being deleted.
WebDeleted	Asynchronous Afterevent that occurs after an existing Web site is completely deleted.
WebDeleting	Synchronous before event that occurs before an existing Web site is completely deleted.
WebMoved	Asynchronous after event that occurs after an existing Web site has been moved.
WebMoving	Synchronous before event that occurs before an existing Web site has been renamed or moved to a different parent object.

· Microsoft.SharePoint.SPListEventReceiver : "List Level"

FieldAdded	Occurs after a field link is added.
FieldAdding	Occurs when a field link is being added to a content type.
FieldDeleted	Occurs after a field has been removed from the list.
FieldDeleting	Occurs when a field is in the process of being removed from the list.
FieldUpdated	Occurs after a field link has been updated
FieldUpdating	Occurs when a field link is being updated

· Microsoft.SharePoint.SPItemEventReceiver : "List Item Level"

ItemAdded	Asynchronous After event that occurs after a new item has been added to its containing object.
ItemAdding	Synchronous before event that occurs when a new item is added to its containing object.
ItemAttachmentAdded	Asynchronous after event that occurs after a user adds an attachment to an item.
ItemAttachmentAdding	Synchronous before event that occurs when a user adds an attachment to an item.
ItemAttachmentDeleted	Asynchronous after event that occurs when after a user removes an attachment from an item.
ItemAttachmentDeleting	Synchronous before event that occurs when a user removes an attachment from an item.
ItemCheckedIn	Asynchronous after event that occurs after an item is checked in.
ItemCheckedOut	Asynchronous after event that occurs after an item is checked out.
ItemCheckingIn	Synchronous before event that occurs as a file is being checked in.
ItemCheckingOut	Synchronous before event that occurs after an item is checked out.
ItemDeleted	Asynchronous after event that occurs after an existing item is completely deleted.
ItemDeleting	Synchronous before event that occurs before an existing item is completely deleted.
ItemFileConverted
ItemFileMoved	Occurs after a file is moved.
ItemFileMoving	Occurs when a file is being moved.
ItemUncheckedOut	Synchronous before event that occurs when an item is being unchecked out.
ItemUncheckingOut	Synchronous before event that occurs when an item is being unchecked out.
ItemUpdated	Asynchronous after event that occurs after an existing item is changed, for example, when the user changes data in one or more fields.
ItemUpdating	Synchronous before event that occurs when an existing item is changed, for example, when the user changes data in one or more fields.

Asynchronous vs Synchronous Events: The "ing" and the "ed"

As you may have noticed above, there are two events raised for each type of event. The "...ing" event occurs before the action starts and the "...ed" occurs after the actions ends. "...ing" events occur synchronously while the "...ed" events occur asynchronously. What does this mean?

Synchronous events:

· Occur before the event.

· Block the flow of code execution until your event handler completes.

· Provide you with the ability to cancel the events resulting in no after event (“...ed") being fired.

Asynchronous events:

· Occur after the event.

· Do not block the flow of code execution in SharePoint.

Combining Custom Event Handlers with Content Types = POWER!

Content Type is just what it sounds like: a metadata description of content that can include custom properties, a retention policy, and an associated set of workflows and business processes.

For example, a company may define a “Contract” Content Type that includes the required metadata to make it easy to find that contract later.

The “Contract” Content Type is now a metadata description definition that can be associated to lists such as Document Libraries in your SharePoint environment. Once added, you now have the ability to add and manage Contracts added to your portal.

This is where Event Handlers come in: You can attach custom event handlers to a Content Type! Once attached to the Content Type definition, it picks up the events wherever you use the content type. This is extremely powerful! Why? Well, you have the ability to target individual content types across the entire site collection. For example, wherever a “Contract” Content Type is used, you could store a link in another system for each Contract created in your system, no matter what document library the contract is stored in.

Best Practices

When building custom event handlers, keep the following points in mind:

1. Security:

The assembly you deploy to the Global Assembly Cache(GAC) is running with full trust. Watch out for the following:

· Denial of Service attack: If a user uploads 10000 items to a list, what is the effect it will have to the systems your assembly uses.

· SQL Injection attack: If a user attempts to insert SQL statements into a column of a list that your assembly uses to update a database, what mechanisms are you using to make sure the input is valid.

· Cross Site scripting attack: What is the effect of adding script to a column that your assembly uses to update another area in SharePoint?

2. Performance:

Watch out for the following:

· Load: What burden are you placing on your web front end servers to run the assembly each time an event occurs? Use performance counters to determine this.

· Long Running Operations: Consider creating a custom SharePoint timer job. Kick off/ Schedule the Timer Job from the event rather than running all the logic inside the event. This will allow you to use the features of SharePoint to view whether the Timer Job ran successfully.

· Sync vs Async Events: Synchronous events have to wait until your code completes before returning the page, whereas Asynchronous events show the page immediately.

3. Error Handling:

When using synchronous events and you decide to cancel an event, let the user know why the event was cancelled. For example, update a Task List with a message why it failed.

Log your errors so that you can determine what issue is occurring when your system is in production environment.

4. Connections: Cater for external systems being down when you are trying to connect to them. Don’t let your code / solution go belly up because you cannot connect to a database.

5. Bulk Operations:

The MSDN documentation mentions that event handlers will not fire when bulk operation is occurring. For example, when a new list is created, the FieldAdding event will not fire.

Limitations of Event Handler in SharePoint

Strangely there is no “SiteAdding”, “SiteAdded” event. However, if you really need this event you could create a “feature” to accomplish this. Features in SharePoint have a “FeatureActivated” event, where you could perform an action on creation of a site.

Summary

Custom Event handlers are a powerful tool in your arsenal as a SharePoint Architect/ Developer!