/// <summary>
        ///		Clona una colección
        /// </summary>
        internal CategoryModelCollection Clone(TrackModel target)
        {
            CategoryModelCollection categories = new CategoryModelCollection();

            // Clona las categorías
            foreach (CategoryModel category in this)
            {
                categories.Add(category.Clone(target));
            }
            // Devuelve la colección clonada
            return(categories);
        }
        /// <summary>
        ///		Mezcla una colección de categorías
        /// </summary>
        public CategoryModelCollection Merge(TrackModel track, CategoryModelCollection categoriesNew)
        {
            CategoryModelCollection categoriesMerged = new CategoryModelCollection();

            // Mezcla las categorías
            foreach (CategoryModel categoryNew in categoriesNew)
            {
                CategoryModel categoryFound = Search(categoryNew.Id, categoryNew.Title);

                if (categoryFound == null)
                {
                    // Añade la categoría a la colección (indicando que está cargada)
                    categoryNew.IsLoaded = true;
                    Add(categoryNew.Clone(track));
                    // Añade la categoría a las categorías mezcladas
                    categoriesMerged.Add(categoryNew.Clone(track));
                }
                else
                {
                    EntryModelCollection entriesMerged = categoryFound.Entries.Merge(categoryNew.Entries);

                    // Si se han encontrado entradas nuevas, se añade a la lista de categorías mezcladas
                    if (entriesMerged.Count > 0)
                    {
                        CategoryModel categoryMerged = categoryFound.Clone(track);

                        // Limpia las entradas
                        categoryMerged.Entries.Clear();
                        // Añade sólo las entradas mezcladas
                        categoryMerged.Entries.AddRange(entriesMerged);
                        // y añade la categoría a la lista
                        categoriesMerged.Add(categoryMerged);
                    }
                }
            }
            // Devuelve la categorías en las que ha habido algún cambio
            return(categoriesMerged);
        }
        /// <summary>
        ///		Mezcla la colección de canales
        /// </summary>
        public TrackModelCollection Merge(TrackModelCollection tracksNew)
        {
            TrackModelCollection tracksMerged = new TrackModelCollection();

            // Mezcla la colección
            foreach (TrackModel trackNew in tracksNew)
            {
                TrackModel trackFound = Search(trackNew.Id);

                // Si el canal no estaba, se añade y se indica que se ha modificado
                if (trackFound == null)
                {
                    // Añade el canal
                    Add(trackNew);
                    // Añade el canal a la lista de canales mezclados
                    tracksMerged.Add(trackNew);
                }
                else
                {
                    CategoryModelCollection categoriesMerged = trackFound.Categories.Merge(trackFound, trackNew.Categories);

                    // Si se ha mezclado alguna categoría, se añade la pista
                    if (categoriesMerged.Count > 0)
                    {
                        TrackModel trackMerged = trackFound.Clone();

                        // Quita las categorías que tuviera
                        trackMerged.Categories.Clear();
                        // Le añade las mezcladas
                        trackMerged.Categories.AddRange(categoriesMerged.Clone(trackMerged));
                        // y añade el canal a la colección de canales mezclados
                        tracksMerged.Add(trackMerged);
                    }
                }
            }
            // Devuelve el valor que indica si ha habido algo nuevo
            return(tracksMerged);
        }