I encountered this problem recently, and it manifested itself when calling Update() on the list item from the custom Edit form.

We can initialise the UIImageView directly with an image, and this image supports using NSData to initialise it. It would seem we could simple get NSData from an NSURL, and bingo, we could load images easily from remote addresses. However, as you will find out – although this works, it essentially blocks the UI display thread until the image has loaded. This means that the display does not update until the image has been fetched from the web, and will present the user with what seems like an unusable pause.

To get round this we can implement lazy loading; where the request to retrieve the image is fired off asynchronously, and allows the UI display thread to continue till the image is received. Apple has an example in their dev knowledge base that allows you to do this directly on models. In this article we are going to look at doing this directly on a UIImageView.

In order to do this, we first create a header file for a class that inherits from UIImageView. We can call this UILazyImageView. It will, at first, look like the below:

#import <Foundation/Foundation.h>


@interface UILazyImageView : UIImageView {
}

@end

In order to implement the delegate for NSURLConnection, which we will use to do the asynchronous fetch of the image (as in last week’s post on creating an asynchronous XML parser for iOS applications); we will need a NSMutableData variable to store the data retrieved from the URL. We use NSMutableData rather than NSData, because we can append to it since it is a mutable data type.

We will also need a new initialisation method, to initialise with a URL; and this will call off to a method to load from a URL.

Having input these the header file will now look like this:

#import <Foundation/Foundation.h>


@interface UILazyImageView : UIImageView {
    NSMutableData *receivedData;    
}

- (id)initWithURL:(NSURL *)url;
- (void)loadWithURL:(NSURL *)url;

@end

Next, in our code (.m) file for UILazyImageView we can add the init method, which calls the load method, as follows:

- (id)initWithURL:(NSURL *)url
{
    self = [self init];
    
    if (self)
    {
	    receivedData = [[NSMutableData alloc] init];
        [self loadWithURL:url];
    }

    return self;
}

Next, we need to implement the loadWithURL method. This needs to fire of an asynchronous connection; the work of dealing with the image will only happen once the connection has completed.

This will look like:

- (void)loadWithURL:(NSURL *)url    
{
    NSURLConnection *connection = [NSURLConnection connectionWithRequest:[NSURLRequest requestWithURL:url]delegate:self];
    [connection start];
}

