private bool TryGetAttributeMessageFromAttributeInfoMessage(AttributeInfoMessage attributeInfoMessage,
                                                                    string name,
                                                                    [NotNullWhen(returnValue: true)] out AttributeMessage?attributeMessage)
        {
            attributeMessage = null;

            var fractalHeap     = attributeInfoMessage.FractalHeap;
            var btree2NameIndex = attributeInfoMessage.BTree2NameIndex;
            var nameHash        = H5Checksum.JenkinsLookup3(name);
            var candidate       = default(AttributeMessage);

            var success = btree2NameIndex.TryFindRecord(out var record, record =>
            {
#warning Better to implement comparison code in record (here: BTree2Record08) itself?

                if (nameHash < record.NameHash)
                {
                    return(-1);
                }
                else if (nameHash > record.NameHash)
                {
                    return(1);
                }
                else
                {
#warning duplicate2
                    using var localReader = new H5BinaryReader(new MemoryStream(record.HeapId));
                    var heapId            = FractalHeapId.Construct(this.Context, localReader, fractalHeap);
                    candidate             = heapId.Read(reader => new AttributeMessage(reader, this.Context.Superblock));

                    // https://stackoverflow.com/questions/35257814/consistent-string-sorting-between-c-sharp-and-c
                    // https://stackoverflow.com/questions/492799/difference-between-invariantculture-and-ordinal-string-comparison
                    return(string.CompareOrdinal(name, candidate.Name));
                }
            });

            if (success)
            {
                if (candidate == null)
                {
                    throw new Exception("This should never happen. Just to satisfy the compiler.");
                }

                attributeMessage = candidate;
                return(true);
            }

            return(false);
        }
        private IEnumerable <AttributeMessage> EnumerateAttributeMessagesFromAttributeInfoMessage(AttributeInfoMessage attributeInfoMessage)
        {
            var btree2NameIndex = attributeInfoMessage.BTree2NameIndex;
            var records         = btree2NameIndex
                                  .EnumerateRecords()
                                  .ToList();

            var fractalHeap = attributeInfoMessage.FractalHeap;

            // local cache: indirectly accessed, non-filtered
            List <BTree2Record01>?record01Cache = null;

            foreach (var record in records)
            {
#warning duplicate1
                using var localReader = new H5BinaryReader(new MemoryStream(record.HeapId));
                var heapId  = FractalHeapId.Construct(this.Context, localReader, fractalHeap);
                var message = heapId.Read(reader => new AttributeMessage(reader, this.Context.Superblock), ref record01Cache);

                yield return(message);
            }
        }