Akka.Cluster.Reachability.ObserverRows C# (CSharp) Method

        ImmutableDictionary<UniqueAddress, Record> ObserverRows(UniqueAddress observer)
        {
            ImmutableDictionary<UniqueAddress, Record> observerRows = null;
            _cache.Value.ObserverRowMap.TryGetValue(observer, out observerRows);

            return observerRows;
        }

        /// <summary>
        ///     TBD
        /// </summary>
        /// <param name="allowed">TBD</param>
        /// <param name="other">TBD</param>
        /// <returns>TBD</returns>
        public Reachability Merge(IImmutableSet <UniqueAddress> allowed, Reachability other)
        {
            var recordBuilder = ImmutableList.CreateBuilder <Record>();
            //TODO: Size hint somehow?
            var newVersions = Versions;

            foreach (var observer in allowed)
            {
                var observerVersion1 = CurrentVersion(observer);
                var observerVersion2 = other.CurrentVersion(observer);

                var rows1 = ObserverRows(observer);
                var rows2 = other.ObserverRows(observer);

                if (rows1 != null && rows2 != null)
                {
                    var rows = observerVersion1 > observerVersion2 ? rows1 : rows2;
                    foreach (var record in rows.Values.Where(r => allowed.Contains(r.Subject)))
                    {
                        recordBuilder.Add(record);
                    }
                }

                if (rows1 != null && rows2 == null)
                {
                    if (observerVersion1 > observerVersion2)
                    {
                        foreach (var record in rows1.Values.Where(r => allowed.Contains(r.Subject)))
                        {
                            recordBuilder.Add(record);
                        }
                    }
                }
                if (rows1 == null && rows2 != null)
                {
                    if (observerVersion2 > observerVersion1)
                    {
                        foreach (var record in rows2.Values.Where(r => allowed.Contains(r.Subject)))
                        {
                            recordBuilder.Add(record);
                        }
                    }
                }

                if (observerVersion2 > observerVersion1)
                {
                    newVersions = newVersions.SetItem(observer, observerVersion2);
                }
            }

            newVersions = ImmutableDictionary.CreateRange(newVersions.Where(p => allowed.Contains(p.Key)));

            return(new Reachability(recordBuilder.ToImmutable(), newVersions));
        }