We now need to implement the delegate for the connection (which has been set to the UILazyImageView. For this we need to at least implement didReceiveResponse, didReceiveData and connectionDidFinishLoading.

We will implement didReceiveResponse to clear the data (as this may be called when 302 redirects occur); and didReceiveData to append to the receivedData item.

Finally in connectionDidFinishLoading we can display the image, from the receivedData.

This will look like:

- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response
{
    [receivedData setLength:0];
}

-(void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data
{
    [receivedData appendData:data];
}

- (void)connectionDidFinishLoading:(NSURLConnection *)connection
{
    self.image = [[UIImage alloc] initWithData:receivedData];
}

If we run this, we will notice it works as planned, but the image seems to appear very suddenly. We can make this a more gentle introduction, by setting the alpha to 0 before the connection begins, and then animating it to 1 (effectively creating a fade in effect).

We would do this with code like:

- (void)loadWithURL:(NSURL *)url    
{
	self.alpha = 0;
    NSURLConnection *connection = [NSURLConnection connectionWithRequest:[NSURLRequest requestWithURL:url]delegate:self];
    [connection start];
}

- (void)connectionDidFinishLoading:(NSURLConnection *)connection
{
    self.image = [[UIImage alloc] initWithData:receivedData];
    [UIView beginAnimations:@"fadeIn" context:NULL];
    [UIView setAnimationDuration:0.5];
    self.alpha = 1.0;
    [UIView commitAnimations];
}

In this article I am going to explore how to write an XML parser that parses XML from a given URL asynchronously by implementing the NSXMLParserDelegate protocol and the NSURLConnectionProtocol, and using the NSXMLParser and NSURLConnection objects.

If you do not have a good grounding in Objective C, first please go and have a read of a few tutorials; if you have a decent grounding in an object oriented language, you should pick it up fairly quickly – though the memory management side of things may be confusing (and will probably be for a while!), unless you come from a non GC language background.

For the purpose of this exercise we are going to assume we are tackling a standard RSS XML feed (SlashDot RSS), that we want to represent as a collection of objects to be used in our application.

The first thing we need is an object that we will use for the representation of each item in the RSS.

We can create this as a new object, deriving from NSObject, with instance variables and @property’s for each of the RSS items.

The object’s header file would look something like:

@interface RSSItem : NSObject {
    NSString *title;
    NSString *description;
}

@property (nonatomic, retain) NSString *title;
@property (nonatomic, retain) NSString *description;

@end

And its simple implementation file would like something like:

#import "RSSItem.h"

@implementation RSSItem

@synthesize title, description;

- (void)dealloc
{
    [title release];
    [description release];
    
    [super dealloc];
}

@end

The above obviously only captures two of our RSS elements, but as a proof-of-concept will be fine, and can be extended to capture more elements.

Now that we have this defined, we can define our RSSParser. Our RSSParser can inherit directly from NSObject, but we will need to define it to comply to the NSXMLParserDelegate protocol, which allows us to set it to be the delegate object for an NSXMLParser object, so that it can deal with the elements therein.

Our header file for RSSParser would, therefore, look something like:

#import "RSSItem.h"

@interface RSSParser : NSObject <NSXMLParserDelegate> {
	//This variable will eventually (once the asynchronous event has completed) hold all the RSSItems in the feed
    NSMutableArray *allItems;
    
    //This variable will be used to map properties in the XML to properties in the RSSItem object
    NSMutableArray *propertyMap;
    
    //This variable will be used to build up the data coming back from NSURLConnection
    NSMutableData *receivedData;
    
    //This item will be declared and created each time a new RSS item is encountered in the XML
    RSSItem *currentItem;
    
    //This stores the value of the XML element that is currently being processed
    NSMutableString *currentValue;
    
    //This allows the creating object to know when parsing has completed
    BOOL parsing;
    
    //This internal variable allows the object to know if the current property is inside an item element
    BOOL inItemElement;
}

@property (nonatomic, readonly) NSMutableArray *allItems;
@property (nonatomic, retain) NSMutableArray *propertyMap;
@property (nonatomic, retain) NSData *receivedData;
@property (nonatomic, retain) RSSItem *currentItem;
@property (nonatomic, retain) NSMutableString *currentValue;
@property BOOL parsing;

//This method kicks off a parse of a URL at a specified string
- (void)startParse:(NSString*)url;

@end

You will notice we have NOT specified that this object complies to the NSURLConnectionProtocol. The reason for this is that NSObject informally complies to this protocol by default, so we can add the necessary methods we need, and set this object as the delegate for the NSURLConnection object too.

So, when we first kick off a parse using the startParse: method, we will need to create an NSURLConnection object, which will kick off the retrieval of the data from the specified URL. Once this data is all retrieved we can then actually parse the XML.

We can use code similar to the following to achieve this:

- (void)startParse:(NSString *)url
{
    //Set the status to parsing
    parsing = true;

	//Initialise the receivedData object
    receivedData = [[NSMutableData alloc] init];
    
    //Create the connection with the string URL and kick it off
    NSURLConnection *urlConnection = [NSURLConnection connectionWithRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:url]] delegate:self];
    [urlConnection start];
}

As can be seen in our creation of the connection object, we have set the delegate to be the current object.

We can then define the methods we need to add the necessary data from the request as it comes back; and once it has all finished, to start the XML parser.

- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response
{
	//Reset the data as this could be fired if a redirect or other response occurs
    [receivedData setLength:0];
}

- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data
{
	//Append the received data each time this is called
    [receivedData appendData:data];
}

- (void)connectionDidFinishLoading:(NSURLConnection *)connection
{
	//Start the XML parser with the delegate pointing at the current object
    NSXMLParser *parser = [[NSXMLParser alloc] initWithData:receivedData];
    [parser setDelegate:self];
    [parser parse];
    
    parsing = false;
}

