internal Segment<byte>? GetCell(PropertyKey key)
        {
            var colDef = _columnDefs.FirstOrDefault(d => d.Tag.Key == key);
            if (colDef == null)
                return null;

            if (!ColumnExists(colDef.CebIndex))
                return null;

            var type = colDef.Tag.Type;
            Segment<byte> data;
            var offset = colDef.Offset + (_rowIndex * _offsets.Bm);
            if (!type.IsVariableLength() && type.GetLength() <= 8)
            {
                var length = colDef.Tag.Type.GetLength();
                data = _rowData.Derive(offset, length);
            }
            else
            {
                var hnid = BitConverter.ToUInt32(_rowData.Array, _rowData.Offset + offset);
                if ((hnid & 0x1f) == 0)
                {
                    data = _heap[hnid];
                }
                else
                {
                    var subnode = _node.FindSubnode(hnid);
                    var subBlock = subnode.GetDataBlock();
                    data = subBlock.Data;
                }
            }

            return data;
        }

        public virtual int UpdateProperty(uint commandId, ref PropertyKey key, PropVariantRef currentValue, out PropVariant newValue)
        {
            Command command = ParentCommandManager.Get((CommandId)commandId);
            if (command == null)
            {
                return NullCommandUpdateProperty(commandId, ref key, currentValue, out newValue);
            }

            try
            {
                newValue = new PropVariant();
                command.GetPropVariant(key, currentValue, ref newValue);

                if (newValue.IsNull())
                {
                    Trace.Fail("Didn't property update property for " + PropertyKeys.GetName(key) + " on command " + ((CommandId)commandId).ToString());

                    newValue = PropVariant.FromObject(currentValue.PropVariant.Value);
                }
            }
            catch (Exception ex)
            {
                Trace.Fail("Exception in UpdateProperty for " + PropertyKeys.GetName(key) + " on command " + commandId + ": " + ex);
                newValue = PropVariant.FromObject(currentValue.PropVariant.Value);
            }

            return HRESULT.S_OK;
        }

        public void ConstructorWithString(string formatId, int propertyId)
        {
            PropertyKey pk = new PropertyKey(formatId, propertyId);

            Assert.Equal<Guid>(new Guid(formatId), pk.FormatId);
            Assert.Equal<int>(propertyId, pk.PropertyId);
        }

        public EntityHierarchyEnumerator(EntitySystem EntitySystem, ViewModelContext selectedEntitiesContext)
        {
            isSelectedProperty = new PropertyKey<bool>("IsSelected", typeof(EntityHierarchyEnumerator), new StaticDefaultValueMetadata(false) { PropertyUpdateCallback = IsSelectedChanged });

            this.EntitySystem = EntitySystem;
            this.selectedEntitiesContext = selectedEntitiesContext;
        }

        protected object GetOverride(ref PropertyKey key, object defaultValue)
        {
            PropVariant propVariant;
            if (_overrides.TryGetValue(key, out propVariant))
                return propVariant.Value;

            return defaultValue;
        }

        public void ConstructorWithGuid(string formatIdString, int propertyId)
        {
            Guid formatId = new Guid(formatIdString);
            PropertyKey pk = new PropertyKey(formatId, propertyId);

            Assert.Equal<Guid>(formatId, pk.FormatId);
            Assert.Equal<int>(propertyId, pk.PropertyId);
        }

 public ShellPropertyDescription GetPropertyDescription(PropertyKey key)
 {
     if (!propsDictionary.ContainsKey(key))
     {
         propsDictionary.Add(key, new ShellPropertyDescription(key));
     }
     return propsDictionary[key];
 }

 public static bool IsStringPropertyKey(PropertyKey key)
 {
     return (key == PropertyKeys.Label ||
             key == PropertyKeys.LabelDescription ||
             key == PropertyKeys.Keytip ||
             key == PropertyKeys.TooltipTitle ||
             key == PropertyKeys.TooltipDescription);
 }

 public override void GetPropVariant(PropertyKey key, PropVariantRef currentValue, ref PropVariant value)
 {
     if (key == PropertyKeys.ContextAvailable)
     {
         value.SetUInt((uint)ContextAvailability);
     }
     else
         base.GetPropVariant(key, currentValue, ref value);
 }

 public Property FindProperty(PropertyKey key)
 {
   Type type = FindType(key);
   Property member = type.FindProperty(key);
   if (member == null)
   {
     member = type.AddProperty(key);
   }
   return member;
 }

 private void UpdateInvalidationStateAndNotifyIfDifferent(ref PropertyKey key, IComparable overrideValue, IComparableDelegate currentValueDelegate)// where T : IComparable
 {
     // Only invalidate if we're actually making a change.
     // Unnecessary invalidations hurt perf as well as cause ribbon bugs.
     if (overrideValue.CompareTo(currentValueDelegate()) != 0)
     {
         UpdateInvalidationState(key, InvalidationState.Pending);
         OnStateChanged(EventArgs.Empty);
     }
 }

        public void ToStringReturnsExpectedString()
        {
            Guid guid = new Guid("00000000-1111-2222-3333-000000000000");
            int property = 1234;

            PropertyKey key = new PropertyKey(guid, property);

            Assert.Equal<string>(
                "{" + guid.ToString() + "}, " + property.ToString(),
                key.ToString());
        }

        protected int RemoveOverride(ref PropertyKey key, IComparableDelegate currentValueDelegate)
        {
            PropVariant overrideValue;
            if (_overrides.TryGetValue(key, out overrideValue))
            {
                _overrides.Remove(key);
                UpdateInvalidationStateAndNotifyIfDifferent(ref key, (IComparable)overrideValue.Value, currentValueDelegate);
                return HRESULT.S_OK;
            }

            return HRESULT.S_FALSE;
        }

        public void HasAssessor_DeclaringType_And_PropertyName()
        {
            var declaringType = typeof(SimpleClass);
            var propertyName = "Id";
            var propertyKey = new PropertyKey(declaringType, propertyName);
            var assessor = CreatePropertyAssessor(propertyKey);
            _cache.TryAdd(propertyKey, assessor);

            var result = PropertyAssessorCache.HasAssessor(typeof(SimpleClass), "Id");

            Assert.IsTrue(result);
        }

        public void HasAssessor_PropertyInfo()
        {
            var propertyInfo = typeof(SimpleClass).GetProperty("Id");
            var propertyKey = new PropertyKey(propertyInfo);
            var assessor = CreatePropertyAssessor(propertyKey);
            _cache.TryAdd(propertyKey, assessor);

            propertyInfo = typeof(SimpleClass).GetProperty("Id");
            var result = PropertyAssessorCache.HasAssessor(propertyInfo);

            Assert.IsTrue(result);
        }

        public virtual int CancelOverride(ref PropertyKey key)
        {
            if (key == PropertyKeys.Enabled)
            {
                return RemoveOverride(ref key, () => Enabled);
            }
            if (key == PropertyKeys.ContextAvailable)
            {
                return RemoveOverride(ref key, () => (uint)ContextAvailability);
            }

            return HRESULT.E_INVALIDARG;
        }

        public void Dispatch(PropertyKey key, ExecuteEventHandlerArgs args)
        {
            ExecuteWithArgsDelegate executeWithArgsDelegate = commands[key] as ExecuteWithArgsDelegate;

            if (executeWithArgsDelegate != null)
            {
                executeWithArgsDelegate(args);
                return;
            }

            CommandId commandId = (CommandId)commands[key];
            Command command = CommandManager.Get(commandId);
            command.PerformExecuteWithArgs(args);
        }

        internal Segment<byte> Get(PropertyKey key)
        {
            var prop = _bTree.Find((ushort)key);
            if (prop == null)
                return null;

            if (prop.Type.IsVariableLength())
            {
                if ((prop.Hnid & 0x1f) == 0)
                    return _heap[prop.Hnid];
                return _node.FindSubnode(prop.Hnid).GetDataBlock().Data;
            }

            if (prop.Type.GetLength() <= 4)
                return BitConverter.GetBytes(prop.Hnid);

            return _heap[prop.Hnid];
        }

        public void GetOrAdd_PropertyInfo_WhenIsAlreadyInCache()
        {
            var propertyInfo = typeof(SimpleClass).GetProperty("Id");
            var created = false;
            var propertyKey = new PropertyKey(propertyInfo);

            _cache.TryAdd(propertyKey, CreatePropertyAssessor(propertyKey));

            propertyInfo = typeof(SimpleClass).GetProperty("Id");
            var assessor = PropertyAssessorCache.GetOrAdd(propertyInfo, propertyKeyForCreation =>
            {
                created = true;
                return CreatePropertyAssessor(propertyKeyForCreation);
            });

            propertyInfo = typeof(SimpleClass).GetProperty("Id");
            Assert.IsTrue(_cache.ContainsKey(new PropertyKey(propertyInfo)));
            Assert.IsFalse(created);
        }

        public virtual int OverrideProperty(ref PropertyKey key, PropVariantRef overrideValue)
        {
            if (key == PropertyKeys.Enabled)
            {
                bool currentValue = Enabled;
                _overrides[key] = overrideValue.PropVariant;
                UpdateInvalidationStateAndNotifyIfDifferent(ref key, Convert.ToBoolean(overrideValue.PropVariant.Value, CultureInfo.InvariantCulture), () => currentValue);
                return HRESULT.S_OK;
            }
            else if (key == PropertyKeys.ContextAvailable)
            {
                uint currentValue = (uint)ContextAvailability;
                _overrides[key] = overrideValue.PropVariant;
                UpdateInvalidationStateAndNotifyIfDifferent(ref key, Convert.ToUInt32(overrideValue.PropVariant.Value, CultureInfo.InvariantCulture), () => currentValue);
                return HRESULT.S_OK;
            }

            return HRESULT.E_INVALIDARG;
        }