C# Metadata.ContainsKey方法代码示例

        public void ClonedMetadataDoesNotContainNewValues()
        {
            // Given
            Engine engine = new Engine();
            engine.Metadata["A"] = "a";
            Metadata metadata = new Metadata(engine);

            // When
            Metadata clone = metadata.Clone(new Dictionary<string, object> { { "B", "b" } });

            // Then
            Assert.IsFalse(metadata.ContainsKey("B"));
        }

        public void CloneWithCanMerge()
        {
            // Arrange
            var key1 = A<string>();
            var key2 = A<string>();
            var value1 = A<string>();
            var value2 = A<string>();

            // Act
            var metadata1 = new Metadata { [key1] = value1 };
            var metadata2 = metadata1.CloneWith(new KeyValuePair<string, string>(key2, value2));

            // Assert
            metadata1.ContainsKey(key2).Should().BeFalse();

            metadata2.ContainsKey(key1).Should().BeTrue();
            metadata2.ContainsKey(key2).Should().BeTrue();
            metadata2[key1].Should().Be(value1);
            metadata2[key2].Should().Be(value2);
        }

        private async Task<Metadata> GetActualMetadata(ICloudBlob blob)
        {
            var metadata = new Metadata(blob.Metadata);

            if (blob.Properties.LastModified.HasValue || blob.SnapshotTime.HasValue)
            {
                metadata.StoredLastModified = blob.SnapshotTime.HasValue ? blob.SnapshotTime.Value.UtcDateTime : blob.Properties.LastModified.Value.UtcDateTime;
                if(!metadata.LastModified.HasValue)
                {
                    metadata.LastModified = metadata.StoredLastModified;
                }
            }

            metadata.StoredContentLength = blob.Properties.Length;
            metadata.StoredContentType = blob.Properties.ContentType;
            metadata.ETag = blob.Properties.ETag;

            // Remove the snapshot key at this point if we have it
            if(metadata.ContainsKey(InternalSnapshotKey))
            {
                metadata.Remove(InternalSnapshotKey);
            }

            // Remove the store key as well...
            if(metadata.ContainsKey(StoreVersionKey))
            {
                metadata.Remove(StoreVersionKey);
            }

            if (_enableSnapshots)
            {
                if (blob.IsSnapshot)
                {
                    metadata.Snapshot = blob.SnapshotTime.Value.UtcTicks.ToString(CultureInfo.InvariantCulture);
                }
                else if (blob.Metadata.ContainsKey(InternalSnapshotKey))
                {
                    // Try and use our save snapshot instead of making more calls...
                    metadata.Snapshot = blob.Metadata[InternalSnapshotKey];
                }
                else
                {
                    // Try and find last snapshot
                    // Unfortunately we need to make a request since this information isn't on the actual blob that we are working with...
                    var snapBlob = await ListBlobs(blob.Container, blob.Name, BlobListingDetails.Snapshots | BlobListingDetails.Metadata)
                        .Where(b => b.IsSnapshot && b.Uri == blob.Uri && b.SnapshotTime.HasValue)
                        .Scan((a, b) => a.SnapshotTime.Value > b.SnapshotTime.Value ? a : b)
                        .LastOrDefault()
                        .ConfigureAwait(false);

                    metadata.Snapshot = snapBlob == null ? null : snapBlob.SnapshotTime.Value.UtcTicks.ToString(CultureInfo.InvariantCulture);
                }
            }

            return metadata;
        }

        public void ContainsKeyReturnsTrueForValidValue()
        {
            // Given
            Engine engine = new Engine();
            engine.Metadata["A"] = "a";
            Metadata metadata = new Metadata(engine);

            // When
            bool contains = metadata.ContainsKey("A");

            // Then
            Assert.IsTrue(contains);
        }

        public void ContainsReturnsFalseForInvalidValue()
        {
            // Given
            Engine engine = new Engine();
            engine.Trace.AddListener(new TestTraceListener());
            engine.Metadata["A"] = "a";
            Metadata metadata = new Metadata(engine);

            // When
            bool contains = metadata.ContainsKey("B");

            // Then
            Assert.IsFalse(contains);
        }