As can be seen, the implementation of this is very simple. In addition we should implement the method

- (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error

to handle the failure of the connection request.

Finally, once we have done this we can define the methods for the NSXMLParserDelegate protocol, so that the item is built and added to allItems correctly.

We can do this with code similar to the following:

- (void)parserDidStartDocument:(NSXMLParser *)parser
{
	//Create the property map that will be used to check and populate from elements
    propertyMap = [[NSMutableArray alloc] initWithObjects:@"title", @"description", nil];
    //Clear allItems each time we kick off a new parse
    [allItems removeAllObjects];
}

- (void)parser:(NSXMLParser *)parser didStartElement:(NSString *)elementName namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName attributes:(NSDictionary *)attributeDict
{
	//If we find an item element, then ensure that the object knows we are inside it, and that the new item is allocated
    if ([elementName isEqualToString:@"item"])
    {
        currentItem = [[RSSItem alloc] init];
        inItemElement = true;
    }
}

- (void)parser:(NSXMLParser *)parser didEndElement:(NSString *)elementName namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName
{
	//When we reach the end of an item element, we should add the RSSItem to the allItems array
    if ([elementName isEqualToString:@"item"])
    {
        [allItems addObject:currentItem];
        [currentItem release];
        currentItem = nil;
        inItemElement = false;
    }
    //If we are in element and we reach the end of an element in the propertyMap, we can trim its value and set it using the setValue method on RSSItem
    if (inItemElement)
    {
        if ([propertyMap containsObject:elementName])
        {
            [currentItem setValue:[currentValue stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]] forKey:elementName];
        }
    }
    
    //If we've reached the end of an element then we should the scrap the value regardless of whether we've used it
    [currentValue release];
    currentValue = nil;
}

- (void)parser:(NSXMLParser *)parser foundCharacters:(NSString *)string
{
	//When we find characters inside an element, we can add it to the current value, which is created if it is not initialized at present
    if (!currentValue)
    {
        currentValue = [[NSMutableString alloc] init];
    }
    [currentValue appendString:string];
}

As can be seen again, this implementation is very simple, but requires a slight degree of lateral thinking, compared to using a DOM based parser, as most programmers from a .NET background would be familiar with.

You may see List guids appended to the end of the Access Denied page URL, but these MAY NOT be directly at fault, and it’s worth a quick check to ensure that the Style Library has the correct permissions, as the XSL Style Sheets for the Summary Link Web Part are used directly from this web part.

Check that you have the correct password for the certificate. Be assure that the Mac client can read pfx files, and this does not require you to import the certificate into Keychain Access and export as a p12 file – as reported elsewhere.

If you don’t know what inbox zero is – you should read the articles at 43 folders first.

Google Mail gives us some additional tools that can really help over and above what the 43 folders articles offer. In this article I’m going to briefly outline some of the tools you can use with Google Mail to improve your productivity around email.

Much of what is referenced below uses the google lab features. If you are not familiar with them, look for the green conical jar icon in between your email address and the Settings menu in the top right of your Google Mail screen.

Using inbox zero, I went from 21,000 emails in my inbox to just actionable email (currently 5).

1. Filters and Labels

Create filters! Lots of them! Make this an active, on going process. The Gmail filters are very powerful, and so I’d recommend using these to clear your inbox. I don’t quite agree with the 43 folders motto of “Delete, delete, delete”. Instead, with Gmail, archive, archive, archive is the way forward. Make certain email types auto archive (for me this is Twitter, Facebook, LinkedIn etc.); and also make sure you label all emails that come in – this not only increases the findability of information in the future, but also ensures that you can deal with only the emails you want to at any moment. Archived emails are not visible to you, but you can use the powerful search functionality of Gmail to find old information at any time.

2. Nested Labels

There is a great lab feature available to enable nested labels. Nested labels allow you to create “folders” of labels; and this is great for being able to manage large numbers of labels (I have 60 labels, seperated into 3 main categories, some of which have sub categories).

3. Hide Read Labels

Another lab feature that is incredible is the “Hide Read Labels” lab. This hides any label which does not have any unread messages in it. Pairing this with auto archive, means that you can quickly come back to unread (though unimportant) messages at any time.

