Hi all,

Just a best practice question really.

I have an external web service that uses the content and media services in Umbraco to create page content and associated media items.

The process runs nightly but can also run on-demand with a user triggering it in Umbraco using a dashboard.

With regards to media, each page created by the process has an associated media folder in the media section. If the media folder already exists in the tree, it should be used to store child elements. If one does not exist, a new media folder should be created and child elements stored beneath it.

The process I have works but I am looking to improve it and making it faster and more robust as I wrote it 2 years ago when I first started developing in Umbraco.

Essentially I am doing the following:

1. Run an examine query against a custom index. This is used to quickly pull the id of the media folder so that it can then be used in conjunction with the media service to give me an IMedia object to work with.

2. If the above process fails, I used the Umbraco.Typed media helper to search for the specific folder I am looking for in conjunction with LINQ.

3. For the final stage, if all else has failed I use the media service directly along with LINQ to look for the specific media node in the database directly.

In theory, this should provide the fastest results as a lucene index should be fairly rapid and failing that the information would then come from the XML cache. Ultimately I want to try and cut down on calls made to the database. However, in practice I am finding that using the media service directly is actually faster than using the XML cache.

Example 1: Query using the Umbraco helper

Stopwatch xmlStopwatch = new Stopwatch();
xmlStopwatch.Start();
IPublishedContent xmlMediaObject = Umbraco.TypedMediaAtRoot().DescendantsOrSelf(umbraco_node.ContentType.Alias.ToLower() + "Images").Where(m => m.GetPropertyValue<string>("folderCode") == umbraco_node.ContentType.Alias.ToLower() + itemCode).FirstOrDefault();
xmlStopwatch.Stop();
TimeSpan xmlTimespan = xmlStopwatch.Elapsed;

Result : xmlTimespan = 00:01:10:003

Example 2: Query using the Media Service

Stopwatch databaseStopwatch = new Stopwatch();
databaseStopwatch.Start();

IMedia rootMedia = ms.GetRootMedia().Where(m => m.ContentType.Alias == umbraco_node.ContentType.Alias.ToLower() + "Images").FirstOrDefault();
if (rootMedia != null)
{
   databaseMediaObject = rootMedia.Children().Where(c => c.GetValue<string>("folderCode") == umbraco_node.ContentType.Alias.ToLower() + itemCode).FirstOrDefault();
}

databaseStopwatch.Stop();
TimeSpan databaseTimespan = databaseStopwatch.Elapsed;

Result : databaseTimespan = 00:00:00:311

This is running on localhost on my development machine but as you can see, accessing the database directly is much faster than accessing the XML cache.

I am aware that for this particular project there are a lot of media folders (approaching 150 as we speak) but generally I am looking to see what other people would do in this situation.

Remember this is just a fallback as I am initially searching using Examine but it would be great to get the view of other developers and their combined experience.

Thanks in advance.