BeWoPlaner/Shared/Extensions/IListTExtensions.cs

using System;
using System.Collections.Generic;
using System.Linq;

namespace BS.Shared.Extensions
{
    public static class IListTExtensions
    {
        public static void AddIfNotIn<T>(this IList<T> pList, T pToAdd)
        {
            if (!pList.Contains(pToAdd))
            {
                pList.Add(pToAdd);
            }
        }

	    public static void AddRangeIfElementsNotIn<T>(this IList<T> pList, IEnumerable<T> pToAdd)
	    {
			foreach (var iItem in pToAdd)
			{
				pList.AddIfNotIn(iItem);
			}
	    }

        public static void AddRange<T>(this IList<T> pList, IEnumerable<T> pToAdd)
        {
            foreach (T iItem in pToAdd)
            {
                pList.Add(iItem);
            }
        }

        public static bool Exists<T>(this IList<T> pList, Predicate<T> pMatch)
        {
            foreach (T iItem in pList)
            {
                if (pMatch(iItem))
                {
                    return true;
                }
            }

            return false;
        }

        public static void MakeEqualTo<T>(this IList<T> plist, IList<T> otherList)
        {
            var toRemove = new List<T>();

            foreach (T t in plist)
            {
                if (!otherList.Contains(t))
                {
                    toRemove.Add(t);
                }
            }

            plist.RemoveRange(toRemove);

            foreach (T t in otherList)
            {
                if (!plist.Contains(t))
                {
                    plist.Insert(otherList.IndexOf(t), t);
                }
            }
        }

		public static void UpdateBy<T>(this IList<T> a_list, IList<T> b_list)
		{
            // Elemente entfernen, die in der Zielliste nicht mehr vorkommen.
            // Rückwärts iterieren, damit RemoveAt die noch zu prüfenden Indizes nicht verschiebt.
            for (int i = a_list.Count - 1; i >= 0; i--)
            {
                if (!b_list.Contains(a_list[i]))
                    a_list.RemoveAt(i);
            }

            // Reihenfolge angleichen und fehlende Elemente einfügen.
            // Bewusst über Insert/RemoveAt statt über den Indexer (a_list[i] = ...),
            // da BindingList<T> beim Indexer nur ItemChanged meldet und WPF die
            // ListView dann nicht neu anordnet. Insert/RemoveAt melden ItemAdded/ItemDeleted.
            for (int i = 0; i < b_list.Count; i++)
            {
                var item = b_list[i];

                if (i < a_list.Count && a_list[i].Equals(item))
                    continue;

                var currentIndex = a_list.IndexOf(item);
                if (currentIndex >= 0)
                    a_list.RemoveAt(currentIndex);

                a_list.Insert(i, item);
            }

            // Eventuelle überzählige Elemente am Ende entfernen.
            while (a_list.Count > b_list.Count)
                a_list.RemoveAt(a_list.Count - 1);
		}

		public static void RemoveRange<T>(this IList<T> pList, IEnumerable<T> pToRemove)
        {
            foreach (T iItem in pToRemove.ToList())
            {
                pList.Remove(iItem);
            }
        }

        public static void RemoveRange<T>(this IList<T> pList, Predicate<T> pMatch)
        {
            List<T> lToDelete = pList.Where(t => pMatch(t)).ToList();
            pList.RemoveRange(lToDelete);
        }

        public static List<T> GetElementsInCommon<T>(List<List<T>> listCollection)
        {
            var result = new List<T>();
            var allElements = new List<T>();

            listCollection.DoForEach(list =>
            {
                allElements.AddRangeIfElementsNotIn(list);
            });

            allElements.DoForEach(element =>
            {
                if(listCollection.TrueForAll(list => list.Contains(element)))
                {
                    result.AddIfNotIn(element);
                }
            });
            
            return result;
        }

        public static List<T> Clone<T>(this IList<T> list)
        {
            return list?.ToList() ?? new List<T>();
        }

        public static void AddRangeIfElementsNotIn<T>(this IList<T> list, IList<T> toAdd)
        {
            foreach(var item in toAdd)
            {
                list.AddIfNotIn(item);
            }
        }

        public static void AddRange<T>(this IList<T> list, IList<T> toAdd)
        {
            foreach(T item in toAdd)
            {
                list.Add(item);
            }
        }

        public static bool AreListEqual<T>(this IList<T> list1, IList<T> list2)
        {
            if(list2 is null)
            {
                return false;
            }

            return list1.Count == list2.Count && list1.All(list2.Contains) && list2.All(list1.Contains);
        }

        public static void AddIfNotNull<T>(this IList<T> list, T item)
        {
            if(item != null)
            {
                list.Add(item);
            }
        }

        public static void AddIfNotNullAndNotIn<T>(this IList<T> list, T item)
        {
            if(item != null)
            {
                list.AddIfNotIn(item);
            }
        }

        public static void AddRangeIfNotNull<T>(this IList<T> list, IList<T> items)
        {
            if(items == null)
            {
                return;
            }

            foreach(var item in items)
            {
                list.AddIfNotNull(item);
            }
        }
    }
}