4. Send and Archive

Send and archive is a lab feature that allows you to archive a thread as soon as you send the response. Enable this to ensure that your inbox remains clean.

5. Tasks

Enable Google Tasks lab feature if you haven’t already, and then use the More Actions menu to create tasks from emails where you have actions within an email. You can then archive the email, and use the Google Tasks feature to manage your to do list. In addition, if you add a deadline to the task, this will appear in your Google Calendar.

When it came to my latest project, to architect the FAST search component of a system with a highly active userbase of 140,000, and a reasonably sized corpus of data (240 terabytes); with FAST Search Server 2010 for SharePoint chosen as the search server, I started to discover there were some holes, or at least some level of disjointing in the data presented by Microsoft.

The purpose of this article is to draw together some of this knowledge into a more coherent form to help future architects designing the topology and in particular ensuring that their design is performant and scalable.

This article assumes a reasonable knowledge of SharePoint and FAST search architecture.

FAST farms consist of two composite components:

• Service servers: one or more servers which holding one or more of the core roles. (Technet article)
• Search cluster matrix: one or more servers in a row/column structure to handle the indexing and query matching components. See the above article for detailed information on the performance of these services.

There are two primary drivers when considering the topology of our FAST farm. The size of the corpus, and the performance needed. In my case the performance I was aiming for was 350 queries per second (qps). The general rule of thumb with FAST is that you can reasonably expect 1qps performance for each 1ghz core available to the query matching component of FAST. This is assuming that you are using the search cluster model topology, and not a single server deployment.

Since we are looking for a performance of 350 qps, we can assume we need 350 cores at 1ghz, or 175 cores at 2 ghz. Since our target servers are running dual quad-core CPUs @ 2.93 ghz, we essentially have the ability to run 23.44 qps per query matching server ((1 x) 2.93 x 8). Dividing 350 through by 23.44 we round up to get 15. So we need 15 of our servers running the query matching service to achieve 350 qps throughput.

Once we know we need 15 query matching servers (ie. servers in the search row component of the clusters) we need to ensure this is arranged correctly in the server matrix to ensure that we can handle the corpus of data we need. In my case, we have a 30 million item corpus, however; allowing for reasonably growth, I am allowing for 60 million items. Since we can have a performant maximum of 15 million items per index column this means we are looking at 4 index columns.

The query matching servers MUST be distributed evenly between the index columns, so the closest we can get to 15 query matching servers is having 4 index columns with 4 query matching servers in each; a total of 16 query matching servers.

Each index column should also have at least one server running the indexer service. An additional index server can be used, but is present purely for failover.

On the storage sizing side of things, we have two types of storage needed:

• Local directly attached storage on the indexer boxes. This is used for the storage of the indices; and is stored in a flat file format. A good rule of thumb is to allow approximately 20% of the total corpus size for the indices.
• SQL Database storage for the Crawl Databases. These are used by the Content SSA in SharePoint to store metadata on the corpus crawled. A general rule of thumb is to use 5% of the total corpus size (in my case 240 terabytes, so a crawl DB allowance of 12 terabytes.) These can be scaled out across multiple crawl databases, and the best advice would be to host these on a separate box to the SharePoint database as they will be extremely intense on disk I/O; especially with a large, fast changing corpus.

When provisioning lookup fields in code, however, there don’t appear, at first, to be any additional properties to allow us to set these additional view fields.

However, when we are provisioning the fields to a field collection (using the AddLookup method), there is an additional method that allows us to provision these additional view fields. The AddDependentLookup method adds this field, and can be used on any SPFieldCollection (to add the field either as a Site Column, or as a Field directly on a list).

