public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin)
 {
   BuilderHelper.CheckParameter("ServiceClassName", itemData);
   string serviceClassName = itemData.Attributes["ServiceClassName"];
   object serviceInstance = plugin.InstantiatePluginObject(serviceClassName);
   if (serviceInstance == null)
   {
     ServiceRegistration.Get<ILogger>().Warn("ServiceBuilder: Could not instantiate service class '{0}' in plugin '{1}' (id: '{2}')",
         serviceClassName, itemData.PluginRuntime.Metadata.Name, itemData.PluginRuntime.Metadata.PluginId);
     return null;
   }
   string registrationClassAssembly;
   if (!itemData.Attributes.TryGetValue("RegistrationClassAssembly", out registrationClassAssembly))
     registrationClassAssembly = null;
   string registrationClassName;
   if (!itemData.Attributes.TryGetValue("RegistrationClassName", out registrationClassName))
     registrationClassName = null;
   Type registrationType;
   if (string.IsNullOrEmpty(registrationClassName))
     registrationType = serviceInstance.GetType();
   else
     registrationType = string.IsNullOrEmpty(registrationClassAssembly) ? plugin.GetPluginType(registrationClassName) :
         Type.GetType(registrationClassName + ", " + registrationClassAssembly);
   if (registrationType == null)
   {
     ServiceRegistration.Get<ILogger>().Warn("ServiceBuilder: Could not instantiate service registration type '{0}' (Assembly: '{1}') in plugin '{2}' (id: '{3}')",
         registrationClassName, registrationClassAssembly, itemData.PluginRuntime.Metadata.Name, itemData.PluginRuntime.Metadata.PluginId);
     return null;
   }
   return new ServiceItem(registrationType, serviceInstance);
 }

 public static void CheckParameter(string parameterName, PluginItemMetadata itemData)
 {
   if (!itemData.Attributes.ContainsKey(parameterName))
     throw new PluginItemBuildException(
         "'{0}' item at registration location '{1}' needs to specify the '{2}' parameter",
             itemData.BuilderName, itemData.RegistrationLocation, parameterName);
 }

 public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin)
 {
   BuilderHelper.CheckParameter("ClassName", itemData);
   BuilderHelper.CheckParameter("ProviderName", itemData);
   BuilderHelper.CheckParameter("Priority", itemData);
   return new ThumbnailProviderRegistration(plugin.GetPluginType(itemData.Attributes["ClassName"]), itemData.Id, itemData.Attributes["ProviderName"], itemData.Attributes["Priority"]);
 }

 protected static ConfigSectionMetadata BuildSection(PluginItemMetadata itemData, PluginRuntime plugin)
 {
   string location = ConfigBaseMetadata.ConcatLocations(itemData.RegistrationLocation, itemData.Id);
   string text = null;
   string iconSmallPath = null;
   string iconLargePath = null;
   foreach (KeyValuePair<string, string> attr in itemData.Attributes)
   {
     switch (attr.Key)
     {
       case "Text":
         text = attr.Value;
         break;
       case "IconSmallPath":
         iconSmallPath = attr.Value;
         break;
       case "IconLargePath":
         iconLargePath = attr.Value;
         break;
       default:
         throw new ArgumentException("'ConfigSection' builder doesn't define an attribute '" + attr.Key + "'");
     }
   }
   if (text == null)
     throw new ArgumentException("'ConfigSection' item needs an attribute 'Text'");
   return new ConfigSectionMetadata(location, text,
                                    plugin.Metadata.GetAbsolutePath(iconSmallPath),
                                    plugin.Metadata.GetAbsolutePath(iconLargePath));
 }

 public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin)
 {
   BuilderHelper.CheckParameter("ClassName", itemData);
   BuilderHelper.CheckParameter("Caption", itemData);
   BuilderHelper.CheckParameter("Sort", itemData);
   return new MediaItemActionExtension(plugin.GetPluginType(itemData.Attributes["ClassName"]), itemData.Attributes["Caption"], itemData.Attributes["Sort"], itemData.Id);
 }

 public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin)
 {
   BuilderHelper.CheckParameter("Type", itemData);
   BuilderHelper.CheckParameter("Directory", itemData);
   return new PluginResource(
       (PluginResourceType) Enum.Parse(typeof (PluginResourceType), itemData.Attributes["Type"]),
       plugin.Metadata.GetAbsolutePath(itemData.Attributes["Directory"]));
 }

 public void RevokeItem(object item, PluginItemMetadata itemData, PluginRuntime plugin)
 {
   BackgroundType type;
   string typeName = GetBackgroundAndType(itemData.Attributes, out type);
   switch (type)
   {
     case BackgroundType.Manager:
       plugin.RevokePluginObject(typeName);
       break;
   }
 }

 public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin)
 {
   BackgroundType type;
   string value = GetBackgroundAndType(itemData.Attributes, out type);
   switch (type)
   {
     case BackgroundType.Static:
       return new StaticBackgroundManager(value);
     case BackgroundType.Manager:
       // The cast is necessary here to ensure the returned instance is an IBackgroundManager
       return (IBackgroundManager) plugin.InstantiatePluginObject(value);
     default:
       throw new NotImplementedException(string.Format(
           "Background builder: Background type '{0}' is not implemented", type));
   }
 }

    public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin)
    {
      BuilderHelper.CheckParameter("ClassName", itemData);
      BuilderHelper.CheckParameter("Filter", itemData);
      // Support for simplified escaping inside XML tag
      string filter = itemData.Attributes["Filter"].Replace("{", "<").Replace("}", ">");
      FilterWrapper wrapper;

      if (_serializer == null)
        _serializer = new XmlSerializer(typeof(FilterWrapper));

      using (var reader = new StringReader(filter))
        wrapper = (FilterWrapper)_serializer.Deserialize(reader);

      return new MediaNavigationFilter(itemData.Attributes["ClassName"], wrapper.Filter);
    }

 protected static ConfigGroupMetadata BuildGroup(
   PluginItemMetadata itemData, PluginRuntime plugin)
 {
   string location = ConfigBaseMetadata.ConcatLocations(itemData.RegistrationLocation, itemData.Id);
   string text = null;
   foreach (KeyValuePair<string, string> attr in itemData.Attributes)
   {
     switch (attr.Key)
     {
       case "Text":
         text = attr.Value;
         break;
       default:
         throw new ArgumentException("'ConfigGroup' builder doesn't define an attribute '" + attr.Key + "'");
     }
   }
   if (text == null)
     throw new ArgumentException("'ConfigGroup' item needs an attribute 'Text'");
   return new ConfigGroupMetadata(location, text);
 }

 protected WorkflowState BuildWorkflowState(PluginItemMetadata itemData)
 {
   IDictionary<string, string> attributes = itemData.Attributes;
   Guid id = Guid.Empty;
   try
   {
     string name;
     string displayLabel;
     bool isTemporary = false;
     string mainScreen = null;
     bool inheritMenu = false;
     Guid? workflowModelId = null;
     if (string.IsNullOrEmpty(itemData.Id))
       throw new ArgumentException(string.Format("WorkflowState: Id must be specified"));
     id = new Guid(itemData.Id);
     if (!attributes.TryGetValue("Name", out name))
       throw new ArgumentException(string.Format("WorkflowState with id '{0}': 'Name' attribute missing", id));
     if (!attributes.TryGetValue("DisplayLabel", out displayLabel))
       throw new ArgumentException(string.Format("WorkflowState with id '{0}': 'DisplayLabel' attribute missing", id));
     string tmpStr;
     if (attributes.TryGetValue("WorkflowModel", out tmpStr))
       workflowModelId = new Guid(tmpStr);
     if (!attributes.TryGetValue("MainScreen", out mainScreen))
     {
       mainScreen = null;
       if (workflowModelId == null)
         throw new ArgumentException(string.Format("WorkflowState '{0}': Either 'WorkflowModel' or 'MainScreen' atrribute must be specified", name));
     }
     if (attributes.TryGetValue("Temporary", out tmpStr) && !bool.TryParse(tmpStr, out isTemporary))
       throw new ArgumentException("'Temporary' attribute has to be of type bool");
     if (attributes.TryGetValue("InheritMenu", out tmpStr) && !bool.TryParse(tmpStr, out inheritMenu))
       throw new ArgumentException("'InheritMenu' attribute has to be of type bool");
     return new WorkflowState(id, name, displayLabel, isTemporary, mainScreen, inheritMenu, false,
         workflowModelId, WorkflowType.Workflow);
   }
   catch (Exception e)
   {
     ServiceRegistration.Get<ILogger>().Error("WorkflowStateBuilder: Workflow state '{0}' cannot be built", e, id);
     return null;
   }
 }

 /// <summary>
 /// Registers the specified plugin item in the plugin tree.
 /// </summary>
 /// <param name="itemMetadata">Metadata structure of the item to register.</param>
 /// <returns><c>true</c>, if the plugin item could be registered, <c>false</c>,
 /// if the item already existed and <see cref="PluginItemMetadata.IsRedundant"/> is specified.</returns>
 /// <exception cref="ArgumentException">If there is already an item registered at the registration
 /// location and the <see cref="PluginItemMetadata.IsRedundant"/> flag is not set.</exception>
 internal bool RegisterItem(PluginItemMetadata itemMetadata)
 {
   lock (_syncObj)
   {
     IRegistryNode node = GetRegistryNode(itemMetadata.RegistrationLocation, true);
     itemMetadata.PluginRuntime = this;
     if (node.Items != null && node.Items.ContainsKey(itemMetadata.Id))
       if (itemMetadata.IsRedundant)
       {
         PluginItemRegistration itemRegistration = (PluginItemRegistration) node.Items[itemMetadata.Id];
         itemRegistration.AdditionalRedundantItemsMetadata.Add(itemMetadata);
         return false;
       }
       else
         throw new ArgumentException(string.Format("At location '{0}', a plugin item with id '{1}' is already registered",
             itemMetadata.RegistrationLocation, itemMetadata.Id));
     PluginItemRegistration resultItemRegistration = new PluginItemRegistration(itemMetadata);
     node.AddItem(itemMetadata.Id, resultItemRegistration);
     _itemRegistrations.Add(itemMetadata, resultItemRegistration);
   }
   return true;
 }

 public bool NeedsPluginActive(PluginItemMetadata itemData, PluginRuntime plugin)
 {
   BackgroundType type;
   string value = GetBackgroundAndType(itemData.Attributes, out type);
   if (type == BackgroundType.Static)
     return false;
   if (type == BackgroundType.Manager)
     return true;
   throw new NotImplementedException(string.Format(
       "Background builder: Background type '{0}' is not implemented", type));
 }

 public bool NeedsPluginActive(PluginItemMetadata itemData, PluginRuntime plugin)
 {
   return itemData.BuilderName != "ConfigSection" && itemData.BuilderName != "ConfigGroup";
 }

 public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin)
 {
   BuilderHelper.CheckParameter("MediaItemAspectTypeId", itemData);
   return new MIATypeRegistration { MediaItemAspectTypeId = new Guid(itemData.Attributes["MediaItemAspectTypeId"]) };
 }

 public void RevokeItem(object item, PluginItemMetadata itemData, PluginRuntime plugin)
 {
   // Noting to do
 }

 public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin)
 {
   if (itemData.BuilderName == "WorkflowState")
     return BuildWorkflowState(itemData);
   if (itemData.BuilderName == "DialogState")
     return BuildDialogState(itemData);
   return null;
 }

 public void RevokeItem(object item, PluginItemMetadata itemData, PluginRuntime plugin)
 {
   if (item == null)
     return;
   plugin.RevokePluginObject(item.GetType().FullName);
 }

 protected static ConfigSettingMetadata BuildSetting(
   PluginItemMetadata itemData, PluginRuntime plugin)
 {
   string location = ConfigBaseMetadata.ConcatLocations(itemData.RegistrationLocation, itemData.Id);
   string text = null;
   string className = null;
   string helpText = null;
   ICollection<string> listenTo = null;
   foreach (KeyValuePair<string, string> attr in itemData.Attributes)
   {
     switch (attr.Key)
     {
       case "Text":
         text = attr.Value;
         break;
       case "ClassName":
         className = attr.Value;
         break;
       case "HelpText":
         helpText = attr.Value;
         break;
       case "ListenTo":
         listenTo = ParseListenTo(attr.Value);
         break;
       default:
         throw new ArgumentException("'ConfigSetting' builder doesn't define an attribute '" + attr.Key+ "'");
     }
   }
   if (text == null)
     throw new ArgumentException("'ConfigSetting' item needs an attribute 'Text'");
   return new ConfigSettingMetadata(location, text, className, helpText, listenTo);
 }

 public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin)
 {
   BuilderHelper.CheckParameter("ClassName", itemData);
   return plugin.InstantiatePluginObject(itemData.Attributes["ClassName"]);
 }