C# IContent.Retrieve方法代码示例

        protected override void ExecuteSync(IContent content, Index index, object parameter)
        {
            var value = content.Retrieve(index);
            var collectionDescriptor = (CollectionDescriptor)TypeDescriptorFactory.Default.Find(value.GetType());

            object itemToAdd = null;
            var elementType = collectionDescriptor.ElementType;
            if (CanAddNull(elementType) || IsReferenceType(elementType))
            {
                // If the parameter is a type instead of an instance, try to construct an instance of this type
                var type = parameter as Type;
                if (type?.GetConstructor(Type.EmptyTypes) != null)
                    itemToAdd = ObjectFactoryRegistry.NewInstance(type);
            }
            else if (collectionDescriptor.ElementType == typeof(string))
            {
                itemToAdd = parameter ?? "";
            }
            else
            {
                itemToAdd = parameter ?? ObjectFactoryRegistry.NewInstance(collectionDescriptor.ElementType);
            }
            if (index.IsEmpty)
            {
                content.Add(itemToAdd);
            }
            else
            {
                // Handle collections in collections
                // TODO: this is not working on the observable node side
                var collectionNode = content.Reference.AsEnumerable[index].TargetNode;
                collectionNode.Content.Add(itemToAdd);
            }
        }

 protected override void ExecuteSync(IContent content, Index index, object parameter)
 {
     var value = content.Retrieve(index);
     var collectionDescriptor = (CollectionDescriptor)TypeDescriptorFactory.Default.Find(value.GetType());
     object itemToAdd = null;
     // TODO: Find a better solution for ContentSerializerAttribute that doesn't require to reference Core.Serialization (and unreference this assembly)
     if (collectionDescriptor.ElementType.IsAbstract || collectionDescriptor.ElementType.IsNullable() || collectionDescriptor.ElementType.GetCustomAttributes(typeof(ContentSerializerAttribute), true).Any())
     {
         // If the parameter is a type instead of an instance, try to construct an instance of this type
         var type = parameter as Type;
         if (type?.GetConstructor(Type.EmptyTypes) != null)
             itemToAdd = Activator.CreateInstance(type);
     }
     else if (collectionDescriptor.ElementType == typeof(string))
     {
         itemToAdd = parameter ?? "";
     }
     else
     {
         itemToAdd = parameter ?? ObjectFactory.NewInstance(collectionDescriptor.ElementType);
     }
     if (index.IsEmpty)
     {
         content.Add(itemToAdd);
     }
     else
     {
         // Handle collections in collections
         // TODO: this is not working on the observable node side
         var collectionNode = content.Reference.AsEnumerable[index].TargetNode;
         collectionNode.Content.Add(itemToAdd);
     }
 }

        protected override IActionItem ExecuteSync(IContent content, object index, object parameter, IEnumerable<IDirtiable> dirtiables)
        {
            var value = content.Retrieve();
            var collectionDescriptor = (CollectionDescriptor)TypeDescriptorFactory.Default.Find(value.GetType());
            object itemToAdd = null;
            // TODO: Find a better solution for ContentSerializerAttribute that doesn't require to reference Core.Serialization (and unreference this assembly)
            if (collectionDescriptor.ElementType.IsAbstract || collectionDescriptor.ElementType.IsNullable() || collectionDescriptor.ElementType.GetCustomAttributes(typeof(ContentSerializerAttribute), true).Any())
            {
                // If the parameter is a type instead of an instance, try to construct an instance of this type
                var type = parameter as Type;
                if (type?.GetConstructor(Type.EmptyTypes) != null)
                    itemToAdd = Activator.CreateInstance(type);
            }
            else if (collectionDescriptor.ElementType == typeof(string))
            {
                itemToAdd = parameter ?? "";
            }
            else
            {
                itemToAdd = parameter ?? ObjectFactory.NewInstance(collectionDescriptor.ElementType);
            }
            content.Add(itemToAdd);

            return null;
        }

 protected override void ExecuteSync(IContent content, Index index, object parameter)
 {
     var oldName = index;
     var newName = new Index(parameter);
     var renamedObject = content.Retrieve(oldName);
     content.Remove(renamedObject, oldName);
     content.Add(renamedObject, newName);
 }

 protected override void ExecuteSync(IContent content, Index index, object parameter)
 {
     var oldName = index;
     var renamedObject = content.Retrieve(oldName);
     content.Remove(renamedObject, oldName);
     var newName = AddPrimitiveKeyCommand.GenerateStringKey(content.Value, content.Descriptor, (string)parameter);
     content.Add(renamedObject, newName);
 }

 protected override IActionItem ExecuteSync(IContent content, object index, object parameter, IEnumerable<IDirtiable> dirtiables)
 {
     var oldName = (string)index;
     var newName = (string)parameter;
     var removedObject = content.Retrieve(oldName);
     content.Remove(oldName);
     content.Add(newName, removedObject);
     return null;
 }

 protected override void ExecuteSync(IContent content, Index index, object parameter)
 {
     var indices = (Tuple<int, int>)parameter;
     var sourceIndex = new Index(indices.Item1);
     var targetIndex = new Index(indices.Item2);
     var value = content.Retrieve(sourceIndex);
     content.Remove(value, sourceIndex);
     content.Add(value, targetIndex);
 }

 public override Task<IActionItem> Execute(IContent content, object index, object parameter, IEnumerable<IDirtiable> dirtiables)
 {
     var currentValue = content.Retrieve(index);
     var newValue = ChangeValue(currentValue, parameter);
     if (!Equals(newValue, currentValue))
     {
         content.Update(newValue, index);
     }
     return Task.FromResult<IActionItem>(null);
 }

 protected override IActionItem ExecuteSync(IContent content, object index, object parameter, IEnumerable<IDirtiable> dirtiables)
 {
     var indices = (Tuple<int, int>)parameter;
     var sourceIndex = indices.Item1;
     var targetIndex = indices.Item2;
     var value = content.Retrieve(sourceIndex);
     content.Remove(sourceIndex);
     content.Add(targetIndex, value);
     return null;
 }

 public override Task Execute(IContent content, Index index, object parameter)
 {
     var currentValue = content.Retrieve(index);
     var newValue = ChangeValue(currentValue, parameter);
     if (!Equals(newValue, currentValue))
     {
         content.Update(newValue, index);
     }
     return Task.FromResult(0);
 }

 protected override void ExecuteSync(IContent content, Index index, object parameter)
 {
     var value = content.Retrieve(index);
     var dictionaryDescriptor = (DictionaryDescriptor)TypeDescriptorFactory.Default.Find(value.GetType());
     var newKey = dictionaryDescriptor.KeyType != typeof(string) ? new Index(Activator.CreateInstance(dictionaryDescriptor.KeyType)) : GenerateStringKey(value, dictionaryDescriptor, parameter as string);
     object newItem = null;
     // TODO: Find a better solution that doesn't require to reference Core.Serialization (and unreference this assembly)
     if (!dictionaryDescriptor.ValueType.GetCustomAttributes(typeof(ContentSerializerAttribute), true).Any())
         newItem = CreateInstance(dictionaryDescriptor.ValueType);
     content.Add(newItem, newKey);
 }

 protected override IActionItem ExecuteSync(IContent content, object index, object parameter, IEnumerable<IDirtiable> dirtiables)
 {
     var value = content.Retrieve(index);
     var dictionaryDescriptor = (DictionaryDescriptor)TypeDescriptorFactory.Default.Find(value.GetType());
     var newKey = dictionaryDescriptor.KeyType != typeof(string) ? Activator.CreateInstance(dictionaryDescriptor.KeyType) : GenerateStringKey(value, dictionaryDescriptor, parameter as string);
     object newItem = null;
     // TODO: Find a better solution that doesn't require to reference Core.Serialization (and unreference this assembly)
     if (!dictionaryDescriptor.ValueType.GetCustomAttributes(typeof(ContentSerializerAttribute), true).Any())
         newItem = !dictionaryDescriptor.ValueType.IsAbstract ? Activator.CreateInstance(dictionaryDescriptor.ValueType) : null;
     content.Add(newKey, newItem);
     return null;
 }

 public override Task<IActionItem> Execute(IContent content, object index, object parameter, IEnumerable<IDirtiable> dirtiables)
 {
     var currentValue = content.Retrieve(index);
     var newValue = ChangeValue(currentValue, parameter);
     IActionItem actionItem = null;
     if (!Equals(newValue, currentValue))
     {
         content.Update(newValue, index);
         actionItem = new ContentValueChangedActionItem("Change property via command '{Name}'", content, index, currentValue, dirtiables);
     }
     return Task.FromResult(actionItem);
 }

 public override Task Execute(IContent content, Index index, object parameter)
 {
     var hasIndex = content.Indices == null || content.Indices.Contains(index);
     var currentValue = hasIndex ? content.Retrieve(index) : (content.Type.IsValueType ? Activator.CreateInstance(content.Type) : null);
     var newValue = ChangeValue(currentValue, parameter);
     if (hasIndex)
     {
         if (!Equals(newValue, currentValue))
         {
             content.Update(newValue, index);
         }
     }
     else
     {
         content.Add(newValue, index);
     }
     return Task.FromResult(0);
 }

 private static void AssertCollection(IContent content, params string[] items)
 {
     for (var i = 0; i < items.Length; i++)
     {
         var item = items[i];
         Assert.AreEqual(item, content.Retrieve(new Index(i)));
     }
 }