We can, therefore, use code similar to the below to achieve this:

	using (SPWeb web = SPContext.Current.Site.OpenWeb())
            {
                SPList lookupList = web.Lists["MyList"];
                string primaryFieldName = web.Fields.AddLookup("MyCol", lookupList.ID, false);
                SPFieldLookup primaryField = web.Fields.GetFieldByInternalName(primaryFieldName) as SPFieldLookup;
                primaryField.LookupField = "Title";
                primaryField.Update();
                string dependantFieldName = web.Fields.AddDependentLookup("MyCol:SubField", primaryField.Id);
                SPFieldLookup dependentField = web.Fields.GetFieldByInternalName(dependantFieldName) as SPFieldLookup;
                dependentField.LookupField = "SubField";
                dependentField.Update();
                web.Update();
            }

We can achieve the same with CAML by setting the FieldRef attribute of the Field element on the dependent field, to the ID of the primary field, and setting the ShowField attribute to the name of the Field to show from the Lookup List. This will have to be combined with a method to set the List ID from the List Name.

Once the .wsp has been built and deployed, it can be activated at the web scope. Once this is done, on all lists an item called “List attachment versioning” appears on the List Settings page. When accessed this allows the user to switch attachment versioning on or off. This in turn will create a hidden document library and hidden fields as necessary to support the attachment versioning.

Please do try it and let me know what you think.

Download the solution here.

Update: 17/11/2011 – Error fixed where the solution only works on a root site.

In order to overcome this in SharePoint 2010 there are a few things we must do. We need to attach receivers to the ItemAdding, ItemUpdating, ItemAttachmentAdding and ItemAttachmentDeleting methods. These will be used to push the attachments to a document library. Since we will use a document library to store the files, we will need to provision a document library. Finally we will need a custom number field we can use to store the current version of the ListItem. We need to do this because there is no way from the properties object in a receiver method to discover whether we are involved in a rollback. Therefore we can use a custom number field which we increment in the ItemAdding and ItemUpdating methods to store which version we are at. When a rollback occurs this field would also be attempted to be rolled back. We can detect this in the ItemUpdating receiver and therefore pull back documents which were at this version.

So to start with we initially create a Site Column with a Type of “Number”, and include this in our Content Type and List Definition. In addition we can create a ListInstance from this content type and a ListInstance of a document library, where the documents will be persisted. We will also need a custom Site Column of Type “Text” to hold the version numbers the attachment is associated with. We declare this with our normal Field and ListInstance syntax, using ContentTypeBinding to bind our content types to the lists we have created.

Next we need to create the receiver, as defined above. We can do this with a class like the following:

    /// <summary>
    /// Handles the redirection of attachments to a document library
    /// </summary>
    public class RedirectAttachmentsItemEventReceiver : SPItemEventReceiver
    {
        /// <summary>
        /// Local HTTP Context cache
        /// </summary>
        private HttpContext context;

        private string targetDocumentLibrary;
        private string targetLookupField;

        /// <summary>
        /// HTTP Context is available in creation
        /// </summary>
        public RedirectAttachmentsItemEventReceiver()
            : base()
        {
            context = HttpContext.Current;
        }

        /// <summary>
        /// Parses the receiver data string into private variables
        /// </summary>
        /// <param name="receiverData"></param>
        private void ParseReceiverData(string receiverData)
        {
            this.targetDocumentLibrary = receiverData.Split(';')[0];
            this.targetLookupField = receiverData.Split(';')[1];
        }

        /// <summary>
        /// Handles the adding of an attachment to the list
        /// Adds it into the document library
        /// </summary>
        /// <param name="properties"></param>
        public override void ItemAttachmentAdding(SPItemEventProperties properties)
        {
            base.ItemAttachmentAdding(properties);
            int attachmentNumber = 0;
            if (int.TryParse(SPContext.GetContext(context).Web.Properties["attachmentNumber"], out attachmentNumber))
            {
                attachmentNumber++;
                SPContext.GetContext(context).Web.Properties["attachmentNumber"] = attachmentNumber.ToString();
                ParseReceiverData(properties.ReceiverData);
                string fileName = properties.AfterUrl.Split('/')[4];
                //Put the item into the document library
                using (SPWeb web = properties.OpenWeb())
                {
                    SPList documentLibrary = web.Lists[targetDocumentLibrary];
                    SPFolder targetFolder;
                    try
                    {
                        targetFolder = documentLibrary.RootFolder.SubFolders[properties.ListItemId.ToString()];
                    }
                    catch
                    {
                        targetFolder = documentLibrary.RootFolder.SubFolders.Add(properties.ListItemId.ToString());
                    }
                    SPFile document;
                    try
                    {
                        document = targetFolder.Files[fileName];
                    }
                    catch (ArgumentException)
                    {
                        document = targetFolder.Files.Add(fileName, context.Request.Files[attachmentNumber - 1].InputStream);
                    }
                    if (document.Item["VersionLabel"] != null)
                        document.Item["VersionLabel"] = document.Item["VersionLabel"].ToString() + ";" + properties.ListItem.Versions[0].VersionLabel + ";";
                    else
                        document.Item["VersionLabel"] = ";" + properties.ListItem.Versions[0].VersionLabel + ";";
                    document.Item[targetLookupField] = new SPFieldLookupValue(properties.ListItem.ID, properties.ListItem.Title);
                    document.Item.Update();
                }
            }
        }

        /// <summary>
        /// Handles the deleting of an attachment from the list
        /// </summary>
        /// <param name="properties"></param>
        public override void ItemAttachmentDeleting(SPItemEventProperties properties)
        {
            base.ItemAttachmentDeleting(properties);
            ParseReceiverData(properties.ReceiverData);
            int nextVersion = (int)float.Parse(properties.ListItem["CustomVersion"].ToString()) + 1;
            string fileName = properties.BeforeUrl.Split('/')[4];
            //Put the item into the document library
            using (SPWeb web = properties.OpenWeb())
            {
                SPList documentLibrary = web.Lists[targetDocumentLibrary];
                SPFolder targetFolder;
                try
                {
                    targetFolder = documentLibrary.RootFolder.SubFolders[properties.ListItemId.ToString()];
                }
                catch
                {
                    targetFolder = documentLibrary.RootFolder.SubFolders.Add(properties.ListItemId.ToString());
                }
                SPFile document = targetFolder.Files[fileName];
                if (document.Item["VersionLabel"] != null)
                    document.Item["VersionLabel"] = document.Item["VersionLabel"].ToString().Replace(";" + nextVersion.ToString() + ".0;", "");
                document.Item.Update();
            }
        }

        /// <summary>
        /// Set the custom version property
        /// </summary>
        /// <param name="properties"></param>
        public override void ItemAdding(SPItemEventProperties properties)
        {
            base.ItemAdding(properties);
            ParseReceiverData(properties.ReceiverData);
            properties.AfterProperties["CustomVersion"] = 1;
            SPContext.GetContext(context).Web.Properties["attachmentNumber"] = "0";
        }

        /// <summary>
        /// Update the custom version property
        /// </summary>
        /// <param name="properties"></param>
        public override void ItemUpdating(SPItemEventProperties properties)
        {
            base.ItemUpdating(properties);
            SPContext.GetContext(context).Web.Properties["attachmentNumber"] = "0";
            ParseReceiverData(properties.ReceiverData);
            int currentVersion = (int)float.Parse(properties.ListItem["CustomVersion"].ToString());
            int newVersion;
            if (properties.AfterProperties["CustomVersion"] == null)
                newVersion = currentVersion;
            else
                newVersion = (int)float.Parse(properties.AfterProperties["CustomVersion"].ToString());
            int nextVersion = currentVersion + 1;
            using (SPWeb web = properties.OpenWeb())
            {
                SPList documentLibrary = web.Lists[targetDocumentLibrary];
                SPFolder targetFolder;
                try
                {
                    targetFolder = documentLibrary.RootFolder.SubFolders[properties.ListItemId.ToString()];
                }
                catch
                {
                    targetFolder = documentLibrary.RootFolder.SubFolders.Add(properties.ListItemId.ToString());
                }
                if (currentVersion > newVersion)
                {
                    EventFiringEnabled = false;
                    //Clear the list items attachments
                    List<string> attachmentsToDelete = new List<string>();
                    foreach (string attachmentName in properties.ListItem.Attachments)
                    {
                        attachmentsToDelete.Add(attachmentName);
                    }
                    foreach (string attachmentName in attachmentsToDelete)
                    {
                        properties.ListItem.Attachments.Delete(attachmentName);
                    }
                    //Pull attachments for this version
                    SPQuery query = new SPQuery();
                    query.ViewAttributes = "Scope='Recursive'";
                    query.Query = String.Format("<Where><And><Contains><FieldRef Name='VersionLabel' /><Value Type='Text'>;{0}.0;</Value></Contains><Eq><FieldRef Name='{1}' /><Value Type='Lookup'>{2}</Value></Eq></And></Where>", newVersion, targetLookupField, properties.ListItem.Title);
                    SPListItemCollection items = documentLibrary.GetItems(query);
                    foreach (SPListItem item in items)
                    {
                        properties.ListItem.Attachments.Add(item.File.Name, item.File.OpenBinary());
                        item["VersionLabel"] = item["VersionLabel"].ToString() + ";" + nextVersion.ToString() + ".0;";
                        item.SystemUpdate(false);
                    }
                    properties.ListItem.SystemUpdate(false);
                    EventFiringEnabled = true;
                }
                else
                {
                    //Update all attachments
                    foreach (string fileName in properties.ListItem.Attachments)
                    {
                        SPFile document = targetFolder.Files[fileName];
                        document.Item["VersionLabel"] = document.Item["VersionLabel"].ToString() + ";" + nextVersion.ToString() + ".0;";
                        document.Item.Update();
                    }
                }
            }
            properties.AfterProperties["CustomVersion"] = nextVersion;
        }
    }

In the class above we can see we are using the ReceiverData field which we will define below, when attaching the event receiver, to store the document library and the name of the lookup field in the content type that we will be using to link back. We are creating a folder per ID of the item in the master list, and using this folder to store all attachments against any version of this item. We are tracking the version on the master list, and can, using the ListItem values and the AfterProperties values deduce from this whether we are doing a rollback or not.

Finally we need to attach this to our list and let it know which document library to point at using the following syntax:

  <Receivers ListUrl="Lists/My List">
    <Receiver>
      <Name>RedirectAttachmentsItemEventReceiver</Name>
      <Assembly>$SharePoint.Project.AssemblyFullName$</Assembly>
      <Class>Ebenezer.RedirectAttachments.EventReceivers.RedirectAttachmentsItemEventReceiver</Class>
      <Type>ItemAttachmentAdding</Type>
      <SequenceNumber>10000</SequenceNumber>
      <Data>My List Attachments;My List</Data>
    </Receiver>
    <Receiver>
      <Name>RedirectAttachmentsItemEventReceiver</Name>
      <Assembly>$SharePoint.Project.AssemblyFullName$</Assembly>
      <Class>Ebenezer.RedirectAttachments.EventReceivers.RedirectAttachmentsItemEventReceiver</Class>
      <Type>ItemUpdating</Type>
      <SequenceNumber>10001</SequenceNumber>
      <Data>My List Attachments;My List</Data>
    </Receiver>
    <Receiver>
      <Name>RedirectAttachmentsItemEventReceiver</Name>
      <Assembly>$SharePoint.Project.AssemblyFullName$</Assembly>
      <Class>Ebenezer.RedirectAttachments.EventReceivers.RedirectAttachmentsItemEventReceiver</Class>
      <Type>ItemAdding</Type>
      <SequenceNumber>10002</SequenceNumber>
      <Data>My List Attachments;My List</Data>
    </Receiver>
    <Receiver>
      <Name>RedirectAttachmentsItemEventReceiver</Name>
      <Assembly>$SharePoint.Project.AssemblyFullName$</Assembly>
      <Class>Ebenezer.RedirectAttachments.EventReceivers.RedirectAttachmentsItemEventReceiver</Class>
      <Type>ItemAttachmentDeleting</Type>
      <SequenceNumber>10003</SequenceNumber>
      <Data>My List Attachments;My List</Data>
    </Receiver>
  </Receivers>

The advantage of this method is that no changes are needed to the out of the box edit/new forms in order for the attachments to be correctly versioned and updated with rollbacks.