ICollection

4 interfaces inheriting from ICollection

Microsoft.Build (1)

Collections\RetrievableEntryHashSet\IRetrievableEntryHashSet.cs (1)

12ICollection<T>,

System.Private.CoreLib (3)

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\IDictionary.cs (1)

12public interface IDictionary<TKey, TValue> : ICollection<KeyValuePair<TKey, TValue>>

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\IList.cs (1)

13public interface IList<T> : ICollection<T>

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ISet.cs (1)

11public interface ISet<T> : ICollection<T>

73 implementations of ICollection

Microsoft.AspNetCore.Components.Endpoints.Tests (1)

Binding\FormDataMapperTests.cs (1)

2416internal class CustomCollection<T> : ICollection<T>

Microsoft.AspNetCore.Mvc.Abstractions.Test (1)

ModelBinding\ModelMetadataTest.cs (1)

736private class CollectionImplementation : ICollection<string>

Microsoft.AspNetCore.Mvc.IntegrationTests (4)

ActionParametersIntegrationTest.cs (1)

1000private class CustomReadOnlyCollection<T> : ICollection<T>

CollectionModelBinderIntegrationTest.cs (2)

1232private class ExplicitClosedGenericCollection : ICollection<string> 1372private class ExplicitCollection<T> : ICollection<T>

TryUpdateModelIntegrationTest.cs (1)

1291private class CustomReadOnlyCollection<T> : ICollection<T>

Microsoft.AspNetCore.Mvc.ViewFeatures (2)

AttributeDictionary.cs (2)

366private sealed class KeyCollection : ICollection<string> 473private sealed class ValueCollection : ICollection<string?>

Microsoft.AspNetCore.Routing (1)

RouteEndpointDataSource.cs (1)

347private sealed class ThrowOnAddAfterEndpointBuiltConventionCollection : List<Action<EndpointBuilder>>, ICollection<Action<EndpointBuilder>>

Microsoft.AspNetCore.Server.HttpSys (1)

UrlPrefixCollection.cs (1)

15public class UrlPrefixCollection : ICollection<UrlPrefix>

Microsoft.AspNetCore.Server.Kestrel.Core (2)

Internal\ServerAddressesCollection.cs (2)

13internal sealed class ServerAddressesCollection : ICollection<string> 102private sealed class PublicServerAddressesCollection : ICollection<string>

Microsoft.Build (5)

Construction\ProjectElementContainer.cs (1)

769internal sealed class ProjectElementSiblingSubTypeCollection<T> : ICollection<T>, ICollection

Instance\ImmutableProjectCollections\ImmutableElementCollectionConverter.cs (1)

109private sealed class ValuesCollection : ICollection<T>

Instance\ImmutableProjectCollections\ImmutableItemDictionary.cs (1)

151private sealed class ListConverter : ICollection<T>

ReadOnlyCollection.cs (1)

23internal sealed class ReadOnlyCollection<T> : ICollection<T>, ICollection

ReadOnlyEmptyCollection.cs (1)

20internal class ReadOnlyEmptyCollection<T> : ICollection<T>, ICollection

Microsoft.Build.Engine (1)

Engine\ToolsetCollection.cs (1)

22public class ToolsetCollection : ICollection<Toolset>

Microsoft.Build.Framework (6)

ImmutableSegmentedDictionary`2+Builder+KeyCollection.cs (1)

16public readonly struct KeyCollection : ICollection<TKey>, IReadOnlyCollection<TKey>, ICollection

ImmutableSegmentedDictionary`2+Builder+ValueCollection.cs (1)

16public readonly struct ValueCollection : ICollection<TValue>, IReadOnlyCollection<TValue>, ICollection

ImmutableSegmentedDictionary`2+KeyCollection.cs (1)

13public readonly partial struct KeyCollection : IReadOnlyCollection<TKey>, ICollection<TKey>, ICollection

ImmutableSegmentedDictionary`2+ValueCollection.cs (1)

13public readonly partial struct ValueCollection : IReadOnlyCollection<TValue>, ICollection<TValue>, ICollection

SegmentedDictionary`2.cs (2)

1258public sealed class KeyCollection : ICollection<TKey>, ICollection, IReadOnlyCollection<TKey> 1458public sealed class ValueCollection : ICollection<TValue>, ICollection, IReadOnlyCollection<TValue>

Microsoft.Build.Tasks.Core (2)

ReadOnlyCollection.cs (1)

23internal sealed class ReadOnlyCollection<T> : ICollection<T>, ICollection

ReadOnlyEmptyCollection.cs (1)

20internal class ReadOnlyEmptyCollection<T> : ICollection<T>, ICollection

Microsoft.Build.Utilities.Core (1)

ReadOnlyEmptyCollection.cs (1)

20internal class ReadOnlyEmptyCollection<T> : ICollection<T>, ICollection

MSBuild (1)

ReadOnlyEmptyCollection.cs (1)

20internal class ReadOnlyEmptyCollection<T> : ICollection<T>, ICollection

MSBuildTaskHost (1)

ReadOnlyEmptyCollection.cs (1)

20internal class ReadOnlyEmptyCollection<T> : ICollection<T>, ICollection

PresentationCore (6)

MS\Internal\FontFace\TypefaceCollection.cs (1)

26internal unsafe struct TypefaceCollection : ICollection<Typeface>

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\SequentialUshortCollection.cs (1)

30internal class SequentialUshortCollection : ICollection<ushort>

System\Windows\Ink\StrokeCollection.cs (1)

860internal class ReadOnlyStrokeCollection : StrokeCollection, ICollection<Stroke>, IList

System\Windows\Media\Animation\TimelineClockCollection.cs (1)

20public class ClockCollection : ICollection<Clock>

System\Windows\Media\Fonts.cs (1)

292private struct TypefaceCollection : ICollection<Typeface>

System\Windows\Media\GlyphTypeface.cs (1)

1876private class ValueCollection : ICollection<double>

PresentationFramework (5)

MS\Internal\WeakDictionary.cs (2)

19private class KeyCollection<KeyType, ValueType> : ICollection<KeyType> where KeyType : class 106private class ValueCollection<KeyType, ValueType> : ICollection<ValueType> where KeyType : class

MS\Internal\WeakHashSet.cs (1)

18internal class WeakHashSet<T> : ICollection<T> where T : class

System\Windows\Data\XmlNamespaceMappingCollection.cs (1)

26public class XmlNamespaceMappingCollection : XmlNamespaceManager, ICollection<XmlNamespaceMapping>, IAddChildInternal

System\Windows\Documents\TextElementCollection.cs (1)

19public class TextElementCollection<TextElementType> : IList, ICollection<TextElementType> where TextElementType : TextElement

System.Collections (4)

System\Collections\Generic\LinkedList.cs (1)

15public class LinkedList<T> : ICollection<T>, ICollection, IReadOnlyCollection<T>, ISerializable, IDeserializationCallback

System\Collections\Generic\SortedDictionary.cs (2)

523public sealed class KeyCollection : ICollection<TKey>, ICollection, IReadOnlyCollection<TKey> 684public sealed class ValueCollection : ICollection<TValue>, ICollection, IReadOnlyCollection<TValue>

System\Collections\Generic\SortedSet.cs (1)

49public partial class SortedSet<T> : ISet<T>, ICollection<T>, ICollection, IReadOnlyCollection<T>, IReadOnlySet<T>, ISerializable, IDeserializationCallback

System.Collections.Immutable (4)

System\Collections\Immutable\ImmutableHashSet_1.cs (1)

19public sealed partial class ImmutableHashSet<T> : IImmutableSet<T>, IHashKeyCollection<T>, IReadOnlyCollection<T>, ICollection<T>, ISet<T>, IReadOnlySet<T>, ICollection, IStrongEnumerable<T, ImmutableHashSet<T>.Enumerator>

System\Collections\Immutable\ImmutableHashSet_1.HashBucketByRefEqualityComparer.cs (1)

11public sealed partial class ImmutableHashSet<T> : IImmutableSet<T>, IHashKeyCollection<T>, IReadOnlyCollection<T>, ICollection<T>, ISet<T>, ICollection, IStrongEnumerable<T, ImmutableHashSet<T>.Enumerator>

System\Collections\Immutable\ImmutableHashSet_1.HashBucketByValueEqualityComparer.cs (1)

System\Collections\Immutable\KeysOrValuesCollectionAccessor.cs (1)

15internal abstract class KeysOrValuesCollectionAccessor<TKey, TValue, T> : ICollection<T>, ICollection where TKey : notnull

System.ComponentModel.Composition (3)

Microsoft\Internal\Collections\CollectionServices.CollectionOfObject.cs (2)

37private sealed class CollectionOfObjectList : ICollection<object> 92private sealed class CollectionOfObject<T> : ICollection<object>

System\ComponentModel\Composition\Hosting\ComposablePartCatalogCollection.cs (1)

20internal sealed class ComposablePartCatalogCollection : ICollection<ComposablePartCatalog>, INotifyComposablePartCatalogChanged, IDisposable

System.DirectoryServices.AccountManagement (2)

artifacts\obj\System.DirectoryServices.AccountManagement\Debug\net9.0\System.DirectoryServices.AccountManagement.notsupported.cs (2)

System.Linq (2)

System\Linq\Lookup.cs (2)

262internal sealed class CollectionLookup<TKey, TElement> : Lookup<TKey, TElement>, ICollection<IGrouping<TKey, TElement>>, IReadOnlyCollection<IGrouping<TKey, TElement>> 302internal sealed class EmptyLookup<TKey, TElement> : ILookup<TKey, TElement>, ICollection<IGrouping<TKey, TElement>>, IReadOnlyCollection<IGrouping<TKey, TElement>>

System.Linq.Expressions (2)

System\Dynamic\ExpandoObject.cs (2)

349private sealed class KeyCollection : ICollection<string> 488private sealed class ValueCollection : ICollection<object?>

System.Net.Http (2)

System\Net\Http\Headers\HttpHeaderValueCollection.cs (1)

33public sealed class HttpHeaderValueCollection<T> : ICollection<T> where T : class

System\Net\Http\Headers\ObjectCollection.cs (1)

21internal abstract class ObjectCollection<T> : ICollection<T> where T : class

System.Net.HttpListener (1)

System\Net\HttpListenerPrefixCollection.cs (1)

29public class HttpListenerPrefixCollection : ICollection<string>

System.Net.NetworkInformation (4)

System\Net\NetworkInformation\GatewayIPAddressInformationCollection.cs (1)

8public class GatewayIPAddressInformationCollection : ICollection<GatewayIPAddressInformation>

System\Net\NetworkInformation\IPAddressInformationCollection.cs (1)

8public class IPAddressInformationCollection : ICollection<IPAddressInformation>

System\Net\NetworkInformation\MulticastIPAddressInformationCollection.cs (1)

8public class MulticastIPAddressInformationCollection : ICollection<MulticastIPAddressInformation>

System\Net\NetworkInformation\UnicastIPAddressInformationCollection.cs (1)

8public class UnicastIPAddressInformationCollection : ICollection<UnicastIPAddressInformation>

System.Net.Primitives (2)

System\Net\CookieCollection.cs (1)

15public class CookieCollection : ICollection<Cookie>, IReadOnlyCollection<Cookie>, ICollection

System\Net\NetworkInformation\IPAddressCollection.cs (1)

8public class IPAddressCollection : ICollection<IPAddress>

System.Private.CoreLib (5)

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\Dictionary.cs (2)

1461public sealed class KeyCollection : ICollection<TKey>, ICollection, IReadOnlyCollection<TKey> 1656public sealed class ValueCollection : ICollection<TValue>, ICollection, IReadOnlyCollection<TValue>

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\HashSet.cs (1)

16public class HashSet<T> : ICollection<T>, ISet<T>, IReadOnlyCollection<T>, IReadOnlySet<T>, ISerializable, IDeserializationCallback

src\libraries\System.Private.CoreLib\src\System\Collections\ObjectModel\ReadOnlyDictionary.cs (2)

252public sealed class KeyCollection : ICollection<TKey>, ICollection, IReadOnlyCollection<TKey> 308public sealed class ValueCollection : ICollection<TValue>, ICollection, IReadOnlyCollection<TValue>

System.Security.Principal.Windows (1)

artifacts\obj\System.Security.Principal.Windows\Debug\net9.0\System.Security.Principal.Windows.notsupported.cs (1)

42public partial class IdentityReferenceCollection : System.Collections.Generic.ICollection<System.Security.Principal.IdentityReference>, System.Collections.Generic.IEnumerable<System.Security.Principal.IdentityReference>, System.Collections.IEnumerable

System.Speech (1)

artifacts\obj\System.Speech\Debug\net9.0\System.Speech.notsupported.cs (1)

296public sealed partial class SemanticValue : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<string, System.Speech.Recognition.SemanticValue>>, System.Collections.Generic.IDictionary<string, System.Speech.Recognition.SemanticValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, System.Speech.Recognition.SemanticValue>>, System.Collections.IEnumerable

2144 references to ICollection

dotnet-dev-certs (2)

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (2)

380var certsFromDisk = GetCertsFromDisk(); 426private static ICollection<X509Certificate2> GetCertsFromDisk()

dotnet-openapi (3)

Commands\BaseCommand.cs (1)

155var items = project.GetItems(tagName);

Commands\RefreshCommand.cs (1)

42var openApiReferenceItems = project.GetItems(OpenApiReference);

Commands\RemoveCommand.cs (1)

54var openApiReferenceItems = project.GetItems(tagName);

HtmlGenerationWebSite (1)

Models\Order.cs (1)

20public ICollection<string> PaymentMethod

Identity.DefaultUI.WebSite (5)

src\Identity\test\Shared\PocoModel\PocoRole.cs (1)

57public virtual ICollection<PocoRoleClaim<TKey>> Claims { get; private set; } = new List<PocoRoleClaim<TKey>>();

src\Identity\test\Shared\PocoModel\PocoUser.cs (4)

134public virtual ICollection<PocoUserRole<TKey>> Roles { get; private set; } = new List<PocoUserRole<TKey>>(); 138public virtual ICollection<PocoUserClaim<TKey>> Claims { get; private set; } = new List<PocoUserClaim<TKey>>(); 142public virtual ICollection<PocoUserLogin<TKey>> Logins { get; private set; } = new List<PocoUserLogin<TKey>>(); 146public virtual ICollection<PocoUserToken<TKey>> Tokens { get; private set; } = new List<PocoUserToken<TKey>>();

IdentitySample.Mvc (2)

Models\AccountViewModels\SendCodeViewModel.cs (1)

12public ICollection<SelectListItem> Providers { get; set; }

Models\ManageViewModels\ConfigureTwoFactorViewModel.cs (1)

12public ICollection<SelectListItem> Providers { get; set; }

illink (3)

Linker\Annotations.cs (1)

113 public ICollection<AssemblyDefinition> GetAssemblies ()

Linker\LinkContext.cs (1)

352 public virtual ICollection<AssemblyDefinition> ResolveReferences (AssemblyDefinition assembly)

Linker\TypeMapInfo.cs (1)

64 public ICollection<MethodDefinition> MethodsWithOverrideInformation => override_methods.Keys;

InMemory.FunctionalTests (5)

Http2\Http2ConnectionTests.cs (2)

289public ICollection<string> Keys => _innerHeaders.Keys; 290public ICollection<StringValues> Values => _innerHeaders.Values;

Http3\Http3ConnectionTests.cs (2)

640public ICollection<string> Keys => _innerHeaders.Keys; 641public ICollection<StringValues> Values => _innerHeaders.Values;

KestrelMetricsTests.cs (1)

224public ICollection<KeyValuePair<string, object>> Tags { get; } = new List<KeyValuePair<string, object>>();

Microsoft.Arcade.Test.Common (3)

MockEngine.cs (3)

24public ICollection<BuildMessageEventArgs> Messages { get; } = new List<BuildMessageEventArgs>(); 25public ICollection<BuildWarningEventArgs> Warnings { get; } = new List<BuildWarningEventArgs>(); 26public ICollection<BuildErrorEventArgs> Errors { get; } = new List<BuildErrorEventArgs>();

Microsoft.AspNetCore (5)

WebApplication.cs (5)

69public ICollection<string> Urls => ServerFeatures.GetRequiredFeature<IServerAddressesFeature>().Addresses; 83internal ICollection<EndpointDataSource> DataSources => _dataSources; 84ICollection<EndpointDataSource> IEndpointRouteBuilder.DataSources => DataSources; 239var addresses = ServerFeatures.Get<IServerAddressesFeature>()?.Addresses; 246throw new InvalidOperationException($"Changing the URL is not supported because {nameof(IServerAddressesFeature.Addresses)} {nameof(ICollection<string>.IsReadOnly)}.");

Microsoft.AspNetCore.App.Analyzers.Test (1)

RouteEmbeddedLanguage\Infrastructure\ExportProviderExtensions.cs (1)

66|| contractType.GetGenericTypeDefinition() == typeof(ICollection<>)

Microsoft.AspNetCore.Authentication.Core.Test (4)

AuthenticationPropertiesTests.cs (4)

154props.SetParameter<ICollection<string>>("foo", list); 155Assert.Equal(new string[] { "a", "b", "c" }, props.GetParameter<ICollection<string>>("foo")); 159props.SetParameter<ICollection<string>?>("foo", null); 160Assert.Null(props.GetParameter<ICollection<string>>("foo"));

Microsoft.AspNetCore.Authentication.Facebook (1)

FacebookOptions.cs (1)

93public ICollection<string> Fields { get; } = new HashSet<string>();

Microsoft.AspNetCore.Authentication.OAuth (5)

OAuthChallengeProperties.cs (2)

41public ICollection<string> Scope 43get => GetParameter<ICollection<string>>(ScopeKey)!;

OAuthHandler.cs (2)

302var scopeParameter = properties.GetParameter<ICollection<string>>(OAuthChallengeProperties.ScopeKey);

OAuthOptions.cs (1)

84public ICollection<string> Scope { get; } = new HashSet<string>();

Microsoft.AspNetCore.Authentication.OpenIdConnect (3)

OpenIdConnectConfigureOptions.cs (1)

110private static void ClearAndSetListOption(ICollection<string> listOption, IConfigurationSection listConfigSection)

OpenIdConnectHandler.cs (1)

407Scope = string.Join(" ", properties.GetParameter<ICollection<string>>(OpenIdConnectParameterNames.Scope) ?? Options.Scope),

OpenIdConnectOptions.cs (1)

237public ICollection<string> Scope { get; } = new HashSet<string>();

Microsoft.AspNetCore.Authentication.Test (15)

OpenIdConnect\TestSettings.cs (15)

Microsoft.AspNetCore.Authentication.WsFederation (3)

WsFederationOptions.cs (3)

22private ICollection<ISecurityTokenValidator> _securityTokenHandlers = new Collection<ISecurityTokenValidator>() 109public ICollection<ISecurityTokenValidator> SecurityTokenHandlers 124public ICollection<TokenHandler> TokenHandlers

Microsoft.AspNetCore.Components (7)

src\Http\Http.Abstractions\src\Routing\RouteValueDictionary.cs (7)

Microsoft.AspNetCore.Components.Endpoints (9)

Builder\RazorComponentEndpointDataSource.cs (1)

114ICollection<IComponentRenderMode> renderModes = Options.ConfiguredRenderModes;

FormMapping\Converters\CollectionAdapters\ImplementingCollectionBufferAdapter.cs (1)

7where TBuffer : TCollection, ICollection<TElement>, new()

FormMapping\Factories\Collections\ConcreteTypeCollectionConverterFactory.cs (1)

43where TCustomCollection : TCollection, ICollection<TElement>, new()

FormMapping\Factories\Collections\TypedCollectionConverterFactory.cs (6)

65var _ when type.IsAssignableTo(typeof(ICollection<TElement>)) && type.GetConstructor(Type.EmptyTypes) != null => true, 88var _ when type == (typeof(ICollection<TElement>)) => true, 164var _ when type.IsAssignableTo(typeof(ICollection<TElement>)) 197var _ when type.IsAssignableTo(typeof(ICollection<TElement>)) => 198CreateConverter<ICollection<TElement>, List<TElement>>(elementTypeConverter), 212where TImplementation : TInterface, ICollection<TElement>, new()

Microsoft.AspNetCore.Components.Endpoints.Tests (3)

Binding\FormDataMapperTests.cs (1)

698CanDeserialize_Collection<ICollection<int>, List<int>, int>(expected);

HotReloadServiceTests.cs (1)

269public ICollection<EndpointDataSource> DataSources => _dataSources;

RazorComponentEndpointDataSourceTest.cs (1)

290public ICollection<EndpointDataSource> DataSources => _dataSources;

Microsoft.AspNetCore.Components.QuickGrid (2)

GridItemsProviderResult.cs (1)

40public static GridItemsProviderResult<TGridItem> From<TGridItem>(ICollection<TGridItem> items, int totalItemCount)

QuickGrid.razor.cs (1)

113private ICollection<TGridItem> _currentNonVirtualizedViewItems = Array.Empty<TGridItem>();

Microsoft.AspNetCore.Components.Server (1)

DependencyInjection\ServerRazorComponentsBuilderExtensions.cs (1)

134public ICollection<EndpointDataSource> DataSources { get; } = new List<EndpointDataSource>() { };

Microsoft.AspNetCore.Components.Web (1)

Virtualization\Virtualize.cs (1)

98public ICollection<TItem>? Items { get; set; }

Microsoft.AspNetCore.Components.Web.Tests (1)

Virtualization\VirtualizeTest.cs (1)

111ICollection<TItem> items,

Microsoft.AspNetCore.Components.WebAssembly.Server (1)

WebAssemblyRazorComponentsBuilderExtensions.cs (1)

83public ICollection<EndpointDataSource> DataSources { get; } = [];

Microsoft.AspNetCore.Connections.Abstractions (10)

ConnectionItems.cs (9)

Features\IConnectionMetricsTagsFeature.cs (1)

16ICollection<KeyValuePair<string, object?>> Tags { get; }

Microsoft.AspNetCore.DeveloperCertificates.XPlat (2)

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (2)

380var certsFromDisk = GetCertsFromDisk(); 426private static ICollection<X509Certificate2> GetCertsFromDisk()

Microsoft.AspNetCore.Diagnostics (1)

src\Shared\Metrics\MetricsExtensions.cs (1)

13var tags = feature.Tags;

Microsoft.AspNetCore.Grpc.JsonTranscoding.IntegrationTests (1)

Infrastructure\DynamicGrpcServiceRegistry.cs (1)

130public ICollection<EndpointDataSource> DataSources { get; } = new List<EndpointDataSource>();

Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests (1)

JsonTranscodingServiceMethodProviderTests.cs (1)

246public ICollection<EndpointDataSource> DataSources { get; }

Microsoft.AspNetCore.Hosting (6)

GenericHost\GenericWebHostService.cs (1)

67var addresses = serverAddressesFeature?.Addresses;

Internal\HttpMetricsTagsFeature.cs (1)

10ICollection<KeyValuePair<string, object?>> IHttpMetricsTagsFeature.Tags => TagsList;

Internal\WebHost.cs (1)

262var addresses = serverAddressesFeature?.Addresses;

Server\Features\ServerAddressesFeature.cs (1)

14public ICollection<string> Addresses { get; } = new List<string>();

src\Shared\Metrics\MetricsExtensions.cs (1)

13var tags = feature.Tags;

WebHostExtensions.cs (1)

122var serverAddresses = host.ServerFeatures.Get<IServerAddressesFeature>()?.Addresses;

Microsoft.AspNetCore.Hosting.Server.Abstractions (2)

Features\IServerAddressesFeature.cs (2)

12/// An <see cref="ICollection{T}" /> of addresses used by the server. 14ICollection<string> Addresses { get; }

Microsoft.AspNetCore.Hosting.Tests (4)

GenericWebHostBuilderTests.cs (1)

140public ICollection<string> Addresses { get; } = new List<string>();

HostingMetricsTests.cs (1)

182public ICollection<KeyValuePair<string, object>> Tags { get; } = new Collection<KeyValuePair<string, object>>();

WebHostTests.cs (2)

1394public ICollection<string> Keys => null; 1414public ICollection<StringValues> Values => null;

Microsoft.AspNetCore.Http (33)

FormCollection.cs (1)

93public ICollection<string> Keys

HeaderDictionary.cs (2)

163public ICollection<string> Keys 178public ICollection<StringValues> Values

Internal\ItemsDictionary.cs (10)

Internal\RequestCookieCollection.cs (1)

98public ICollection<string> Keys

QueryCollection.cs (1)

104public ICollection<string> Keys

QueryCollectionInternal.cs (1)

46public ICollection<string> Keys => Store.Keys;

src\Shared\CopyOnWriteDictionary\CopyOnWriteDictionary.cs (2)

55public ICollection<TKey> Keys 63public ICollection<TValue> Values

src\Shared\CopyOnWriteDictionary\CopyOnWriteDictionaryHolder.cs (4)

138((ICollection<KeyValuePair<TKey, TValue>>)WriteDictionary).Add(item); 148return ((ICollection<KeyValuePair<TKey, TValue>>)ReadDictionary).Contains(item); 153((ICollection<KeyValuePair<TKey, TValue>>)ReadDictionary).CopyTo(array, arrayIndex); 158return ((ICollection<KeyValuePair<TKey, TValue>>)WriteDictionary).Remove(item);

src\Shared\Dictionary\AdaptiveCapacityDictionary.cs (11)

Microsoft.AspNetCore.Http.Abstractions (7)

Routing\RouteValueDictionary.cs (7)

Microsoft.AspNetCore.Http.Abstractions.Tests (22)

MapPathMiddlewareTests.cs (1)

258public ICollection<EndpointDataSource> DataSources => throw new NotImplementedException();

RouteValueDictionaryTests.cs (21)

Microsoft.AspNetCore.Http.Extensions (8)

src\Components\Endpoints\src\FormMapping\Converters\CollectionAdapters\ImplementingCollectionBufferAdapter.cs (1)

7where TBuffer : TCollection, ICollection<TElement>, new()

src\Components\Endpoints\src\FormMapping\Factories\Collections\ConcreteTypeCollectionConverterFactory.cs (1)

43where TCustomCollection : TCollection, ICollection<TElement>, new()

src\Components\Endpoints\src\FormMapping\Factories\Collections\TypedCollectionConverterFactory.cs (6)

Microsoft.AspNetCore.Http.Extensions.Tests (1)

RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (1)

481public ICollection<EndpointDataSource> DataSources { get; }

Microsoft.AspNetCore.Http.Features (10)

IFormCollection.cs (3)

22/// Gets an <see cref="ICollection{T}" /> containing the keys of the 26/// An <see cref="ICollection{T}" /> containing the keys of the object 29ICollection<string> Keys { get; }

IHttpMetricsTagsFeature.cs (1)

14ICollection<KeyValuePair<string, object?>> Tags { get; }

IQueryCollection.cs (3)

22/// Gets an <see cref="ICollection{T}" /> containing the keys of the 26/// An <see cref="ICollection{T}" /> containing the keys of the object 29ICollection<string> Keys { get; }

IRequestCookieCollection.cs (3)

22/// Gets an <see cref="ICollection{T}" /> containing the keys of the 26/// An <see cref="ICollection{T}" /> containing the keys of the object 29ICollection<string> Keys { get; }

Microsoft.AspNetCore.Http.Microbenchmarks (1)

src\Http\Http.Extensions\test\RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (1)

481public ICollection<EndpointDataSource> DataSources { get; }

Microsoft.AspNetCore.Http.Results (1)

src\Shared\RangeHelper\RangeHelper.cs (1)

69var ranges = rangeHeader.Ranges;

Microsoft.AspNetCore.Http.Tests (2)

Internal\ItemsDictionaryTests.cs (2)

29ICollection<KeyValuePair<object, object>> cl = (ICollection<KeyValuePair<object, object>>)dict;

Microsoft.AspNetCore.Identity.EntityFrameworkCore.Test (5)

src\Identity\test\Shared\PocoModel\PocoRole.cs (1)

57public virtual ICollection<PocoRoleClaim<TKey>> Claims { get; private set; } = new List<PocoRoleClaim<TKey>>();

src\Identity\test\Shared\PocoModel\PocoUser.cs (4)

Microsoft.AspNetCore.Identity.InMemory.Test (5)

src\Identity\test\Shared\PocoModel\PocoRole.cs (1)

57public virtual ICollection<PocoRoleClaim<TKey>> Claims { get; private set; } = new List<PocoRoleClaim<TKey>>();

src\Identity\test\Shared\PocoModel\PocoUser.cs (4)

Microsoft.AspNetCore.Identity.Test (5)

src\Identity\test\Shared\PocoModel\PocoRole.cs (1)

57public virtual ICollection<PocoRoleClaim<TKey>> Claims { get; private set; } = new List<PocoRoleClaim<TKey>>();

src\Identity\test\Shared\PocoModel\PocoUser.cs (4)

Microsoft.AspNetCore.JsonPatch.Tests (4)

TestObjectModels\DynamicTestObject.cs (2)

15public ICollection<string> Keys => ((IDictionary<string, object>)_dictionary).Keys; 17public ICollection<object> Values => ((IDictionary<string, object>)_dictionary).Values;

WriteOnceDynamicTestObject.cs (2)

29public ICollection<string> Keys => ((IDictionary<string, object>)_dictionary).Keys; 31public ICollection<object> Values => ((IDictionary<string, object>)_dictionary).Values;

Microsoft.AspNetCore.Mvc.Abstractions (4)

ModelBinding\ModelMetadata.cs (2)

456/// A collection type is defined as a <see cref="Type"/> which is assignable to <see cref="ICollection{T}"/>. 661var collectionType = ClosedGenericMatcher.ExtractGenericInterface(ModelType, typeof(ICollection<>));

ModelBinding\Validation\ValidationStateDictionary.cs (2)

61public ICollection<object> Keys => ((IDictionary<object, ValidationStateEntry>)_inner).Keys; 64public ICollection<ValidationStateEntry> Values => ((IDictionary<object, ValidationStateEntry>)_inner).Values;

Microsoft.AspNetCore.Mvc.Api.Analyzers (2)

AddResponseTypeAttributeCodeFixAction.cs (2)

58var results = CalculateStatusCodesToApply(context, declaredResponseMetadata); 169private static ICollection<(int statusCode, ITypeSymbol? typeSymbol)> CalculateStatusCodesToApply(in CodeActionContext context, IList<DeclaredApiResponseMetadata> declaredResponseMetadata)

Microsoft.AspNetCore.Mvc.ApiExplorer (4)

ApiResponseTypeProvider.cs (3)

30public ICollection<ApiResponseType> GetApiResponseTypes(ControllerActionDescriptor action) 54var apiResponseTypes = GetApiResponseTypes(responseMetadataAttributes, producesResponseMetadata, runtimeReturnType, defaultErrorType); 75private ICollection<ApiResponseType> GetApiResponseTypes(

DefaultApiDescriptionProvider.cs (1)

115var apiResponseTypes = _responseTypeProvider.GetApiResponseTypes(action);

Microsoft.AspNetCore.Mvc.ApiExplorer.Test (18)

ApiResponseTypeProviderTest.cs (17)

EndpointMetadataApiDescriptionProviderTest.cs (1)

1438public ICollection<EndpointDataSource> DataSources { get; }

Microsoft.AspNetCore.Mvc.Core (37)

Infrastructure\AsyncEnumerableReader.cs (3)

24/// This type is used to create a strongly typed synchronous <see cref="ICollection{T}"/> instance from 25/// an <see cref="IAsyncEnumerable{T}"/>. An accurate <see cref="ICollection{T}"/> is required for XML formatters to 47/// Attempts to produces a delegate that reads an <see cref="IAsyncEnumerable{T}"/> into an <see cref="ICollection{T}"/>.

ModelBinding\Binders\CollectionModelBinder.cs (3)

201typeof(ICollection<TElement>).IsAssignableFrom(targetType); 471var targetCollection = target as ICollection<TElement?>;

ModelBinding\Binders\CollectionModelBinderProvider.cs (2)

14/// An <see cref="IModelBinderProvider"/> for <see cref="ICollection{T}"/>. 32var collectionType = ClosedGenericMatcher.ExtractGenericInterface(modelType, typeof(ICollection<>));

ModelBinding\Binders\FormCollectionModelBinder.cs (1)

64public ICollection<string> Keys => new List<string>();

ModelBinding\Binders\FormFileModelBinder.cs (2)

47ICollection<IFormFile> postedFiles; 138ICollection<IFormFile> postedFiles)

ModelBinding\Binders\HeaderModelBinder.cs (1)

179var collection = ModelBindingHelper.GetCompatibleCollection<string>(bindingContext, values.Length);

ModelBinding\ModelBindingHelper.cs (14)

451/// <typeparam name="T">The element type of the <see cref="ICollection{T}"/> required.</typeparam> 483if (model is ICollection<T> collection && !collection.IsReadOnly) 500typeof(ICollection<T>).IsAssignableFrom(modelType); 504/// Creates an <see cref="ICollection{T}"/> instance compatible with <paramref name="bindingContext"/>'s 507/// <typeparam name="T">The element type of the <see cref="ICollection{T}"/> required.</typeparam> 510/// An <see cref="ICollection{T}"/> instance compatible with <paramref name="bindingContext"/>'s 516public static ICollection<T> GetCompatibleCollection<T>(ModelBindingContext bindingContext) 522/// Creates an <see cref="ICollection{T}"/> instance compatible with <paramref name="bindingContext"/>'s 525/// <typeparam name="T">The element type of the <see cref="ICollection{T}"/> required.</typeparam> 531/// An <see cref="ICollection{T}"/> instance compatible with <paramref name="bindingContext"/>'s 537public static ICollection<T> GetCompatibleCollection<T>(ModelBindingContext bindingContext, int capacity) 542private static ICollection<T> GetCompatibleCollection<T>(ModelBindingContext bindingContext, int? capacity) 566if (model is ICollection<T> collection && !collection.IsReadOnly) 578return (ICollection<T>)Activator.CreateInstance(modelType)!;

ModelBinding\PrefixContainer.cs (2)

17private readonly ICollection<string> _originalValues; 24public PrefixContainer(ICollection<string> values)

ModelBinding\PropertyValueSetter.cs (2)

60var targetCollection = (ICollection<TElement>)target;

src\Shared\CopyOnWriteDictionary\CopyOnWriteDictionary.cs (2)

55public ICollection<TKey> Keys 63public ICollection<TValue> Values

src\Shared\CopyOnWriteDictionary\CopyOnWriteDictionaryHolder.cs (4)

src\Shared\RangeHelper\RangeHelper.cs (1)

69var ranges = rangeHeader.Ranges;

Microsoft.AspNetCore.Mvc.Core.Test (26)

ApplicationModels\DefaultApplicationModelProviderTest.cs (1)

1783ICollection<IFormFile> formFileCollection,

ApplicationModels\InferParameterBindingInfoConventionTest.cs (1)

1025public IActionResult FromQueryOnCollectionType([FromQuery] ICollection<int> value) => null;

Controllers\ControllerBinderDelegateProviderTest.cs (5)

663ParameterType = typeof(ICollection<string>), 918typeof(ICollection<string>), 932typeof(ICollection<string>), 1369public ICollection<string> CollectionProperty { get; } = new List<string> { "goodbye" }; 1373public ICollection<string> NullCollectionProperty { get; private set; }

Formatters\JsonInputFormatterTestBase.cs (1)

282public virtual Task ReadAsync_ReadsValidArray_AsCollectionOfT() => ReadAsync_ReadsValidArray_AsList(typeof(ICollection<int>));

Infrastructure\AsyncEnumerableReaderTest.cs (6)

43var collection = Assert.IsAssignableFrom<ICollection<string>>(readCollection); 61var collection = Assert.IsAssignableFrom<ICollection<int>>(readCollection); 166var collection = Assert.IsAssignableFrom<ICollection<object>>(readCollection);

ModelBinding\Binders\CollectionModelBinderProviderTest.cs (1)

39[InlineData(typeof(ICollection<int>))]

ModelBinding\Binders\CollectionModelBinderTest.cs (1)

429{ typeof(ICollection<int>), true },

ModelBinding\Binders\DictionaryModelBinderProviderTest.cs (1)

14[InlineData(typeof(ICollection<string>))]

ModelBinding\Binders\DictionaryModelBinderTest.cs (1)

593{ typeof(ICollection<KeyValuePair<int, int>>), true },

ModelBinding\Binders\FormFileModelBinderTest.cs (1)

249[InlineData(typeof(ICollection<IFormFile>))]

ModelBinding\Binders\HeaderModelBinderProviderTest.cs (1)

100[InlineData(typeof(ICollection<CarEnumType>))]

ModelBinding\Binders\HeaderModelBinderTests.cs (3)

62[InlineData(typeof(ICollection<string>))] 195[InlineData(typeof(ICollection<string>))] 301[InlineData(typeof(ICollection<CarType>), "a, b")]

ModelBinding\ModelBindingHelperTest.cs (2)

1337[InlineData(typeof(ICollection<int>))] 1361[InlineData(typeof(ICollection<int>))]

ModelBinding\Validation\DefaultObjectValidatorTests.cs (1)

884typeof(ICollection<DateTime>)

Microsoft.AspNetCore.Mvc.Formatters.Xml.Test (1)

EnumerableWrapperProviderTest.cs (1)

15[InlineData(typeof(ICollection<SerializableError>),

Microsoft.AspNetCore.Mvc.IntegrationTests (60)

ActionParametersIntegrationTest.cs (2)

1002private readonly ICollection<T> _original; 1009public CustomReadOnlyCollection(ICollection<T> original)

CollectionModelBinderIntegrationTest.cs (34)

DictionaryModelBinderIntegrationTest.cs (18)

GenericModelBinderIntegrationTest.cs (3)

391ParameterType = typeof(ICollection<KeyValuePair<string, int>>) 435ParameterType = typeof(ICollection<KeyValuePair<string, int>>) 479ParameterType = typeof(ICollection<KeyValuePair<string, int>>)

TryUpdateModelIntegrationTest.cs (3)

582public ICollection<Address> Address { get; } = new Address[] 1293private readonly ICollection<T> _original; 1300public CustomReadOnlyCollection(ICollection<T> original)

Microsoft.AspNetCore.Mvc.NewtonsoftJson (3)

src\Mvc\Mvc.Core\src\Infrastructure\AsyncEnumerableReader.cs (3)

Microsoft.AspNetCore.Mvc.NewtonsoftJson.Test (7)

src\Mvc\Mvc.Core\test\Formatters\JsonInputFormatterTestBase.cs (1)

282public virtual Task ReadAsync_ReadsValidArray_AsCollectionOfT() => ReadAsync_ReadsValidArray_AsList(typeof(ICollection<int>));

src\Mvc\Mvc.Core\test\Infrastructure\AsyncEnumerableReaderTest.cs (6)

Microsoft.AspNetCore.Mvc.Razor (2)

TagHelperComponentManager.cs (1)

26public ICollection<ITagHelperComponent> Components { get; }

TagHelpers\ITagHelperComponentManager.cs (1)

18ICollection<ITagHelperComponent> Components { get; }

Microsoft.AspNetCore.Mvc.TagHelpers (4)

CurrentValues.cs (3)

10public CurrentValues(ICollection<string> values) 16public ICollection<string> Values { get; } 18public ICollection<string> ValuesAndEncodedValues { get; set; }

SelectTagHelper.cs (1)

24private ICollection<string> _currentValues;

Microsoft.AspNetCore.Mvc.TagHelpers.Test (6)

OptionTagHelperTest.cs (6)

13public static TheoryData<string, string, string, ICollection<string>, TagHelperOutput> GeneratesExpectedDataSet 17return new TheoryData<string, string, string, ICollection<string>, TagHelperOutput> 358entry => (entry[1] != null || entry[3] == null || ((ICollection<string>)(entry[3])).Count == 0)); 379ICollection<string> currentValues, 451ICollection<string> currentValues, 515ICollection<string> _,

Microsoft.AspNetCore.Mvc.ViewFeatures (29)

AttributeDictionary.cs (2)

63public ICollection<string> Keys => new KeyCollection(this); 66public ICollection<string?> Values => new ValueCollection(this);

DefaultHtmlGenerator.cs (5)

516var currentValues = GetCurrentValues(viewContext, modelExplorer, expression, allowMultiple); 535ICollection<string> currentValues, 900public virtual ICollection<string> GetCurrentValues( 1556ICollection<string> currentValues) 1640private static IHtmlContent GenerateOption(SelectListItem item, ICollection<string> currentValues)

IHtmlGenerator.cs (4)

416/// An <see cref="ICollection{String}"/> containing values for <option> elements to select. If 446ICollection<string> currentValues, 576/// <see cref="ICollection{String}"/> containing current values for the given 594ICollection<string> GetCurrentValues(

Infrastructure\DefaultTempDataSerializer.cs (4)

182case ICollection<int> intCollection: 191case ICollection<string> stringCollection: 230typeof(ICollection<int>).IsAssignableFrom(type) || 231typeof(ICollection<string>).IsAssignableFrom(type) ||

TempDataDictionary.cs (12)

ViewDataDictionary.cs (2)

332public ICollection<string> Keys 338public ICollection<object?> Values

Microsoft.AspNetCore.Mvc.ViewFeatures.Test (14)

AttributeDictionaryTest.cs (2)

196var keys = attributes.Keys; 348var values = attributes.Values;

DefaultHtmlGeneratorTest.cs (12)

Microsoft.AspNetCore.OpenApi.Tests (1)

Services\OpenApiDocumentServiceTestsBase.cs (1)

150public ICollection<EndpointDataSource> DataSources { get; }

Microsoft.AspNetCore.Owin (27)

DictionaryStringArrayWrapper.cs (9)

DictionaryStringValuesWrapper.cs (9)

OwinEnvironment.cs (9)

Microsoft.AspNetCore.Owin.Tests (2)

OwinEnvironmentTests.cs (2)

141var collection = (ICollection<KeyValuePair<string, object>>)owinEnvironment;

Microsoft.AspNetCore.Razor (1)

TagHelpers\TagHelperAttributeList.cs (1)

121bool ICollection<TagHelperAttribute>.IsReadOnly => false;

Microsoft.AspNetCore.Razor.Runtime (6)

src\Shared\CopyOnWriteDictionary\CopyOnWriteDictionary.cs (2)

55public ICollection<TKey> Keys 63public ICollection<TValue> Values

src\Shared\CopyOnWriteDictionary\CopyOnWriteDictionaryHolder.cs (4)

Microsoft.AspNetCore.Razor.Test (2)

TagHelpers\TagHelperAttributeListTest.cs (2)

219var attributes = new TagHelperAttributeList() as ICollection<TagHelperAttribute>;

Microsoft.AspNetCore.Routing (13)

Builder\RouteHandlerBuilder.cs (4)

12private readonly ICollection<Action<EndpointBuilder>>? _conventions; 13private readonly ICollection<Action<EndpointBuilder>>? _finallyConventions; 15internal RouteHandlerBuilder(ICollection<Action<EndpointBuilder>> conventions, ICollection<Action<EndpointBuilder>> finallyConventions)

CompositeEndpointDataSource.cs (1)

20private readonly ICollection<EndpointDataSource> _dataSources;

ConfigureRouteOptions.cs (2)

11private readonly ICollection<EndpointDataSource> _dataSources; 13public ConfigureRouteOptions(ICollection<EndpointDataSource> dataSources)

DefaultEndpointRouteBuilder.cs (1)

20public ICollection<EndpointDataSource> DataSources { get; }

IEndpointRouteBuilder.cs (1)

28ICollection<EndpointDataSource> DataSources { get; }

RouteEndpointDataSource.cs (1)

353void ICollection<Action<EndpointBuilder>>.Add(Action<EndpointBuilder> convention)

RouteGroupBuilder.cs (1)

36ICollection<EndpointDataSource> IEndpointRouteBuilder.DataSources => _dataSources;

RouteOptions.cs (2)

25private ICollection<EndpointDataSource> _endpointDataSources = default!; 30internal ICollection<EndpointDataSource> EndpointDataSources

Microsoft.AspNetCore.Routing.Microbenchmarks (1)

EndpointRoutingShortCircuitBenchmark.cs (1)

102public ICollection<EndpointDataSource> DataSources => new List<EndpointDataSource>();

Microsoft.AspNetCore.Server.HttpSys (12)

MessagePump.Log.cs (2)

23public static void ClearedAddresses(ILogger logger, ICollection<string> serverAddresses) 37public static void ClearedPrefixes(ILogger logger, ICollection<string> serverAddresses)

src\Shared\HttpSys\RequestProcessing\HeaderCollection.cs (2)

108public ICollection<string> Keys 113public ICollection<StringValues> Values

src\Shared\HttpSys\RequestProcessing\RequestHeaders.cs (8)

Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (1)

Listener\ResponseHeaderTests.cs (1)

276((ICollection<KeyValuePair<string, StringValues>>)responseHeaders).Add(kvp);

Microsoft.AspNetCore.Server.HttpSys.Microbenchmarks (2)

RequestHeaderBenchmarks.cs (2)

41public ICollection<string> KeysSingleHeader() 48public ICollection<string> KeysLargeHeaders()

Microsoft.AspNetCore.Server.IIS (11)

Core\ServerAddressesFeature.cs (1)

10public ICollection<string> Addresses { get; set; } = Array.Empty<string>();

src\Shared\HttpSys\RequestProcessing\HeaderCollection.cs (2)

108public ICollection<string> Keys 113public ICollection<StringValues> Values

src\Shared\HttpSys\RequestProcessing\RequestHeaders.cs (8)

Microsoft.AspNetCore.Server.Kestrel.Core (17)

Internal\AddressBindContext.cs (1)

23public ICollection<string> Addresses => ServerAddressesFeature.InternalCollection;

Internal\Http\HttpHeaders.cs (8)

Internal\Http\HttpHeaders.Generated.cs (3)

7472((ICollection<KeyValuePair<string, StringValues>>?)MaybeUnknown)?.CopyTo(array, arrayIndex); 14799((ICollection<KeyValuePair<string, StringValues>>?)MaybeUnknown)?.CopyTo(array, arrayIndex); 17567((ICollection<KeyValuePair<string, StringValues>>?)MaybeUnknown)?.CopyTo(array, arrayIndex);

Internal\Infrastructure\KestrelConnectionOfT.cs (1)

103ICollection<KeyValuePair<string, object?>> IConnectionMetricsTagsFeature.Tags => TagsList;

Internal\ServerAddressesCollection.cs (1)

23public ICollection<string> PublicCollection => _publicCollection;

Internal\ServerAddressesFeature.cs (1)

16ICollection<string> IServerAddressesFeature.Addresses => InternalCollection.PublicCollection;

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (2)

380var certsFromDisk = GetCertsFromDisk(); 426private static ICollection<X509Certificate2> GetCertsFromDisk()

Microsoft.AspNetCore.Server.Kestrel.Core.Tests (5)

Http1\Http1ConnectionTests.cs (2)

1197public ICollection<string> Keys => _innerHeaders.Keys; 1198public ICollection<StringValues> Values => _innerHeaders.Values;

HttpResponseHeadersTests.cs (3)

123((ICollection<KeyValuePair<string, StringValues>>)responseHeaders).Add(kvp); 217((ICollection<KeyValuePair<string, StringValues>>)responseHeaders).Add(kvp); 249((ICollection<KeyValuePair<string, StringValues>>)responseHeaders).Add(kvp);

Microsoft.AspNetCore.Session (4)

DefaultDistributedSessionStore.cs (1)

15public ICollection<EncodedKey> Keys => _store.Keys;

IDistributedSessionStore.cs (1)

12ICollection<EncodedKey> Keys { get; }

NoOpSessionStore.cs (2)

20public ICollection<EncodedKey> Keys { get; } = Array.Empty<EncodedKey>(); 22public ICollection<byte[]> Values { get; } = Array.Empty<byte[]>();

Microsoft.AspNetCore.Shared.Tests (61)

AdaptiveCapacityDictionaryTests.cs (15)

ClosedGenericMatcherTest.cs (18)

PropertyHelperTest.cs (1)

292var helpers = PropertyHelper.GetProperties(typeof(ICollection<string>));

src\Shared\CopyOnWriteDictionary\CopyOnWriteDictionary.cs (2)

55public ICollection<TKey> Keys 63public ICollection<TValue> Values

src\Shared\CopyOnWriteDictionary\CopyOnWriteDictionaryHolder.cs (4)

src\Shared\Dictionary\AdaptiveCapacityDictionary.cs (11)

src\Shared\HttpSys\RequestProcessing\HeaderCollection.cs (2)

108public ICollection<string> Keys 113public ICollection<StringValues> Values

src\Shared\HttpSys\RequestProcessing\RequestHeaders.cs (8)

Microsoft.AspNetCore.SignalR.Core (1)

Internal\HubGroupList.cs (1)

40((ICollection<KeyValuePair<string, GroupConnectionList>>)(_groups)).Remove(groupToRemove);

Microsoft.AspNetCore.StaticAssets (1)

src\Shared\RangeHelper\RangeHelper.cs (1)

69var ranges = rangeHeader.Ranges;

Microsoft.AspNetCore.StaticFiles (1)

src\Shared\RangeHelper\RangeHelper.cs (1)

69var ranges = rangeHeader.Ranges;

Microsoft.AspNetCore.StaticFiles.FunctionalTests (1)

src\Shared\RangeHelper\RangeHelper.cs (1)

69var ranges = rangeHeader.Ranges;

Microsoft.AspNetCore.Tests (3)

WebApplicationTests.cs (3)

3091private readonly ICollection<string> _urls; 3098public MockAddressesServer(ICollection<string> urls) 3135public ICollection<string> Addresses { get; set; }

Microsoft.Build (290)

BackEnd\BuildManager\BuildParameters.cs (1)

579public ICollection<Toolset> Toolsets => ToolsetProvider.Toolsets;

BackEnd\BuildManager\BuildRequestData.cs (3)

262public ICollection<string> TargetNames { get; } 273public ICollection<ProjectPropertyInstance> GlobalProperties => (GlobalPropertiesDictionary == null) ? 274(ICollection<ProjectPropertyInstance>)ReadOnlyEmptyCollection<ProjectPropertyInstance>.Instance :

BackEnd\Components\Logging\ILoggingService.cs (8)

96ICollection<ILogger> Loggers 106ICollection<LoggerDescription> LoggerDescriptions 115ICollection<string> RegisteredLoggerTypeNames 124ICollection<string> RegisteredSinkNames 264ICollection<string> GetWarningsAsErrors(BuildEventContext context); 271ICollection<string> GetWarningsNotAsErrors(BuildEventContext context); 278ICollection<string> GetWarningsAsMessages(BuildEventContext context); 312void InitializeNodeLoggers(ICollection<LoggerDescription> loggerDescriptions, IBuildEventSink forwardingLoggerSink, int nodeId);

BackEnd\Components\Logging\LoggingService.cs (9)

476public ICollection<LoggerDescription> LoggerDescriptions => _loggerDescriptions; 481public ICollection<ILogger> Loggers => _loggers; 595public ICollection<string> GetWarningsAsErrors(BuildEventContext context) 606public ICollection<string> GetWarningsNotAsErrors(BuildEventContext context) 617public ICollection<string> GetWarningsAsMessages(BuildEventContext context) 632private ICollection<string> GetWarningsForProject(BuildEventContext context, IDictionary<WarningsConfigKey, ISet<string>> warningsByProject, ISet<string> warnings) 707public ICollection<string> RegisteredLoggerTypeNames 733public ICollection<string> RegisteredSinkNames 1128public void InitializeNodeLoggers(ICollection<LoggerDescription> descriptions, IBuildEventSink forwardingLoggerSink, int nodeId)

BackEnd\Components\Logging\TaskLoggingContext.cs (3)

150internal ICollection<string> GetWarningsAsErrors() 155internal ICollection<string> GetWarningsNotAsErrors() 160internal ICollection<string> GetWarningsAsMessages()

BackEnd\Components\ProjectCache\ProjectCacheService.cs (7)

100ICollection<string> requestedTargets, 128ICollection<string> requestedTargets, 162ICollection<string> requestedTargets, 178ICollection<ProjectItemInstance> items = projectInstance.GetItems(ItemTypeNames.ProjectCachePlugin); 197ICollection<string> requestedTargets, 530ICollection<string> requestedTargetsList = buildRequestConfiguration.RequestedTargets as ICollection<string> ?? buildRequestConfiguration.RequestedTargets.ToList();

BackEnd\Components\RequestBuilder\BatchingEngine.cs (7)

143Dictionary<string, ICollection<ProjectItemInstance>> itemListsToBeBatched = GetItemListsToBeBatched(consumedMetadataReferences, consumedItemReferences, lookup, elementLocation); 197private static Dictionary<string, ICollection<ProjectItemInstance>> GetItemListsToBeBatched( 206var itemListsToBeBatched = new Dictionary<string, ICollection<ProjectItemInstance>>(MSBuildNameIgnoreCaseComparer.Default); 248ICollection<ProjectItemInstance> items = lookup.GetItems(consumedItemName); 293Dictionary<string, ICollection<ProjectItemInstance>> itemListsToBeBatched, 303foreach (KeyValuePair<string, ICollection<ProjectItemInstance>> entry in itemListsToBeBatched) 308ICollection<ProjectItemInstance> items = entry.Value ?? lookup.GetItems(itemName);

BackEnd\Components\RequestBuilder\IntrinsicTasks\ItemGroupIntrinsicTask.cs (4)

248ICollection<ProjectItemInstance> group = bucket.Lookup.GetItems(child.ItemType); 293ICollection<ProjectItemInstance> group = bucket.Lookup.GetItems(child.ItemType); 543ICollection<ProjectItemInstance> items, 612ICollection<ProjectItemInstance> group,

BackEnd\Components\RequestBuilder\ItemBucket.cs (1)

74ICollection<string> itemNames,

BackEnd\Components\RequestBuilder\Lookup.cs (11)

BackEnd\Components\RequestBuilder\TaskBuilder.cs (2)

1030var projectReferenceItems = _buildRequestEntry.RequestConfiguration.Project.GetItems(ItemTypeNames.ProjectReference); 1198ICollection<ProjectItemInstance> items = bucket.Expander.ExpandIntoItemsLeaveEscaped(outputItemSpec, itemFactory, ExpanderOptions.ExpandItems, taskItemInstance.TaskParameterLocation);

BackEnd\Components\RequestBuilder\TaskHost.cs (6)

703private ICollection<string> _warningsAsErrors; 709private ICollection<string> WarningsAsErrors 723private ICollection<string> _warningsNotAsErrors; 729private ICollection<string> WarningsNotAsErrors 743private ICollection<string> _warningsAsMessages; 749private ICollection<string> WarningsAsMessages

BackEnd\Node\OutOfProcNode.cs (1)

732ICollection<Toolset> parentToolSets = _buildParameters.ToolsetProvider.Toolsets;

BackEnd\Shared\BuildRequest.cs (1)

177ICollection<string> escapedTargets,

BackEnd\Shared\BuildRequestConfiguration.cs (1)

813var items = Project.GetItems(ItemTypeNames.GraphIsolationExemptReference);

Collections\ArrayDictionary.cs (2)

68public ICollection<TKey> Keys => keys; 76public ICollection<TValue> Values => values;

Collections\CopyOnWritePropertyDictionary.cs (7)

68ICollection<string> IDictionary<string, T>.Keys => ((IDictionary<string, T>)_backing).Keys; 73ICollection<T> IDictionary<string, T>.Values => ((IDictionary<string, T>)_backing).Values; 78bool ICollection<KeyValuePair<string, T>>.IsReadOnly => false; 212void ICollection<KeyValuePair<string, T>>.Add(KeyValuePair<string, T> item) 220bool ICollection<KeyValuePair<string, T>>.Contains(KeyValuePair<string, T> item) 233void ICollection<KeyValuePair<string, T>>.CopyTo(KeyValuePair<string, T>[] array, int arrayIndex) 241bool ICollection<KeyValuePair<string, T>>.Remove(KeyValuePair<string, T> item)

Collections\IItemDictionary.cs (2)

30ICollection<string> ItemTypes { get; } 41ICollection<T> this[string itemType] { get; }

Collections\ItemDictionary.cs (7)

94public ICollection<string> ItemTypes 114public ICollection<T> this[string itemtype] 138foreach (ICollection<T> list in _itemLists.Values) 205public ICollection<T> GetItems(string itemType) 207ICollection<T> result = this[itemType]; 406private IEnumerator<ICollection<T>> _listEnumerator; 416internal Enumerator(IEnumerable<ICollection<T>> listEnumerable)

Collections\PropertyDictionary.cs (14)

108ICollection<string> IDictionary<string, T>.Keys 123ICollection<T> IDictionary<string, T>.Values 138int ICollection<KeyValuePair<string, T>>.Count => Count; 144bool ICollection<KeyValuePair<string, T>>.IsReadOnly => false; 155return ((ICollection<T>)_properties).Count; 231((ICollection<T>)_properties).Clear(); 376void ICollection<KeyValuePair<string, T>>.Add(KeyValuePair<string, T> item) 384void ICollection<KeyValuePair<string, T>>.Clear() 392bool ICollection<KeyValuePair<string, T>>.Contains(KeyValuePair<string, T> item) 408void ICollection<KeyValuePair<string, T>>.CopyTo(KeyValuePair<string, T>[] array, int arrayIndex) 416bool ICollection<KeyValuePair<string, T>>.Remove(KeyValuePair<string, T> item) 503var dictionary = new Dictionary<string, string>(((ICollection<T>)_properties).Count, MSBuildNameIgnoreCaseComparer.Default); 518foreach (var kvp in (ICollection<T>)_properties) 530foreach (T property in (ICollection<T>)_properties)

Collections\ReadOnlyConvertingDictionary.cs (2)

49public ICollection<K> Keys => _backing.Keys; 54public ICollection<N> Values

Collections\RetrievableEntryHashSet\HashSet.cs (10)

176ICollection<T> coll = collection as ICollection<T>; 203public ICollection<string> Keys 221public ICollection<T> Values 244/// Add item to this hashset. This is the explicit implementation of the <see cref="ICollection{T}" /> 248void ICollection<T>.Add(T item) 285bool ICollection<KeyValuePair<string, T>>.Contains(KeyValuePair<string, T> entry) 399bool ICollection<KeyValuePair<string, T>>.Remove(KeyValuePair<string, T> entry) 605void ICollection<KeyValuePair<string, T>>.Add(KeyValuePair<string, T> entry) 636void ICollection<KeyValuePair<string, T>>.CopyTo(KeyValuePair<string, T>[] array, int index)

Construction\ProjectChooseElement.cs (1)

61public ICollection<ProjectWhenElement> WhenElements => GetChildrenOfType<ProjectWhenElement>();

Construction\ProjectElementContainer.cs (2)

76public ICollection<ProjectElement> Children 100public ICollection<ProjectElement> ChildrenReversed

Construction\ProjectImportGroupElement.cs (1)

52public ICollection<ProjectImportElement> Imports => GetChildrenOfType<ProjectImportElement>();

Construction\ProjectItemDefinitionElement.cs (1)

53public ICollection<ProjectMetadataElement> Metadata => GetChildrenOfType<ProjectMetadataElement>();

Construction\ProjectItemDefinitionGroupElement.cs (1)

48public ICollection<ProjectItemDefinitionElement> ItemDefinitions => GetChildrenOfType<ProjectItemDefinitionElement>();

Construction\ProjectItemElement.cs (1)

286public ICollection<ProjectMetadataElement> Metadata => GetChildrenOfType<ProjectMetadataElement>();

Construction\ProjectItemGroupElement.cs (1)

57public ICollection<ProjectItemElement> Items => GetChildrenOfType<ProjectItemElement>();

Construction\ProjectOtherwiseElement.cs (3)

58public ICollection<ProjectItemGroupElement> ItemGroups => GetChildrenOfType<ProjectItemGroupElement>(); 63public ICollection<ProjectPropertyGroupElement> PropertyGroups => GetChildrenOfType<ProjectPropertyGroupElement>(); 68public ICollection<ProjectChooseElement> ChooseElements => GetChildrenOfType<ProjectChooseElement>();

Construction\ProjectPropertyGroupElement.cs (2)

48public ICollection<ProjectPropertyElement> Properties => GetChildrenOfType<ProjectPropertyElement>(); 53public ICollection<ProjectPropertyElement> PropertiesReversed => GetChildrenReversedOfType<ProjectPropertyElement>();

Construction\ProjectRootElement.cs (15)

Construction\ProjectTargetElement.cs (4)

59public ICollection<ProjectItemGroupElement> ItemGroups => GetChildrenOfType<ProjectItemGroupElement>(); 64public ICollection<ProjectPropertyGroupElement> PropertyGroups => GetChildrenOfType<ProjectPropertyGroupElement>(); 69public ICollection<ProjectTaskElement> Tasks => GetChildrenOfType<ProjectTaskElement>(); 74public ICollection<ProjectOnErrorElement> OnErrors => GetChildrenOfType<ProjectOnErrorElement>();

Construction\ProjectTaskElement.cs (1)

128public ICollection<ProjectOutputElement> Outputs => GetChildrenOfType<ProjectOutputElement>();

Construction\ProjectWhenElement.cs (3)

49public ICollection<ProjectChooseElement> ChooseElements => GetChildrenOfType<ProjectChooseElement>(); 54public ICollection<ProjectItemGroupElement> ItemGroups => GetChildrenOfType<ProjectItemGroupElement>(); 59public ICollection<ProjectPropertyGroupElement> PropertyGroups => GetChildrenOfType<ProjectPropertyGroupElement>();

Construction\UsingTaskParameterGroupElement.cs (1)

60public ICollection<ProjectUsingTaskParameterElement> Parameters => GetChildrenOfType<ProjectUsingTaskParameterElement>();

CopyOnWriteDictionary.cs (2)

114public ICollection<string> Keys => ((IDictionary<string, V>)_backing).Keys; 119public ICollection<V> Values => ((IDictionary<string, V>)_backing).Values;

Definition\BuiltInMetadata.cs (1)

33internal static ICollection<string> MetadataNames

Definition\Project.cs (30)

Definition\ProjectCollection.cs (6)

586public ICollection<Project> LoadedProjects => GetLoadedProjects(true, null); 608public ICollection<ILogger> Loggers 616? (ICollection<ILogger>)ReadOnlyEmptyCollection<ILogger>.Instance 628public ICollection<Toolset> Toolsets 1082public ICollection<Project> GetLoadedProjects(string fullPath) 1092internal ICollection<Project> GetLoadedProjects(bool includeExternal, string fullPath = null)

Definition\ProjectItem.cs (2)

283public ICollection<ProjectMetadata> Metadata 324internal ICollection<ProjectMetadata> MetadataCollection

Definition\Toolset.cs (1)

932ICollection<ProjectPropertyInstance> subToolsetProperties = null;

Evaluation\Expander.cs (1)

2001var itemsOfType = evaluatedItems.GetItems(expressionCapture.ItemType);

Evaluation\IItemProvider.cs (1)

23ICollection<T> GetItems(string itemType);

Evaluation\IToolsetProvider.cs (1)

18ICollection<Toolset> Toolsets

Evaluation\LazyItemEvaluator.cs (1)

633private static IEnumerable<string> GetExpandedMetadataValuesAndConditions(ICollection<ProjectMetadataElement> metadata, Expander<P, I> expander, LoggingContext loggingContext = null)

Evaluation\LazyItemEvaluator.EvaluatorData.cs (1)

49public ICollection GetItems(string itemType)

Evaluation\LazyItemEvaluator.OrderedItemDataCollection.cs (2)

137public void RemoveAll(ICollection itemsToRemove) 147public void RemoveAll(ICollection<string> itemPathsToRemove)

Evaluation\PropertyTrackingEvaluatorDataWrapper.cs (1)

119public ICollection GetItems(string itemType) => _wrapped.GetItems(itemType);

Evaluation\ToolsetProvider.cs (1)

62public ICollection<Toolset> Toolsets => _toolsets.Values;

Graph\GraphBuildRequestData.cs (14)

Graph\ProjectGraph.cs (2)

609public IReadOnlyDictionary<ProjectGraphNode, ImmutableList<string>> GetTargetLists(ICollection<string> entryProjectTargets) 786void ThrowOnEmptyTargetNames(ICollection<string> targetNames)

Graph\ProjectInterpretation.cs (1)

501ICollection<ProjectItemInstance> projectReferenceTargets = project.GetItems(ItemTypeNames.ProjectReferenceTargets);

Instance\ImmutableProjectCollections\ImmutableElementCollectionConverter.cs (2)

47public ICollection<string> Keys => _projectElements.Keys; 49public ICollection<T> Values => _values;

Instance\ImmutableProjectCollections\ImmutableItemDictionary.cs (13)

23private readonly IDictionary<string, ICollection<TCached>> _itemsByType; 24private readonly ICollection<T> _allItems; 26public ImmutableItemDictionary(IDictionary<string, ICollection<TCached>> itemsByType, ICollection<TCached> allItems) 48public ICollection<T> this[string itemType] 52if (!_itemsByType.TryGetValue(itemType, out ICollection<TCached>? list)) 65public ICollection<string> ItemTypes => _itemsByType.Keys; 113public ICollection<T> GetItems(string itemType) 115if (_itemsByType.TryGetValue(itemType, out ICollection<TCached>? items)) 154private readonly ICollection<T> _allItems; 155private readonly ICollection<TCached> _list; 157public ListConverter(string itemType, ICollection<T> allItems, ICollection<TCached> list)

Instance\ProjectInstance.cs (18)

Instance\ProjectItemDefinitionInstance.cs (1)

89public ICollection<ProjectMetadataInstance> Metadata

Instance\ProjectItemGroupTaskInstance.cs (2)

91public ICollection<ProjectItemGroupTaskItemInstance> Items 97(ICollection<ProjectItemGroupTaskItemInstance>)ReadOnlyEmptyCollection<ProjectItemGroupTaskItemInstance>.Instance :

Instance\ProjectItemGroupTaskItemInstance.cs (2)

322public ICollection<ProjectItemGroupTaskMetadataInstance> Metadata 328(ICollection<ProjectItemGroupTaskMetadataInstance>)ReadOnlyEmptyCollection<ProjectItemGroupTaskMetadataInstance>.Instance :

Instance\ProjectItemInstance.cs (1)

273public ICollection<string> MetadataNames

Instance\ProjectPropertyGroupTaskInstance.cs (2)

91public ICollection<ProjectPropertyGroupTaskPropertyInstance> Properties 97(ICollection<ProjectPropertyGroupTaskPropertyInstance>)ReadOnlyEmptyCollection<ProjectPropertyGroupTaskPropertyInstance>.Instance :

Instance\ProjectTargetInstance.cs (1)

331public ICollection<ProjectTaskInstance> Tasks

Logging\BinaryLogger\BuildEventArgsWriter.cs (1)

832else if (items is ICollection<ITaskItem> genericList)

ObjectModelRemoting\DefinitionObjectsLinks\ProjectItemDefinitionLink.cs (1)

30public abstract ICollection<ProjectMetadata> Metadata { get; }

ObjectModelRemoting\DefinitionObjectsLinks\ProjectItemLink.cs (2)

36public abstract ICollection<ProjectMetadata> MetadataCollection { get; } 41public abstract ICollection<ProjectMetadata> DirectMetadata { get; }

ObjectModelRemoting\DefinitionObjectsLinks\ProjectLink.cs (10)

ObjectModelRemoting\ExternalProjectsProvider.cs (1)

21public abstract ICollection<Project> GetLoadedProjects(string filePath);

ReadOnlyCollection.cs (6)

81private ICollection<T> BackingCollection 85ICollection<T> backingCollection = _backing as ICollection<T>; 119if (!(_backing is ICollection<T>)) 134ICollection<T> backingCollection = _backing as ICollection<T>;

ReadOnlyEmptyDictionary.cs (2)

73public ICollection<K> Keys => 83public ICollection<V> Values =>

SolutionConfiguration.cs (1)

108public ICollection<XmlElement> ProjectConfigurations => _cachedProjectElements.Values;

TaskHostConfiguration.cs (9)

95private ICollection<string> _warningsAsErrors; 96private ICollection<string> _warningsNotAsErrors; 98private ICollection<string> _warningsAsMessages; 162ICollection<string> warningsAsErrors, 163ICollection<string> warningsNotAsErrors, 164ICollection<string> warningsAsMessages) 381public ICollection<string> WarningsAsErrors 390public ICollection<string> WarningsNotAsErrors 399public ICollection<string> WarningsAsMessages

WindowsFileSystem.cs (1)

118ICollection<string> result)

Microsoft.Build.Engine (2)

Items\BuildItem.cs (1)

1340ICollection<string> defaultedNames = itemDefinitionLibrary.GetDefaultedMetadataNames(name);

Items\ItemDefinitionLibrary.cs (1)

130internal ICollection<string> GetDefaultedMetadataNames(string itemType)

Microsoft.Build.Engine.OM.UnitTests (61)

Construction\ElementLocationPublic_Tests.cs (1)

131var values = new List<KeyValuePair<string, ElementLocation>>((ICollection<KeyValuePair<string, ElementLocation>>)property.GetValue(element, null));

Definition\ProjectItem_Tests.cs (6)

2212var items = project.GetItems("I"); 2226var metadata = item.Metadata; 2239var metadataElements = items.First().Xml.Metadata; 2272var items = project.GetItems("I"); 2286var metadata = item.Metadata; 2295var metadataElements = items.First().Xml.Metadata;

ObjectModelRemoting\Helpers\ViewValidation.construction.cs (8)

ObjectModelRemoting\Helpers\ViewValidation.evaluation.cs (3)

27private ProjectItem VerifyAfterAddSingleItem(ObjectType where, ICollection<ProjectItem> added, IEnumerable<KeyValuePair<string, string>> metadata) 68var realItems = this.Real.GetItemsByEvaluatedInclude(evaluatedInclude); 69var viewItems = this.View.GetItemsByEvaluatedInclude(evaluatedInclude);

ObjectModelRemoting\LinkedEvaluationReadOnly_Tests.cs (6)

68var viewItems = this.StdGroup.View.AllEvaluatedItems; 69var realItems = this.StdGroup.Real.AllEvaluatedItems; 88var viewProperties = this.StdGroup.View.Properties; 89var realProperties = this.StdGroup.Real.Properties; 98var viewMetadata = this.StdGroup.View.AllEvaluatedItemDefinitionMetadata; 99var realMetadata = this.StdGroup.Real.AllEvaluatedItemDefinitionMetadata;

ObjectModelRemoting\LinkedProjectCollection_Tests.cs (10)

41var loadedLocal = pcLocal.Collection.LoadedProjects; 42var loadedRemote = pcRemote.Collection.LoadedProjects; 84var loadedLocal = pcLocal.Collection.LoadedProjects; 85var loadedRemote0 = pcRemote0.Collection.LoadedProjects; 86var loadedRemote1 = pcRemote1.Collection.LoadedProjects; 94var loadedWithExternal = pcLocal.Collection.LoadedProjects; 97var prj0Coll = pcLocal.Collection.GetLoadedProjects(proj0Path); 101var prj1Coll = pcLocal.Collection.GetLoadedProjects(proj1Path); 106var prj2Coll = pcLocal.Collection.GetLoadedProjects(proj2Path); 115var prj3Coll = pcLocal.Collection.GetLoadedProjects(proj3Path);

ObjectModelRemoting\RemoteProjectsProviderMock\EvaluationLinkMocks\MockProjectItemDefinitionLink.cs (2)

23public ICollection<MockProjectMetadataLinkRemoter> Metadata => this.OwningCollection.ExportCollection<ProjectMetadata, MockProjectMetadataLinkRemoter>(this.Source.Metadata); 47public override ICollection<ProjectMetadata> Metadata

ObjectModelRemoting\RemoteProjectsProviderMock\EvaluationLinkMocks\MockProjectItemLink.cs (4)

25public ICollection<MockProjectMetadataLinkRemoter> MetadataCollection => this.OwningCollection.ExportCollection<ProjectMetadata, MockProjectMetadataLinkRemoter>(this.Source.Metadata); 26public ICollection<MockProjectMetadataLinkRemoter> DirectMetadata => this.OwningCollection.ExportCollection<ProjectMetadata, MockProjectMetadataLinkRemoter>(this.Source.DirectMetadata); 56public override ICollection<ProjectMetadata> MetadataCollection 58public override ICollection<ProjectMetadata> DirectMetadata

ObjectModelRemoting\RemoteProjectsProviderMock\EvaluationLinkMocks\MockProjectLink.cs (19)

ObjectModelRemoting\RemoteProjectsProviderMock\ExporterMock.cs (1)

340public override ICollection<Project> GetLoadedProjects(string filePath)

WindowsFileSystem.cs (1)

118ICollection<string> result)

Microsoft.Build.Engine.UnitTests (112)

BackEnd\IntrinsicTask_Tests.cs (47)

BackEnd\Lookup_Tests.cs (26)

BackEnd\MockLoggingService.cs (8)

51public ICollection<ILogger> Loggers 115public ICollection<LoggerDescription> LoggerDescriptions 126public ICollection<string> RegisteredLoggerTypeNames 137public ICollection<string> RegisteredSinkNames 291public void InitializeNodeLoggers(ICollection<LoggerDescription> loggerDescriptions, IBuildEventSink forwardingLoggerSink, int nodeId) 622public ICollection<string> GetWarningsAsErrors(BuildEventContext context) 627public ICollection<string> GetWarningsNotAsErrors(BuildEventContext context) 632public ICollection<string> GetWarningsAsMessages(BuildEventContext context)

BackEnd\TargetEntry_Tests.cs (13)

BackEnd\TranslationHelpers.cs (2)

55internal static bool CompareCollections<T>(ICollection<T> left, ICollection<T> right, IComparer<T> comparer)

Collections\OMcollections_tests.cs (1)

133ICollection<ProjectItemInstance> itemList = items["x"];

Definition\Project_Internal_Tests.cs (1)

256var c = project.ItemsIgnoringCondition;

Definition\ProjectEvaluationContext_Tests.cs (3)

523var actualGlobExpansion = project.GetItems("i"); 594var actualGlobExpansion = project.GetItems("i"); 654var actualGlobExpansion = project.GetItems("i");

Evaluation\Expander_Tests.cs (5)

4743ICollection<ProjectItemInstance> myDirectories = projectInstance.GetItems("MyDirectories"); 4787ICollection<ProjectItemInstance> myDirectories = projectInstance.GetItems("MyDirectories"); 4816ICollection<ProjectItemInstance> squiggles = projectInstance.GetItems("Squiggle"); 4863ICollection<ProjectItemInstance> squiggleItems = projectInstance.GetItems("Compile"); 4904ICollection<ProjectItemInstance> squiggleItems = projectInstance.GetItems("MyDirectory");

Evaluation\SdkResultEvaluation_Tests.cs (5)

81var itemsFromResolver = project.GetItems("ItemNameFromSdkResolver"); 223var items = project.GetItems("ItemsFromSdkResolverAfter"); 323var items = project.GetItems("ItemsFromSdkResolverAfter"); 402var itemsFromBody = project.GetItems("ItemsFromSdkResolverInProjectBody"); 454var itemsFromResolver = project.GetItems("ItemName");

WarningsAsMessagesAndErrors_Tests.cs (1)

257private string GetTestProject(bool? treatAllWarningsAsErrors = null, string warningsAsErrors = null, string warningsAsMessages = null, ICollection<KeyValuePair<string, string>> customProperties = null)

Microsoft.Build.Framework (80)

BinaryTranslator.cs (4)

362public void Translate<T, L>(ref ICollection<T> collection, ObjectTranslator<T> objectTranslator, NodePacketCollectionCreator<L> collectionFactory) where L : ICollection<T> 1051public void Translate<T, L>(ref ICollection<T> collection, ObjectTranslator<T> objectTranslator, NodePacketCollectionCreator<L> collectionFactory) where L : ICollection<T>

ICollectionCalls`1.cs (2)

10/// Provides static methods to invoke <see cref="ICollection{T}"/> members on value types that explicitly implement 21where TCollection : ICollection<T>

ICollectionDebugView`1.cs (2)

19private readonly ICollection<T> _collection; 21public ICollectionDebugView(ICollection<T> collection)

IDictionaryDebugView`2.cs (4)

41private readonly ICollection<TKey> _collection; 43public DictionaryKeyCollectionDebugView(ICollection<TKey> collection) 62private readonly ICollection<TValue> _collection; 64public DictionaryValueCollectionDebugView(ICollection<TValue> collection)

ImmutableSegmentedDictionary`2.cs (9)

ImmutableSegmentedDictionary`2+Builder.cs (5)

66ICollection<TKey> IDictionary<TKey, TValue>.Keys => Keys; 68ICollection<TValue> IDictionary<TKey, TValue>.Values => Values; 70bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => false; 222void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) 223=> ((ICollection<KeyValuePair<TKey, TValue>>)ReadOnlyDictionary).CopyTo(array, arrayIndex);

ImmutableSegmentedDictionary`2+Builder+KeyCollection.cs (2)

28bool ICollection<TKey>.IsReadOnly => false; 34void ICollection<TKey>.Add(TKey item)

ImmutableSegmentedDictionary`2+Builder+ValueCollection.cs (3)

28bool ICollection<TValue>.IsReadOnly => false; 34void ICollection<TValue>.Add(TValue item) 49bool ICollection<TValue>.Remove(TValue item)

ImmutableSegmentedDictionary`2+KeyCollection.cs (5)

24bool ICollection<TKey>.IsReadOnly => true; 42void ICollection<TKey>.CopyTo(TKey[] array, int arrayIndex) 48void ICollection<TKey>.Add(TKey item) 51void ICollection<TKey>.Clear() 54bool ICollection<TKey>.Remove(TKey item)

ImmutableSegmentedDictionary`2+ValueCollection.cs (5)

24bool ICollection<TValue>.IsReadOnly => true; 42void ICollection<TValue>.CopyTo(TValue[] array, int arrayIndex) 48void ICollection<TValue>.Add(TValue item) 51void ICollection<TValue>.Clear() 54bool ICollection<TValue>.Remove(TValue item)

ImmutableSegmentedList`1.cs (5)

88bool ICollection<T>.IsReadOnly => true; 163if (items is ICollection<T> { Count: 0 }) 649void ICollection<T>.Add(T item) 652void ICollection<T>.Clear() 655bool ICollection<T>.Remove(T item)

ImmutableSegmentedList`1+Builder.cs (1)

26bool ICollection<T>.IsReadOnly => ICollectionCalls<T>.IsReadOnly(ref _builder);

ImmutableSegmentedList`1+ValueBuilder.cs (1)

37bool ICollection<T>.IsReadOnly => false;

ITranslator.cs (2)

211void Translate<T, L>(ref ICollection<T> collection, ObjectTranslator<T> objectTranslator, NodePacketCollectionCreator<L> collectionFactory) where L : ICollection<T>;

ReuseableStringBuilder.cs (1)

143public ReuseableStringBuilder AppendSeparated(char separator, ICollection<string> strings)

SegmentedArray`1.cs (8)

127int ICollection<T>.Count => Length; 164void ICollection<T>.CopyTo(T[] array, int arrayIndex) 168ICollection<T> collection = _items[i]; 197void ICollection<T>.Add(T value) 212void ICollection<T>.Clear() 229bool ICollection<T>.Contains(T value) 231foreach (ICollection<T> collection in _items) 285bool ICollection<T>.Remove(T value)

SegmentedDictionary`2.cs (18)

144: this((collection as ICollection<KeyValuePair<TKey, TValue>>)?.Count ?? 0, comparer) 169ICollection<TKey> IDictionary<TKey, TValue>.Keys => Keys; 175ICollection<TValue> IDictionary<TKey, TValue>.Values => Values; 205void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> keyValuePair) 208bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> keyValuePair) 219bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> keyValuePair) 840bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => false; 842void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int index) 1303bool ICollection<TKey>.IsReadOnly => true; 1305void ICollection<TKey>.Add(TKey item) 1308void ICollection<TKey>.Clear() 1311bool ICollection<TKey>.Contains(TKey item) 1314bool ICollection<TKey>.Remove(TKey item) 1503bool ICollection<TValue>.IsReadOnly => true; 1505void ICollection<TValue>.Add(TValue item) 1508bool ICollection<TValue>.Remove(TValue item) 1514void ICollection<TValue>.Clear() 1517bool ICollection<TValue>.Contains(TValue item)

SegmentedList`1.cs (3)

83if (collection is ICollection<T> c) 157bool ICollection<T>.IsReadOnly => false; 753if (collection is ICollection<T> c)

Microsoft.Build.Tasks.Core (20)

AssemblyDependency\Reference.cs (1)

189internal ICollection<ITaskItem> GetSourceItems()

AssemblyDependency\ReferenceTable.cs (3)

1415ICollection<ITaskItem> dependees = assemblyReference.GetSourceItems(); 1488ICollection<ITaskItem> dependees = assemblyReference.GetSourceItems(); 2702ICollection<ITaskItem> sourceItems = reference.GetSourceItems();

AssemblyDependency\ResolveAssemblyReference.cs (1)

1868ICollection<ITaskItem> dependees = reference.GetSourceItems();

CopyOnWriteDictionary.cs (2)

114public ICollection<string> Keys => ((IDictionary<string, V>)_backing).Keys; 119public ICollection<V> Values => ((IDictionary<string, V>)_backing).Values;

ReadOnlyCollection.cs (6)

ReadOnlyEmptyDictionary.cs (2)

73public ICollection<K> Keys => 83public ICollection<V> Values =>

RoslynCodeTaskFactory\RoslynCodeTaskFactory.cs (3)

205internal static string GetSourceCode(RoslynCodeTaskFactoryTaskInfo taskInfo, ICollection<TaskPropertyInfo> parameters) 276/// <param name="parameters">An <see cref="ICollection{TaskPropertyInfo}"/> containing parameters for the task.</param> 293internal static bool TryLoadTaskBody(TaskLoggingHelper log, string taskName, string taskBody, ICollection<TaskPropertyInfo> parameters, out RoslynCodeTaskFactoryTaskInfo taskInfo)

SolutionConfiguration.cs (1)

108public ICollection<XmlElement> ProjectConfigurations => _cachedProjectElements.Values;

WindowsFileSystem.cs (1)

118ICollection<string> result)

Microsoft.Build.Tasks.UnitTests (3)

RoslynCodeTaskFactory_Tests.cs (3)

233ICollection<TaskPropertyInfo> parameters = new List<TaskPropertyInfo> 342ICollection<TaskPropertyInfo> parameters = new List<TaskPropertyInfo> 789ICollection<TaskPropertyInfo> parameters = null,

Microsoft.Build.UnitTests.Shared (3)

ObjectModelHelpers.cs (3)

247public static void AssertItems(string[] expectedItems, ICollection<ProjectItem> items, Dictionary<string, string> expectedDirectMetadata = null, bool normalizeSlashes = false) 1247public static void AssertCollectionsValueEqual<T>(ICollection<T> one, ICollection<T> two)

Microsoft.Build.Utilities.Core (10)

ApiContract.cs (1)

46internal static void ReadContractsElement(XmlElement element, ICollection<ApiContract> apiContracts)

CopyOnWriteDictionary.cs (2)

114public ICollection<string> Keys => ((IDictionary<string, V>)_backing).Keys; 119public ICollection<V> Values => ((IDictionary<string, V>)_backing).Values;

ExtensionSDK.cs (1)

139public ICollection<ApiContract> ApiContracts => Manifest.ApiContracts;

PlatformManifest.cs (2)

56public ICollection<DependentPlatform> DependentPlatforms { get; private set; } 63public ICollection<ApiContract> ApiContracts { get; private set; }

ReadOnlyEmptyDictionary.cs (2)

73public ICollection<K> Keys => 83public ICollection<V> Values =>

SDKManifest.cs (1)

241internal ICollection<ApiContract> ApiContracts { get; private set; }

WindowsFileSystem.cs (1)

118ICollection<string> result)

Microsoft.Cci.Extensions (14)

Experimental\APIClosureTypeReferenceVisitor.cs (4)

17private readonly ICollection<ITypeReference> _typeReferences; 18private readonly ICollection<IAssemblyReference> _assemblyReferences; 26public ICollection<ITypeReference> TypeReferences { get { return _typeReferences; } } 28public ICollection<IAssemblyReference> AssemblyReferences { get { return _assemblyReferences; } }

Experimental\TypeReferenceSearcher.cs (2)

57private readonly ICollection<TypeReferenceDependency> _dependencies; 64public ICollection<TypeReferenceDependency> Dependencies { get { return _dependencies; } }

Experimental\TypeReferenceVisitor.cs (4)

HostEnvironment.cs (1)

54public ICollection<UnresolvedReference<IUnit, AssemblyIdentity>> UnresolvedIdentities { get { return _unresolvedIdentities; } }

TypeDependencies.cs (3)

15private ICollection<ITypeReference> _publicDependents; 16private ICollection<ITypeReference> _dependents; 17private ICollection<IMethodReference> _methodDependents;

Microsoft.CSharp (2)

Microsoft\CSharp\RuntimeBinder\Semantics\Types\AggregateType.cs (1)

168|| genType == typeof(ICollection<>)

Microsoft\CSharp\RuntimeBinder\Semantics\Types\PredefinedTypes.cs (1)

156new PredefinedTypeInfo(PredefinedType.PT_G_ICOLLECTION, typeof(ICollection<>), "System.Collections.Generic.ICollection`1"),

Microsoft.DotNet.Build.Tasks.Packaging (3)

Extensions.cs (1)

162public static void AddRangeToMember<T, TItem>(this T target, Expression<Func<T, ICollection<TItem>>> memberLamda, IEnumerable<TItem> value)

HarvestPackage.cs (2)

540private static bool ProbePath(string path, ICollection<string> pathsIncluded) 555private static bool ProbePath<T>(string path, IDictionary<string, T> pathsIncluded, ICollection<string> pathsNotIncluded, out T result)

Microsoft.DotNet.PackageTesting (1)

VerifyClosure.cs (1)

396private static bool TryAddNode(ICollection<string> existing, XElement parent, string id, bool isNative = false)

Microsoft.DotNet.SharedFramework.Sdk (1)

src\Microsoft.DotNet.PackageTesting\VerifyClosure.cs (1)

396private static bool TryAddNode(ICollection<string> existing, XElement parent, string id, bool isNative = false)

Microsoft.DotNet.SignCheckLibrary (3)

Verification\Jar\JarSignatureFile.cs (1)

78public ICollection<Timestamp> Timestamps

Verification\SignatureVerificationResult.cs (2)

137public ICollection<SignatureVerificationResult> NestedResults 157public ICollection<Timestamp> Timestamps

Microsoft.Extensions.Caching.Hybrid (4)

Runtime\HybridCache.cs (4)

83null or ICollection<string> { Count: 0 } => default, 84ICollection<string> { Count: 1 } => RemoveByTagAsync(keys.Single(), token), 108null or ICollection<string> { Count: 0 } => default, 109ICollection<string> { Count: 1 } => RemoveByTagAsync(tags.Single(), token),

Microsoft.Extensions.Caching.Memory (1)

MemoryCache.cs (1)

665private ICollection<KeyValuePair<object, CacheEntry>> EntriesCollection => _entries;

Microsoft.Extensions.Configuration (2)

ConfigurationManager.cs (2)

283public ICollection<string> Keys => _properties.Keys; 285public ICollection<object> Values => _properties.Values;

Microsoft.Extensions.Configuration.Binder (2)

ConfigurationBinder.cs (2)

396(interfaceGenericType == typeof(ICollection<>) || interfaceGenericType == typeof(IList<>))) 420Type? collectionInterface = FindOpenGenericInterface(typeof(ICollection<>), type);

Microsoft.Extensions.DependencyInjection (2)

ServiceLookup\CallSiteFactory.cs (1)

24public CallSiteFactory(ICollection<ServiceDescriptor> descriptors)

ServiceProvider.cs (1)

50internal ServiceProvider(ICollection<ServiceDescriptor> serviceDescriptors, ServiceProviderOptions options)

Microsoft.Extensions.DependencyInjection.Abstractions (1)

ServiceCollection.cs (1)

73void ICollection<ServiceDescriptor>.Add(ServiceDescriptor item)

Microsoft.Extensions.Diagnostics (1)

src\libraries\Common\src\System\Diagnostics\DiagnosticsHelper.cs (1)

38if (tags2 is ICollection<KeyValuePair<string, object?>> tagsCol)

Microsoft.Extensions.Diagnostics.HealthChecks (2)

DefaultHealthCheckService.cs (1)

42var registrations = _options.Value.Registrations;

HealthCheckServiceOptions.cs (1)

16public ICollection<HealthCheckRegistration> Registrations { get; } = new List<HealthCheckRegistration>();

Microsoft.Extensions.Options.SourceGeneration (2)

Emitter.cs (1)

79/// <see cref="System.ComponentModel.DataAnnotations.Validator.TryValidateValue(object, ValidationContext, ICollection{ValidationResult}, IEnumerable{ValidationAttribute})"/> is nullable annotated.

TypeDeclarationSyntaxReceiver.cs (1)

20public ICollection<TypeDeclarationSyntax> TypeDeclarations { get; } = new List<TypeDeclarationSyntax>();

Microsoft.Extensions.Primitives (6)

StringValues.cs (6)

114bool ICollection<string?>.IsReadOnly => true; 339bool ICollection<string?>.Contains(string? item) 352void ICollection<string?>.CopyTo(string?[] array, int arrayIndex) 388void ICollection<string?>.Add(string? item) => throw new NotSupportedException(); 392bool ICollection<string?>.Remove(string? item) => throw new NotSupportedException(); 396void ICollection<string?>.Clear() => throw new NotSupportedException();

Microsoft.Interop.SourceGeneration (8)

Marshalling\MarshallerHelpers.cs (1)

104ICollection<T> elements,

ValueEqualityImmutableDictionary.cs (7)

47public ICollection<T> Keys => ((IDictionary<T, U>)Map).Keys; 48public ICollection Values => ((IDictionary<T, U>)Map).Values; 50public bool IsReadOnly => ((ICollection<KeyValuePair<T, U>>)Map).IsReadOnly; 53public void CopyTo(KeyValuePair<T, U>[] array, int arrayIndex) => ((ICollection<KeyValuePair<T, U>>)Map).CopyTo(array, arrayIndex); 56public bool Remove(KeyValuePair<T, U> item) => ((ICollection<KeyValuePair<T, U>>)Map).Remove(item); 60public void Add(KeyValuePair<T, U> item) => ((ICollection<KeyValuePair<T, U>>)Map).Add(item); 61public void Clear() => ((ICollection<KeyValuePair<T, U>>)Map).Clear();

Microsoft.Net.Http.Headers (13)

CacheControlHeaderValue.cs (5)

88private ICollection<StringSegment>? _noCacheHeaders; 99private ICollection<StringSegment>? _privateHeaders; 129public ICollection<StringSegment> NoCacheHeaders 275public ICollection<StringSegment> PrivateHeaders 712ref ICollection<StringSegment>? destination)

HeaderUtilities.cs (4)

84internal static bool AreEqualCollections<T>(ICollection<T>? x, ICollection<T>? y) 89internal static bool AreEqualCollections<T>(ICollection<T>? x, ICollection<T>? y, IEqualityComparer<T>? comparer)

ObjectCollection.cs (1)

56public bool IsReadOnly => ((ICollection<T>)this).IsReadOnly;

RangeHeaderValue.cs (2)

24private ICollection<RangeItemHeaderValue>? _ranges; 63public ICollection<RangeItemHeaderValue> Ranges

RangeItemHeaderValue.cs (1)

106ICollection<RangeItemHeaderValue> rangeCollection)

MonoTargetsTasks (1)

EmitBundleTask\EmitBundleBase.cs (1)

301private static void GenerateBundledResourcePreallocationAndRegistration(string resourceSymbols, string bundleRegistrationFunctionName, ICollection<(string resourceType, string registeredName, string resourceName, string resourceDataSymbol, string culture, string? resourceSymbolName)> files, StreamWriter outputUtf8Writer)

MSBuild (17)

CopyOnWriteDictionary.cs (2)

114public ICollection<string> Keys => ((IDictionary<string, V>)_backing).Keys; 119public ICollection<V> Values => ((IDictionary<string, V>)_backing).Values;

OutOfProcTaskHostNode.cs (3)

290private ICollection<string> WarningsAsErrors { get; set; } 292private ICollection<string> WarningsNotAsErrors { get; set; } 294private ICollection<string> WarningsAsMessages { get; set; }

ReadOnlyEmptyDictionary.cs (2)

73public ICollection<K> Keys => 83public ICollection<V> Values =>

TaskHostConfiguration.cs (9)

WindowsFileSystem.cs (1)

118ICollection<string> result)

MSBuildTaskHost (28)

BinaryTranslator.cs (4)

CopyOnWriteDictionary.cs (2)

114public ICollection<string> Keys => ((IDictionary<string, V>)_backing).Keys; 119public ICollection<V> Values => ((IDictionary<string, V>)_backing).Values;

Immutable\ImmutableDictionary.cs (6)

41public ICollection<K> Keys => _backing.Keys; 42public ICollection<V> Values => _backing.Values; 92void ICollection<KeyValuePair<K, V>>.CopyTo(KeyValuePair<K, V>[] array, int arrayIndex) 267void ICollection<KeyValuePair<K, V>>.Add(KeyValuePair<K, V> item) 272void ICollection<KeyValuePair<K, V>>.Clear() 277bool ICollection<KeyValuePair<K, V>>.Remove(KeyValuePair<K, V> item)

ITranslator.cs (2)

211void Translate<T, L>(ref ICollection<T> collection, ObjectTranslator<T> objectTranslator, NodePacketCollectionCreator<L> collectionFactory) where L : ICollection<T>;

OutOfProcTaskHostNode.cs (3)

ReadOnlyEmptyDictionary.cs (2)

73public ICollection<K> Keys => 83public ICollection<V> Values =>

TaskHostConfiguration.cs (9)

mscorlib (1)

src\libraries\shims\mscorlib\ref\mscorlib.cs (1)

90[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Collections.Generic.ICollection<>))]

netstandard (1)

netstandard.cs (1)

112[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Collections.Generic.ICollection<>))]

PresentationCore (131)

MS\Internal\FontCache\FontFaceLayoutInfo.cs (2)

635public ICollection<int> Keys 686public ICollection<ushort> Values

MS\Internal\FontCache\FontSourceCollection.cs (1)

125ICollection<string> files;

MS\Internal\FontFace\CompositeFontInfo.cs (1)

364internal ICollection<XmlLanguage> FamilyMapLanguages

MS\Internal\FontFace\FontDriver.cs (1)

258internal byte[] ComputeFontSubset(ICollection<ushort> glyphs)

MS\Internal\FontFace\IFontFamily.cs (1)

109ICollection<Typeface> GetTypefaces(FontFamilyIdentifier familyIdentifier);

MS\Internal\FontFace\PhysicalFontFamily.cs (1)

445ICollection<Typeface> IFontFamily.GetTypefaces(FontFamilyIdentifier familyIdentifier)

MS\Internal\Ink\GestureRecognizer\NativeRecognizer.cs (2)

214ICollection<ApplicationGesture> collection = applicationGestures as ICollection<ApplicationGesture>;

MS\Internal\Shaping\CompositeFontFamily.cs (1)

266ICollection<Typeface> IFontFamily.GetTypefaces(FontFamilyIdentifier familyIdentifier)

MS\Internal\Shaping\TypefaceMap.cs (1)

138SpanVector itemSpans = new SpanVector(null, new FrugalStructList((ICollection)spans));

MS\Internal\TextFormatting\LineServicesCallbacks.cs (2)

3504private ICollection<IndexedGlyphRun> _indexedGlyphRuns; 3515internal ICollection<IndexedGlyphRun> IndexedGlyphRuns

System\Windows\FreezableCollection.cs (4)

400bool ICollection<T>.IsReadOnly 437return ((ICollection<T>)this).IsReadOnly; 685ICollection<T> enumerableAsICollectionT = enumerable as ICollection<T>;

System\Windows\Generated\TextDecorationCollection.cs (4)

301bool ICollection<TextDecoration>.IsReadOnly 338return ((ICollection<TextDecoration>)this).IsReadOnly; 909ICollection<TextDecoration> icollectionOfT = collection as ICollection<TextDecoration>;

System\Windows\Ink\Stroke.cs (2)

1163ICollection<Point> icol = ienum as ICollection<Point>;

System\Windows\Ink\StrokeCollection.cs (1)

891bool ICollection<Stroke>.IsReadOnly

System\Windows\Input\ManipulationLogic.cs (2)

360internal void ReportFrame(ICollection<IManipulator> manipulators) 521private void UpdateManipulators(ICollection<IManipulator> updatedManipulators)

System\Windows\Media\Animation\Generated\TimelineCollection.cs (4)

311bool ICollection<Timeline>.IsReadOnly 348return ((ICollection<Timeline>)this).IsReadOnly; 928ICollection<Timeline> icollectionOfT = collection as ICollection<Timeline>;

System\Windows\Media\CharacterMetricsDictionary.cs (2)

269public ICollection<int> Keys 278public ICollection<CharacterMetrics> Values

System\Windows\Media\CultureSpecificStringDictionary.cs (2)

235public ICollection<XmlLanguage> Keys 244public ICollection<string> Values

System\Windows\Media\Effects\Generated\BitmapEffectCollection.cs (4)

307bool ICollection<BitmapEffect>.IsReadOnly 344return ((ICollection<BitmapEffect>)this).IsReadOnly; 915ICollection<BitmapEffect> icollectionOfT = collection as ICollection<BitmapEffect>;

System\Windows\Media\FamilyTypefaceCollection.cs (2)

28private ICollection<Typeface> _innerList; 45internal FamilyTypefaceCollection(ICollection<Typeface> innerList)

System\Windows\Media\FontEmbeddingManager.cs (2)

98public ICollection<Uri> GlyphTypefaceUris 115public ICollection<ushort> GetUsedGlyphs(Uri glyphTypeface)

System\Windows\Media\FontFamily.cs (1)

266public ICollection<Typeface> GetTypefaces()

System\Windows\Media\Fonts.cs (11)

54public static ICollection<FontFamily> GetFontFamilies(string location) 71public static ICollection<FontFamily> GetFontFamilies(Uri baseUri) 94public static ICollection<FontFamily> GetFontFamilies(Uri baseUri, string location) 147public static ICollection<Typeface> GetTypefaces(string location) 164public static ICollection<Typeface> GetTypefaces(Uri baseUri) 186public static ICollection<Typeface> GetTypefaces(Uri baseUri, string location) 205public static ICollection<FontFamily> SystemFontFamilies 217public static ICollection<Typeface> SystemTypefaces 245private static ICollection<FontFamily> CreateFamilyCollection( 273private static ICollection<FontFamily> CreateDefaultFamilyCollection() 407private static readonly ICollection<FontFamily> _defaultFontCollection = CreateDefaultFamilyCollection();

System\Windows\Media\Generated\DoubleCollection.cs (4)

260bool ICollection<double>.IsReadOnly 297return ((ICollection<double>)this).IsReadOnly; 937ICollection<double> icollectionOfT = collection as ICollection<double>;

System\Windows\Media\Generated\DrawingCollection.cs (4)

323bool ICollection<Drawing>.IsReadOnly 360return ((ICollection<Drawing>)this).IsReadOnly; 958ICollection<Drawing> icollectionOfT = collection as ICollection<Drawing>;

System\Windows\Media\Generated\GeneralTransformCollection.cs (4)

309bool ICollection<GeneralTransform>.IsReadOnly 346return ((ICollection<GeneralTransform>)this).IsReadOnly; 917ICollection<GeneralTransform> icollectionOfT = collection as ICollection<GeneralTransform>;

System\Windows\Media\Generated\GeometryCollection.cs (4)

323bool ICollection<Geometry>.IsReadOnly 360return ((ICollection<Geometry>)this).IsReadOnly; 958ICollection<Geometry> icollectionOfT = collection as ICollection<Geometry>;

System\Windows\Media\Generated\GradientStopCollection.cs (4)

309bool ICollection<GradientStop>.IsReadOnly 346return ((ICollection<GradientStop>)this).IsReadOnly; 1020ICollection<GradientStop> icollectionOfT = collection as ICollection<GradientStop>;

System\Windows\Media\Generated\Int32Collection.cs (4)

260bool ICollection<int>.IsReadOnly 297return ((ICollection<int>)this).IsReadOnly; 937ICollection<int> icollectionOfT = collection as ICollection<int>;

System\Windows\Media\Generated\PathFigureCollection.cs (4)

310bool ICollection<PathFigure>.IsReadOnly 347return ((ICollection<PathFigure>)this).IsReadOnly; 1007ICollection<PathFigure> icollectionOfT = collection as ICollection<PathFigure>;

System\Windows\Media\Generated\PathSegmentCollection.cs (4)

309bool ICollection<PathSegment>.IsReadOnly 346return ((ICollection<PathSegment>)this).IsReadOnly; 917ICollection<PathSegment> icollectionOfT = collection as ICollection<PathSegment>;

System\Windows\Media\Generated\PointCollection.cs (4)

260bool ICollection<Point>.IsReadOnly 297return ((ICollection<Point>)this).IsReadOnly; 939ICollection<Point> icollectionOfT = collection as ICollection<Point>;

System\Windows\Media\Generated\TextEffectCollection.cs (4)

309bool ICollection<TextEffect>.IsReadOnly 346return ((ICollection<TextEffect>)this).IsReadOnly; 917ICollection<TextEffect> icollectionOfT = collection as ICollection<TextEffect>;

System\Windows\Media\Generated\TransformCollection.cs (4)

323bool ICollection<Transform>.IsReadOnly 360return ((ICollection<Transform>)this).IsReadOnly; 958ICollection<Transform> icollectionOfT = collection as ICollection<Transform>;

System\Windows\Media\Generated\VectorCollection.cs (4)

260bool ICollection<Vector>.IsReadOnly 297return ((ICollection<Vector>)this).IsReadOnly; 939ICollection<Vector> icollectionOfT = collection as ICollection<Vector>;

System\Windows\Media\GlyphTypeface.cs (3)

231public byte[] ComputeSubset(ICollection<ushort> glyphs) 1758public ICollection<ushort> Keys 1782public ICollection<double> Values

System\Windows\Media\textformatting\TextFormatterContext.cs (1)

257internal ICollection<IndexedGlyphRun> IndexedGlyphRuns

System\Windows\Media3D\Generated\GeneralTransform3DCollection.cs (4)

305bool ICollection<GeneralTransform3D>.IsReadOnly 342return ((ICollection<GeneralTransform3D>)this).IsReadOnly; 913ICollection<GeneralTransform3D> icollectionOfT = collection as ICollection<GeneralTransform3D>;

System\Windows\Media3D\Generated\MaterialCollection.cs (4)

319bool ICollection<Material>.IsReadOnly 356return ((ICollection<Material>)this).IsReadOnly; 954ICollection<Material> icollectionOfT = collection as ICollection<Material>;

System\Windows\Media3D\Generated\Model3DCollection.cs (4)

319bool ICollection<Model3D>.IsReadOnly 356return ((ICollection<Model3D>)this).IsReadOnly; 954ICollection<Model3D> icollectionOfT = collection as ICollection<Model3D>;

System\Windows\Media3D\Generated\Point3DCollection.cs (4)

256bool ICollection<Point3D>.IsReadOnly 293return ((ICollection<Point3D>)this).IsReadOnly; 936ICollection<Point3D> icollectionOfT = collection as ICollection<Point3D>;

System\Windows\Media3D\Generated\Transform3DCollection.cs (4)

319bool ICollection<Transform3D>.IsReadOnly 356return ((ICollection<Transform3D>)this).IsReadOnly; 954ICollection<Transform3D> icollectionOfT = collection as ICollection<Transform3D>;

System\Windows\Media3D\Generated\Vector3DCollection.cs (4)

256bool ICollection<Vector3D>.IsReadOnly 293return ((ICollection<Vector3D>)this).IsReadOnly; 936ICollection<Vector3D> icollectionOfT = collection as ICollection<Vector3D>;

System\Windows\Media3D\Visual3DCollection.cs (1)

306bool ICollection<Visual3D>.IsReadOnly

PresentationFramework (44)

MS\Internal\Annotations\Component\HighlightComponent.cs (1)

480ICollection<AnnotationResource> cargos = annot.Cargos;

MS\Internal\Annotations\ObservableDictionary.cs (10)

MS\Internal\Annotations\TextAnchor.cs (5)

191internal bool IsOverlapping(ICollection<TextSegment> textSegments) 281internal static TextAnchor TrimToRelativeComplement(TextAnchor anchor, ICollection<TextSegment> textSegments) 383internal static TextAnchor TrimToIntersectionWith(TextAnchor anchor, ICollection<TextSegment> textSegments) 593private static ICollection<TextSegment> SortTextSegments(ICollection<TextSegment> textSegments, bool excludeZeroLength)

MS\Internal\Data\LiveShapingList.cs (1)

720ICollection<DependencyProperty> usedDPs = this.Values;

MS\Internal\Documents\ContentElementCollection.cs (1)

551/// <see cref="ICollection<T>.IsReadOnly"/>

MS\Internal\ListOfObject.cs (7)

57void ICollection<object>.Add(object item) 62void ICollection<object>.Clear() 67bool ICollection<object>.Contains(object item) 72void ICollection<object>.CopyTo(object[] array, int arrayIndex) 77int ICollection<object>.Count 82bool ICollection<object>.IsReadOnly 87bool ICollection<object>.Remove(object item)

MS\Internal\WeakDictionary.cs (2)

203public ICollection<TKey> Keys 236public ICollection<TValue> Values

System\Windows\Annotations\LocatorPart.cs (1)

399foreach (KeyValuePair<string, string> k_v in ((ICollection<KeyValuePair<string, string>>)this.NameValuePairs))

System\Windows\Controls\CustomDictionarySources.cs (8)

160void ICollection<Uri>.Add(Uri item) 174void ICollection<Uri>.Clear() 183bool ICollection<Uri>.Contains(Uri item) 188void ICollection<Uri>.CopyTo(Uri[] array, int arrayIndex) 193int ICollection<Uri>.Count 201bool ICollection<Uri>.IsReadOnly 205return ((ICollection<Uri>)_uriList).IsReadOnly; 209bool ICollection<Uri>.Remove(Uri item)

System\Windows\Controls\TextChangedEventArgs.cs (3)

71public TextChangedEventArgs(RoutedEvent id, UndoAction action, ICollection<TextChange> changes) : base() 136public ICollection<TextChange> Changes 163private readonly ICollection<TextChange> _changes;

System\Windows\Documents\FixedDocument.cs (2)

1162ICollection<FixedPage> newHighlightPages = _highlights.Keys as ICollection<FixedPage>;

System\Windows\Documents\TableColumnCollection.cs (1)

369/// <see cref="ICollection<T>.IsReadOnly"/>

System\Windows\Markup\Baml2006\Baml2006SchemaContext.cs (1)

55public override ICollection<XamlType> GetAllXamlTypes(string xamlNamespace)

System\Windows\Markup\Baml2006\WpfXamlType.cs (1)

506if (typeof(ICollection<System.Windows.Data.XmlNamespaceMapping>).IsAssignableFrom(UnderlyingType)

PresentationUI (4)

MS\Internal\Documents\DigitalSignatureProvider.cs (1)

412ICollection<XpsSignatureDefinition> documentSignatureDefinitionList =

MS\Internal\Documents\RightsManagementProvider.cs (3)

666ICollection<ContentGrant> licenseGrants = 1343private ICollection<ContentGrant> GetGrantsFromUnsignedLicense( 1346ICollection<ContentGrant> grants = null;

ReachFramework (13)

packaging\XpsDigitalSignature.cs (2)

318ICollection<Uri> containingCollection, 319ICollection<Uri> containedCollection

Packaging\XpsFixedDocumentReaderWriter.cs (2)

97ICollection<XpsSignatureDefinition> 356ICollection<XpsSignatureDefinition>

Packaging\XpsFixedPageReaderWriter.cs (8)

162ICollection<XpsFont> 168ICollection<XpsColorContext> 174ICollection<XpsResourceDictionary> 180ICollection<XpsImage> 638public ICollection<XpsFont> 651public ICollection<XpsColorContext> 665public ICollection<XpsResourceDictionary> 679public ICollection<XpsImage>

Serialization\XpsFontSubsetter.cs (1)

596ICollection<ushort> glyphs,

Sockets.BindTests (3)

src\Servers\Kestrel\test\BindTests\AddressRegistrationTests.cs (3)

632var serverAddresses = host.Services.GetRequiredService<IServer>().Features.Get<IServerAddressesFeature>().Addresses; 677var serverAddresses = host.Services.GetRequiredService<IServer>().Features.Get<IServerAddressesFeature>().Addresses; 717var serverAddresses = host.Services.GetRequiredService<IServer>().Features.Get<IServerAddressesFeature>().Addresses;

StartRequestDelegateUrlApp (1)

Program.cs (1)

30var addresses = host.ServerFeatures.Get<IServerAddressesFeature>().Addresses;

StartRouteBuilderUrlApp (1)

Program.cs (1)

31var addresses = host.ServerFeatures.Get<IServerAddressesFeature>().Addresses;

StartWithIApplicationBuilderUrlApp (1)

Program.cs (1)

34var addresses = host.ServerFeatures.Get<IServerAddressesFeature>().Addresses;

System.Collections (38)

src\libraries\Common\src\System\Collections\Generic\EnumerableHelpers.cs (1)

24if (source is ICollection<T> ic)

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ICollectionDebugView.cs (2)

10private readonly ICollection<T> _collection; 12public ICollectionDebugView(ICollection<T> collection)

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\IDictionaryDebugView.cs (4)

38private readonly ICollection<TKey> _collection; 40public DictionaryKeyCollectionDebugView(ICollection<TKey> collection) 61private readonly ICollection<TValue> _collection; 63public DictionaryValueCollectionDebugView(ICollection<TValue> collection)

System\Collections\Generic\LinkedList.cs (2)

64bool ICollection<T>.IsReadOnly 69void ICollection<T>.Add(T value)

System\Collections\Generic\PriorityQueue.cs (3)

402var collection = items as ICollection<(TElement Element, TPriority Priority)>; 465if (elements is ICollection<TElement> collection &&

System\Collections\Generic\SortedDictionary.cs (15)

59void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> keyValuePair) 64bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> keyValuePair) 82bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> keyValuePair) 98bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly 161ICollection<TKey> IDictionary<TKey, TValue>.Keys 179ICollection<TValue> IDictionary<TKey, TValue>.Values 600bool ICollection<TKey>.IsReadOnly 605void ICollection<TKey>.Add(TKey item) 610void ICollection<TKey>.Clear() 620bool ICollection<TKey>.Remove(TKey item) 761bool ICollection<TValue>.IsReadOnly 766void ICollection<TValue>.Add(TValue item) 771void ICollection<TValue>.Clear() 776bool ICollection<TValue>.Contains(TValue item) 781bool ICollection<TValue>.Remove(TValue item)

System\Collections\Generic\SortedList.cs (7)

System\Collections\Generic\SortedSet.cs (3)

277bool ICollection<T>.IsReadOnly => false; 301void ICollection<T>.Add(T item) => Add(item); 1326if (other is ICollection<T> c && c.Count == 0)

System\Collections\Generic\Stack.cs (1)

65/// <inheritdoc cref="ICollection{T}"/>

System.Collections.Concurrent (14)

System\Collections\Concurrent\ConcurrentDictionary.cs (14)

System.Collections.Immutable (171)

System\Collections\Frozen\FrozenDictionary.cs (7)

282ICollection<TKey> IDictionary<TKey, TValue>.Keys => 303ICollection<TValue> IDictionary<TKey, TValue>.Values => 408bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => true; 496bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item) => 546void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item) => throw new NotSupportedException(); 555bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item) => throw new NotSupportedException(); 561void ICollection<KeyValuePair<TKey, TValue>>.Clear() => throw new NotSupportedException();

System\Collections\Frozen\FrozenSet.cs (4)

260bool ICollection<T>.IsReadOnly => true; 329void ICollection<T>.Add(T item) => throw new NotSupportedException(); 332void ICollection<T>.Clear() => throw new NotSupportedException(); 335bool ICollection<T>.Remove(T item) => throw new NotSupportedException();

System\Collections\Frozen\FrozenSetInternalBase.cs (3)

35if (other is ICollection<T> otherAsCollection) 62if (other is ICollection<T> otherAsCollection) 106if (other is ICollection<T> otherAsCollection)

System\Collections\Frozen\Int32\Int32FrozenDictionary.cs (1)

27((ICollection<KeyValuePair<int, TValue>>)source).CopyTo(entries, 0);

System\Collections\Frozen\KeysAndValuesFrozenDictionary.cs (1)

23((ICollection<KeyValuePair<TKey, TValue>>)source).CopyTo(entries, 0);

System\Collections\Immutable\ImmutableArray_1.Builder.cs (10)

System\Collections\Immutable\ImmutableArray_1.cs (7)

42bool ICollection<T>.IsReadOnly 52int ICollection<T>.Count 1053void ICollection<T>.Add(T item) 1058void ICollection<T>.Clear() 1063bool ICollection<T>.Remove(T item) 1202/// Removes all items from the <see cref="ICollection{T}"/>. 1477private ImmutableArray<T> RemoveAtRange(ICollection<int> indicesToRemove)

System\Collections\Immutable\ImmutableDictionary_2.Builder.cs (32)

System\Collections\Immutable\ImmutableDictionary_2.cs (13)

System\Collections\Immutable\ImmutableExtensions.Minimal.cs (4)

41if (sequence is ICollection<T> collectionOfT) 94/// implementation of <see cref="ICollection{T}"/> could hold on to the array when its <see cref="ICollection{T}.CopyTo"/> 143/// because that only tries to cast the sequence to <see cref="ICollection{T}"/> to determine

System\Collections\Immutable\ImmutableHashSet_1.Builder.cs (21)

System\Collections\Immutable\ImmutableHashSet_1.cs (8)

494/// See the <see cref="ICollection{T}"/> interface. 496bool ICollection<T>.IsReadOnly 502/// See the <see cref="ICollection{T}"/> interface. 504void ICollection<T>.CopyTo(T[] array, int arrayIndex) 519void ICollection<T>.Add(T item) 525/// See the <see cref="ICollection{T}"/> interface. 527void ICollection<T>.Clear() 535bool ICollection<T>.Remove(T item)

System\Collections\Immutable\ImmutableList_1.Builder.cs (3)

79bool ICollection<T>.IsReadOnly 1109/// Gets a value indicating whether the <see cref="ICollection{T}"/> is read-only. 1111/// <returns>true if the <see cref="ICollection{T}"/> is read-only; otherwise, false.

System\Collections\Immutable\ImmutableList_1.cs (8)

962void ICollection<T>.Add(T item) => throw new NotSupportedException(); 968void ICollection<T>.Clear() => throw new NotSupportedException(); 971/// Gets a value indicating whether the <see cref="ICollection{T}"/> is read-only. 973/// <returns>true if the <see cref="ICollection{T}"/> is read-only; otherwise, false. 975bool ICollection<T>.IsReadOnly => true; 983bool ICollection<T>.Remove(T item) => throw new NotSupportedException(); 1054/// Gets a value indicating whether the <see cref="ICollection{T}"/> is read-only. 1056/// <returns>true if the <see cref="ICollection{T}"/> is read-only; otherwise, false.

System\Collections\Immutable\ImmutableSortedDictionary_2.Builder.cs (10)

86ICollection<TKey> IDictionary<TKey, TValue>.Keys 102ICollection<TValue> IDictionary<TKey, TValue>.Values 127bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly 225/// Gets a value indicating whether the <see cref="ICollection{T}"/> is read-only. 227/// <returns>true if the <see cref="ICollection{T}"/> is read-only; otherwise, false. 235/// Gets an <see cref="ICollection{T}"/> containing the keys of the <see cref="IDictionary{TKey, TValue}"/>. 238/// An <see cref="ICollection{T}"/> containing the keys of the object that implements <see cref="IDictionary{TKey, TValue}"/>. 246/// Gets an <see cref="ICollection{T}"/> containing the values in the <see cref="IDictionary{TKey, TValue}"/>. 249/// An <see cref="ICollection{T}"/> containing the values in the object that implements <see cref="IDictionary{TKey, TValue}"/>. 508void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)

System\Collections\Immutable\ImmutableSortedDictionary_2.cs (13)

System\Collections\Immutable\ImmutableSortedSet_1.Builder.cs (4)

85bool ICollection<T>.IsReadOnly 342void ICollection<T>.Add(T item) 366/// See <see cref="ICollection{T}"/> 368void ICollection<T>.CopyTo(T[] array, int arrayIndex)

System\Collections\Immutable\ImmutableSortedSet_1.cs (10)

718/// See the <see cref="ICollection{T}"/> interface. 720bool ICollection<T>.IsReadOnly 726/// See the <see cref="ICollection{T}"/> interface. 728void ICollection<T>.CopyTo(T[] array, int arrayIndex) 736void ICollection<T>.Add(T item) 742/// See the <see cref="ICollection{T}"/> interface. 744void ICollection<T>.Clear() 752bool ICollection<T>.Remove(T item) 800/// Gets a value indicating whether the <see cref="ICollection{T}"/> is read-only. 802/// <returns>true if the <see cref="ICollection{T}"/> is read-only; otherwise, false.

System\Collections\Immutable\ImmutableSortedSet_1.Node.cs (2)

336/// See the <see cref="ICollection{T}"/> interface. 350/// See the <see cref="ICollection{T}"/> interface.

System\Collections\Immutable\KeysOrValuesCollectionAccessor.cs (10)

42/// See <see cref="ICollection{T}"/> 50/// See <see cref="ICollection{T}"/> 52/// <returns>The number of elements contained in the <see cref="ICollection{T}"/>.</returns> 67/// See <see cref="ICollection{T}"/> 75/// See <see cref="ICollection{T}"/> 83/// See <see cref="ICollection{T}"/> 88/// See <see cref="ICollection{T}"/> 103/// See <see cref="ICollection{T}"/> 178/// See <see cref="ICollection{T}"/> 200/// See <see cref="ICollection{T}"/>

System.ComponentModel.Annotations (4)

System\ComponentModel\DataAnnotations\Validator.cs (4)

50ICollection<ValidationResult>? validationResults) 96object instance, ValidationContext validationContext, ICollection<ValidationResult>? validationResults) => 134ICollection<ValidationResult>? validationResults, bool validateAllProperties) 186ICollection<ValidationResult>? validationResults, IEnumerable<ValidationAttribute> validationAttributes)

System.ComponentModel.Composition (15)

Microsoft\Internal\Collections\CollectionServices.CollectionOfObject.cs (5)

12public static ICollection<object> GetCollectionWrapper(Type itemType, object collectionObject) 21return (ICollection<object>)collectionObject; 34return (ICollection<object>)Activator.CreateInstance(collectionType, collectionObject)!; 94private readonly ICollection<T> _collectionOfT; 98_collectionOfT = (ICollection<T>)collectionOfT;

Microsoft\Internal\Collections\CollectionServices.cs (4)

18private static readonly Type ICollectionOfTType = typeof(ICollection<>); 81public static ICollection<T>? ConcatAllowingNull<T>(this ICollection<T>? source, ICollection<T>? second)

System\ComponentModel\Composition\Hosting\AggregateCatalog.cs (2)

159/// An <see cref="ICollection{T}"/> of underlying <see cref="ComposablePartCatalog"/> objects 165public ICollection<ComposablePartCatalog> Catalogs

System\ComponentModel\Composition\ReflectionModel\ImportingMember.cs (4)

109ICollection<object>? collection = null; 120private ICollection<object> GetNormalizedCollection(Type itemType, object? instance) 181private void EnsureCollectionIsWritable(ICollection<object>? collection) 213private void PopulateCollection(ICollection<object?> collection, IEnumerable values)

System.Composition.Convention (1)

System\Composition\Convention\ImportConventionBuilder.cs (1)

15private static readonly Type[] s_supportedImportManyTypes = new[] { typeof(IList<>), typeof(ICollection<>), typeof(IEnumerable<>) };

System.Composition.Hosting (3)

System\Composition\Hosting\Core\CycleBreakingMetadataDictionary.cs (2)

43public ICollection<string> Keys 58public ICollection<object> Values

System\Composition\Hosting\Providers\ImportMany\ImportManyExportDescriptorProvider.cs (1)

15private static readonly Type[] s_supportedContractTypes = new[] { typeof(IList<>), typeof(ICollection<>), typeof(IEnumerable<>) };

System.Composition.TypedParts (6)

System\Composition\TypedParts\TypedPartExportDescriptorProvider.cs (6)

16private readonly Dictionary<CompositionContract, ICollection<DiscoveredExport>> _discoveredParts = new Dictionary<CompositionContract, ICollection<DiscoveredExport>>(); 45ICollection<DiscoveredExport> forKey; 60ICollection<DiscoveredExport> forKey; 84ICollection<DiscoveredExport> forKey; 111ICollection<DiscoveredExport> openGenericParts;

System.Data.Common (2)

System\Data\Common\DbConnectionStringBuilder.cs (2)

244ICollection<string> keys = (ICollection<string>)Keys;

System.Diagnostics.DiagnosticSource (3)

src\libraries\Common\src\System\Diagnostics\DiagnosticsHelper.cs (1)

38if (tags2 is ICollection<KeyValuePair<string, object?>> tagsCol)

System\Diagnostics\ActivityTagsCollection.cs (2)

100public ICollection<string> Keys 116public ICollection<object?> Values

System.Diagnostics.Process (2)

System\Collections\Specialized\DictionaryWrapper.cs (2)

29public ICollection<string> Keys => _contents.Keys; 30public ICollection<string?> Values => _contents.Values;

System.Linq (58)

System\Linq\AnyAll.cs (1)

18if (source is ICollection<TSource> gc)

System\Linq\AppendPrepend.SpeedOpt.cs (6)

18if (_source is ICollection<TSource> c) 77if (_source is ICollection<TSource> collection) 130return !onlyIfCheap || _source is ICollection<TSource> ? _source.Count() + 1 : -1; 187if (_source is ICollection<TSource> c) 234if (_source is ICollection<TSource> sourceCollection) 279return !onlyIfCheap || _source is ICollection<TSource> ? _source.Count() + _appendCount + _prependCount : -1;

System\Linq\Concat.cs (6)

72bool hasOnlyCollections = next is ICollection<TSource> && 73_first is ICollection<TSource> && 74_second is ICollection<TSource>; 121/// <c>true</c> if all sources this iterator concatenates implement <see cref="ICollection{TSource}"/>; 137/// <c>true</c> if all sources this iterator concatenates implement <see cref="ICollection{TSource}"/>; 166bool hasOnlyCollections = _hasOnlyCollections && next is ICollection<TSource>;

System\Linq\Concat.SpeedOpt.cs (12)

41ICollection<TSource>? firstCollection = _first as ICollection<TSource>; 42ICollection<TSource>? secondCollection = _second as ICollection<TSource>; 172var collection = source as ICollection<TSource>; 242ICollection<TSource> source = (ICollection<TSource>)node._head; 256var second = (ICollection<TSource>)previous2._second; 266var first = (ICollection<TSource>)previous2._first;

System\Linq\Contains.cs (1)

11source is ICollection<TSource> collection ? collection.Contains(value) :

System\Linq\Count.cs (3)

18if (source is ICollection<TSource> collectionoft) 91/// count can be determined without enumerating; this includes <see cref="ICollection{T}"/>, 104if (source is ICollection<TSource> collectionoft)

System\Linq\DefaultIfEmpty.SpeedOpt.cs (1)

33if (!onlyIfCheap || _source is ICollection<TSource> || _source is ICollection)

System\Linq\Grouping.cs (7)

399int ICollection<TElement>.Count => _count; 401bool ICollection<TElement>.IsReadOnly => true; 403void ICollection<TElement>.Add(TElement item) => ThrowHelper.ThrowNotSupportedException(); 405void ICollection<TElement>.Clear() => ThrowHelper.ThrowNotSupportedException(); 407bool ICollection<TElement>.Contains(TElement item) => Array.IndexOf(_elements, item, 0, _count) >= 0; 409void ICollection<TElement>.CopyTo(TElement[] array, int arrayIndex) => 412bool ICollection<TElement>.Remove(TElement item) => ThrowHelper.ThrowNotSupportedException_Boolean();

System\Linq\Lookup.cs (6)

266void ICollection<IGrouping<TKey, TElement>>.CopyTo(IGrouping<TKey, TElement>[] array, int arrayIndex) 288bool ICollection<IGrouping<TKey, TElement>>.Contains(IGrouping<TKey, TElement> item) 294bool ICollection<IGrouping<TKey, TElement>>.IsReadOnly => true; 295void ICollection<IGrouping<TKey, TElement>>.Add(IGrouping<TKey, TElement> item) => throw new NotSupportedException(); 296void ICollection<IGrouping<TKey, TElement>>.Clear() => throw new NotSupportedException(); 297bool ICollection<IGrouping<TKey, TElement>>.Remove(IGrouping<TKey, TElement> item) => throw new NotSupportedException();

System\Linq\OrderedEnumerable.SpeedOpt.cs (1)

61return !onlyIfCheap || _source is ICollection<TElement> || _source is ICollection ? _source.Count() : -1;

System\Linq\Range.SpeedOpt.cs (3)

107void ICollection<int>.Add(int item) => ThrowHelper.ThrowNotSupportedException(); 108void ICollection<int>.Clear() => ThrowHelper.ThrowNotSupportedException(); 110bool ICollection<int>.Remove(int item) => ThrowHelper.ThrowNotSupportedException_Boolean();

System\Linq\Repeat.SpeedOpt.cs (3)

111void ICollection<TResult>.Add(TResult item) => ThrowHelper.ThrowNotSupportedException(); 112void ICollection<TResult>.Clear() => ThrowHelper.ThrowNotSupportedException(); 114bool ICollection<TResult>.Remove(TResult item) => ThrowHelper.ThrowNotSupportedException_Boolean();

System\Linq\SegmentedArrayBuilder.cs (1)

128if (source is ICollection<T> collection)

System\Linq\SequenceEqual.cs (2)

25if (first is ICollection<TSource> firstCol && second is ICollection<TSource> secondCol)

System\Linq\SkipTake.SpeedOpt.cs (3)

191void ICollection<TSource>.Add(TSource item) => ThrowHelper.ThrowNotSupportedException(); 192void ICollection<TSource>.Clear() => ThrowHelper.ThrowNotSupportedException(); 194bool ICollection<TSource>.Remove(TSource item) => ThrowHelper.ThrowNotSupportedException_Boolean();

System\Linq\ToCollection.cs (2)

21if (source is ICollection<TSource> collection) 47private static TSource[] ICollectionToArray<TSource>(ICollection<TSource> collection)

System.Linq.Expressions (67)

System\Dynamic\ExpandoObject.cs (14)

System\Dynamic\Utils\ContractUtils.cs (1)

87public static void RequiresNotEmpty<T>(ICollection<T> collection, string paramName)

System\Dynamic\Utils\ExpressionUtils.cs (4)

246internal static bool SameElements<T>(ICollection<T>? replacement, IReadOnlyList<T> current) where T : class 278ICollection<T>? replacementCol = replacement as ICollection<T>; 287private static bool SameElementsInCollection<T>(ICollection<T> replacement, IReadOnlyList<T> current) where T : class

System\Linq\Expressions\BlockExpression.cs (14)

System\Linq\Expressions\DynamicExpression.cs (8)

System\Linq\Expressions\LambdaExpression.cs (8)

System\Linq\Expressions\MemberBinding.cs (1)

22/// A binding that represents initializing a member of type <see cref="Collections.IList"/> or <see cref="Collections.Generic.ICollection{T}"/> from a list of elements.

System\Linq\Expressions\MethodCallExpression.cs (15)

System\Runtime\CompilerServices\ReadOnlyCollectionBuilder.cs (2)

52if (collection is ICollection<T> c) 228bool ICollection<T>.IsReadOnly => false;

System.Linq.Parallel (8)

System\Linq\Parallel\QueryOperators\QueryResults.cs (6)

111void ICollection<T>.Add(T item) 116void ICollection<T>.Clear() 121bool ICollection<T>.Contains(T item) 126void ICollection<T>.CopyTo(T[] array, int arrayIndex) 136bool ICollection<T>.IsReadOnly 141bool ICollection<T>.Remove(T item)

System\Linq\ParallelEnumerable.cs (2)

1855if (sourceAsWrapper.WrappedEnumerable is ICollection<TSource> sourceAsCollection) 1926if (sourceAsWrapper.WrappedEnumerable is ICollection<TSource> sourceAsCollection)

System.Net.Http (24)

System\Net\Http\Headers\CacheControlHeaderValue.cs (3)

87public ICollection<string> NoCacheHeaders => _noCacheHeaders ??= new TokenObjectCollection(); 149public ICollection<string> PrivateHeaders => _privateHeaders ??= new TokenObjectCollection(); 163public ICollection<NameValueHeaderValue> Extensions => _extensions ??= new UnvalidatedObjectCollection<NameValueHeaderValue>();

System\Net\Http\Headers\ContentDispositionHeaderValue.cs (1)

43public ICollection<NameValueHeaderValue> Parameters => _parameters ??= new UnvalidatedObjectCollection<NameValueHeaderValue>();

System\Net\Http\Headers\HttpContentHeaders.cs (3)

17public ICollection<string> Allow => 28public ICollection<string> ContentEncoding => 31public ICollection<string> ContentLanguage =>

System\Net\Http\Headers\MediaTypeHeaderValue.cs (1)

62public ICollection<NameValueHeaderValue> Parameters => _parameters ??= new UnvalidatedObjectCollection<NameValueHeaderValue>();

System\Net\Http\Headers\NameValueWithParametersHeaderValue.cs (1)

20public ICollection<NameValueHeaderValue> Parameters =>

System\Net\Http\Headers\ObjectCollection.cs (1)

18/// <summary>An <see cref="ICollection{T}"/> list that prohibits null elements and that is optimized for a small number of elements.</summary>

System\Net\Http\Headers\RangeHeaderValue.cs (1)

27public ICollection<RangeItemHeaderValue> Ranges => _ranges ??= new UnvalidatedObjectCollection<RangeItemHeaderValue>();

System\Net\Http\Headers\RangeItemHeaderValue.cs (1)

80ICollection<RangeItemHeaderValue> rangeCollection)

System\Net\Http\Headers\TransferCodingHeaderValue.cs (1)

20public ICollection<NameValueHeaderValue> Parameters => _parameters ??= new UnvalidatedObjectCollection<NameValueHeaderValue>();

System\Net\Http\HttpRequestOptions.cs (9)

System\Net\Http\SocketsHttpHandler\DecompressionHandler.cs (1)

72ICollection<string> contentEncodings = response.Content.Headers.ContentEncoding;

System\Net\Http\SocketsHttpHandler\FailedProxyCache.cs (1)

128((ICollection<KeyValuePair<Uri, long>>)_failedProxies).Remove(kvp);

System.Net.NameResolution (2)

System\Net\Dns.cs (2)

683((ICollection<KeyValuePair<object, Task>>)s_tasks).Remove(new KeyValuePair<object, Task>(key!, task!)); 696((ICollection<KeyValuePair<object, Task>>)s_tasks).Remove(new KeyValuePair<object, Task>(key!, task));

System.Net.Primitives (1)

System\Net\CookieContainer.cs (1)

577foreach (Cookie c in (ICollection<Cookie>)cookies)

System.Net.Security (2)

System\Security\Authentication\ExtendedProtection\ServiceNameCollection.cs (2)

150ICollection<string>? c = collection as ICollection<string>;

System.ObjectModel (2)

System\Collections\Generic\DebugView.cs (2)

10private readonly ICollection<T> _collection; 12public CollectionDebugView(ICollection<T> collection)

System.Private.CoreLib (77)

src\libraries\Common\src\System\Collections\Generic\EnumerableHelpers.cs (1)

24if (source is ICollection<T> ic)

src\libraries\System.Private.CoreLib\src\System\ArraySegment.cs (5)

229bool ICollection<T>.IsReadOnly => 234void ICollection<T>.Add(T item) => ThrowHelper.ThrowNotSupportedException(); 236void ICollection<T>.Clear() => ThrowHelper.ThrowNotSupportedException(); 238bool ICollection<T>.Contains(T item) 250bool ICollection<T>.Remove(T item)

src\libraries\System.Private.CoreLib\src\System\Collections\Concurrent\ConcurrentQueue.cs (1)

92if (collection is ICollection<T> c)

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\Dictionary.cs (17)

101this((collection as ICollection<KeyValuePair<TKey, TValue>>)?.Count ?? 0, comparer) 218ICollection<TKey> IDictionary<TKey, TValue>.Keys => Keys; 224ICollection<TValue> IDictionary<TKey, TValue>.Values => Values; 254void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> keyValuePair) => 257bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> keyValuePair) 268bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> keyValuePair) 1033bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => false; 1035void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int index) => 1504bool ICollection<TKey>.IsReadOnly => true; 1506void ICollection<TKey>.Add(TKey item) => 1509void ICollection<TKey>.Clear() => 1515bool ICollection<TKey>.Remove(TKey item) 1699bool ICollection<TValue>.IsReadOnly => true; 1701void ICollection<TValue>.Add(TValue item) => 1704bool ICollection<TValue>.Remove(TValue item) 1710void ICollection<TValue>.Clear() => 1713bool ICollection<TValue>.Contains(TValue item) => _dictionary.ContainsValue(item);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\HashSet.cs (8)

102if (collection is ICollection<T> coll) 191void ICollection<T>.Add(T item) => AddIfNotPresent(item, out _); 361bool ICollection<T>.IsReadOnly => false; 516if (other is ICollection<T> otherAsCollection) 655if (other is ICollection<T> otherAsCollection) 704if (other is ICollection<T> otherAsCollection) 748if (other is ICollection<T> otherAsCollection) 841other is ICollection<T> otherAsCollection &&

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ICollectionDebugView.cs (2)

10private readonly ICollection<T> _collection; 12public ICollectionDebugView(ICollection<T> collection)

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\IDictionary.cs (2)

24ICollection<TKey> Keys 30ICollection<TValue> Values

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\IDictionaryDebugView.cs (4)

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\List.cs (4)

66if (collection is ICollection<T> c) 132bool ICollection<T>.IsReadOnly => false; 250if (collection is ICollection<T> c) 821if (collection is ICollection<T> c)

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\Queue.cs (1)

62/// <inheritdoc cref="ICollection{T}"/>

src\libraries\System.Private.CoreLib\src\System\Collections\ObjectModel\Collection.cs (1)

159bool ICollection<T>.IsReadOnly => items.IsReadOnly;

src\libraries\System.Private.CoreLib\src\System\Collections\ObjectModel\CollectionHelpers.cs (1)

33internal static void CopyTo<T>(ICollection<T> collection, Array array, int index)

src\libraries\System.Private.CoreLib\src\System\Collections\ObjectModel\ReadOnlyCollection.cs (4)

57bool ICollection<T>.IsReadOnly => true; 65void ICollection<T>.Add(T value) 70void ICollection<T>.Clear() 80bool ICollection<T>.Remove(T value)

src\libraries\System.Private.CoreLib\src\System\Collections\ObjectModel\ReadOnlyDictionary.cs (21)

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\EventPayload.cs (2)

25public ICollection<string> Keys => m_names; 26public ICollection<object?> Values => m_values;

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\Task.cs (3)

5890if (tasks is ICollection<Task> taskCollection) 6193if (tasks is ICollection<Task<TResult>> taskCollection) 6665if (tasks is ICollection<TTask> tasksAsCollection)

System.Private.DataContractSerialization (15)

System\Runtime\Serialization\CollectionDataContract.cs (1)

804context.IncrementCollectionCountGeneric<T>(xmlwriter, (ICollection<T>)obj);

System\Runtime\Serialization\Globals.cs (1)

254s_typeOfICollectionGeneric ??= typeof(ICollection<>);

System\Runtime\Serialization\ReflectionReader.cs (2)

585Type genericCollectionType = typeof(ICollection<T>); 591((ICollection<T>)resultCollection).Add((T)collectionItem!);

System\Runtime\Serialization\XmlObjectSerializerWriteContext.cs (1)

426internal void IncrementCollectionCountGeneric<T>(XmlWriterDelegator xmlWriter, ICollection<T> collection)

System\Runtime\Serialization\XsdDataContractExporter.cs (10)

101/// <param name="assemblies">A <see cref="ICollection{T}"/> (of <see cref="Assembly"/>) that contains the types to export.</param> 104public void Export(ICollection<Assembly> assemblies) 131/// Transforms the types contained in the <see cref="ICollection{T}"/> passed to this method. 133/// <param name="types">A <see cref="ICollection{T}"/> (of <see cref="Type"/>) that contains the types to export.</param> 136public void Export(ICollection<Type> types) 303/// <param name="assemblies">A <see cref="ICollection{T}"/> of <see cref="Assembly"/> that contains the assemblies with the types to export.</param> 307public bool CanExport(ICollection<Assembly> assemblies) 339/// Gets a value that indicates whether the set of runtime types contained in a <see cref="ICollection{T}"/> can be exported. 341/// <param name="types">A <see cref="ICollection{T}"/> that contains the specified types to export.</param> 345public bool CanExport(ICollection<Type> types)

System.Private.Xml (12)

System\Xml\Xsl\IlGen\GenerateHelper.cs (1)

127IListCount = typeof(ICollection<>).MakeGenericType(storageType).GetMethod("get_Count")!;

System\Xml\Xsl\Runtime\XmlQuerySequence.cs (10)

174bool ICollection<T>.IsReadOnly 182void ICollection<T>.Add(T value) 190void ICollection<T>.Clear() 215bool ICollection<T>.Remove(T value) 670bool ICollection<XPathItem>.IsReadOnly 678void ICollection<XPathItem>.Add(XPathItem value) 686void ICollection<XPathItem>.Clear() 694bool ICollection<XPathItem>.Contains(XPathItem value) 702void ICollection<XPathItem>.CopyTo(XPathItem[] array, int index) 711bool ICollection<XPathItem>.Remove(XPathItem value)

System\Xml\Xsl\Xslt\Scripts.cs (1)

64public ICollection<string> Keys => _backingDictionary.Keys;

System.Private.Xml.Linq (1)

src\libraries\Common\src\System\Collections\Generic\EnumerableHelpers.cs (1)

24if (source is ICollection<T> ic)

System.Runtime (1)

artifacts\obj\System.Runtime\Debug\net9.0\System.Runtime.Forwards.cs (1)

77[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Collections.Generic.ICollection<>))]

System.Security.Cryptography (1)

System\Security\Cryptography\Helpers.cs (1)

18internal static void AddRange<T>(this ICollection<T> coll, IEnumerable<T> newData)

System.Security.Cryptography.Cose (3)

System\Security\Cryptography\Cose\CoseHeaderMap.cs (3)

37private ICollection<KeyValuePair<CoseHeaderLabel, CoseHeaderValue>> HeaderParametersAsCollection => _headerParameters; 43public ICollection<CoseHeaderLabel> Keys => _headerParameters.Keys; 49public ICollection<CoseHeaderValue> Values => _headerParameters.Values;

System.Security.Principal.Windows (1)

artifacts\obj\System.Security.Principal.Windows\Debug\net9.0\System.Security.Principal.Windows.notsupported.cs (1)

48bool System.Collections.Generic.ICollection<System.Security.Principal.IdentityReference>.IsReadOnly { get { throw new System.PlatformNotSupportedException(System.SR.PlatformNotSupported_Principal); } }

System.Speech (7)

artifacts\obj\System.Speech\Debug\net9.0\System.Speech.notsupported.cs (7)

System.Text.Json (17)

src\libraries\System.Text.Json\Common\JsonHelpers.cs (2)

91public static T[] TraverseGraphWithTopologicalSort<T>(T entryNode, Func<T, ICollection<T>> getChildren, IEqualityComparer<T>? comparer = null) 107ICollection<T> children = getChildren(next);

System\Text\Json\JsonPropertyDictionary.KeyCollection.cs (1)

77bool ICollection<string>.Remove(string propertyName) => throw ThrowHelper.GetNotSupportedException_CollectionIsReadOnly();

System\Text\Json\JsonPropertyDictionary.ValueCollection.cs (1)

77bool ICollection<T>.Remove(T node) => throw ThrowHelper.GetNotSupportedException_CollectionIsReadOnly();

System\Text\Json\Nodes\JsonArray.IList.cs (2)

139void ICollection<JsonNode?>.CopyTo(JsonNode?[] array, int index) => List.CopyTo(array, index); 158bool ICollection<JsonNode?>.IsReadOnly => false;

System\Text\Json\Nodes\JsonObject.cs (1)

38JsonPropertyDictionary<JsonNode?> dictionary = properties is ICollection<KeyValuePair<string, JsonNode?>> propertiesCollection

System\Text\Json\Nodes\JsonObject.IDictionary.cs (6)

117bool ICollection<KeyValuePair<string, JsonNode?>>.Contains(KeyValuePair<string, JsonNode?> item) => Dictionary.Contains(item); 136void ICollection<KeyValuePair<string, JsonNode?>>.CopyTo(KeyValuePair<string, JsonNode?>[] array, int index) => Dictionary.CopyTo(array, index); 155bool ICollection<KeyValuePair<string, JsonNode?>>.Remove(KeyValuePair<string, JsonNode?> item) => Remove(item.Key); 160ICollection<string> IDictionary<string, JsonNode?>.Keys => Dictionary.Keys; 165ICollection<JsonNode?> IDictionary<string, JsonNode?>.Values => Dictionary.Values; 186bool ICollection<KeyValuePair<string, JsonNode?>>.IsReadOnly => false;

System\Text\Json\Serialization\Converters\Collection\ICollectionOfTConverter.cs (1)

15where TCollection : ICollection<TElement>

System\Text\Json\Serialization\Converters\Collection\IEnumerableConverterFactory.cs (1)

111else if ((actualTypeToConvert = typeToConvert.GetCompatibleGenericInterface(typeof(ICollection<>))) != null)

System\Text\Json\Serialization\Metadata\JsonMetadataServices.Collections.cs (2)

221/// Creates serialization metadata for types assignable to <see cref="ICollection{T}"/>. 232where TCollection : ICollection<TElement>

System.Text.Json.SourceGeneration (3)

Helpers\KnownTypeSymbols.cs (1)

28public INamedTypeSymbol? ICollectionOfTType => GetOrResolveType(typeof(ICollection<>), ref _ICollectionOfTType);

src\libraries\System.Text.Json\Common\JsonHelpers.cs (2)

System.Text.RegularExpressions (17)

System\Text\RegularExpressions\CaptureCollection.cs (5)

139void ICollection<Capture>.Add(Capture item) => 142void ICollection<Capture>.Clear() => 145bool ICollection<Capture>.Contains(Capture item) => 148bool ICollection<Capture>.Remove(Capture item) => 158value is Capture other && ((ICollection<Capture>)this).Contains(other);

System\Text\RegularExpressions\CollectionDebuggerProxy.cs (2)

11private readonly ICollection<T> _collection; 13public CollectionDebuggerProxy(ICollection<T> collection)

System\Text\RegularExpressions\GroupCollection.cs (5)

153void ICollection<Group>.Add(Group item) => 156void ICollection<Group>.Clear() => 159bool ICollection<Group>.Contains(Group item) => 162bool ICollection<Group>.Remove(Group item) => 172value is Group other && ((ICollection<Group>)this).Contains(other);

System\Text\RegularExpressions\MatchCollection.cs (5)

149void ICollection<Match>.Add(Match item) => 152void ICollection<Match>.Clear() => 155bool ICollection<Match>.Contains(Match item) 161bool ICollection<Match>.Remove(Match item) => 171value is Match match && ((ICollection<Match>)this).Contains(match);

System.Threading.Tasks.Dataflow (1)

Blocks\TransformManyBlock.cs (1)

440if (_target.IsBounded) UpdateBoundingCountWithOutputCount(count: ((ICollection<TOutput>)outputItems).Count);

System.Xaml (45)

src\Microsoft.DotNet.Wpf\src\Shared\MS\Utility\FrugalList.cs (2)

1285public ArrayItemList(ICollection<T> collection) 1967public FrugalStructList(ICollection<T> collection)

System\Xaml\AttachablePropertyServices.cs (1)

139((ICollection<KeyValuePair<AttachableMemberIdentifier, object>>)instanceProperties).CopyTo(array, index);

System\Xaml\MS\Impl\XmlNsInfo.cs (3)

56private ICollection<AssemblyName> _internalsVisibleTo; 57internal ICollection<AssemblyName> InternalsVisibleTo 234ICollection<AssemblyName> LoadInternalsVisibleTo()

System\Xaml\NameScope.cs (2)

219public ICollection<string> Keys 237public ICollection<object> Values

System\Xaml\NameScopeDictionary.cs (9)

System\Xaml\Schema\CollectionReflector.cs (2)

109Type genericICollection = GetGenericInterface(type, typeof(ICollection<>), out hasMoreThanOneICollection); 251Type genericICollection = typeof(ICollection<>).MakeGenericType(itemType);

System\Xaml\Schema\TypeReflector.cs (4)

218internal ICollection<XamlMember> ExcludedReadOnlyMembers { get; set; } 449internal void LookupAllMembers(out ICollection<PropertyInfo> newProperties, 450out ICollection<EventInfo> newEvents, out List<XamlMember> knownMembers) 532private ICollection<EventInfo> FilterEvents(EventInfo[] eventList, List<XamlMember> knownMembers)

System\Xaml\Schema\XamlNamespace.cs (3)

22private ICollection<XamlType> _allPublicTypes; 53public ICollection<XamlType> GetAllXamlTypes() => _allPublicTypes ??= LookupAllTypes(); 201private ICollection<XamlType> LookupAllTypes()

System\Xaml\XamlObjectReader.cs (2)

1618var properties = valueXamlType.GetAllMembers(); 1619var readOnlyProperties = valueXamlType.GetAllExcludedReadOnlyMembers();

System\Xaml\XamlSchemaContext.cs (8)

99public virtual ICollection<XamlType> GetAllXamlTypes(string xamlNamespace) 572ICollection<XamlMember> members = type.GetAllMembers(); 759ICollection<AssemblyName> friends = nsInfo.InternalsVisibleTo; 1410void ICollection<T>.Add(T item) 1415bool ICollection<T>.Contains(T item) 1427void ICollection<T>.CopyTo(T[] array, int arrayIndex) 1435bool ICollection<T>.Remove(T item) 1440bool ICollection<T>.IsReadOnly

System\Xaml\XamlType.cs (7)

346public ICollection<XamlMember> GetAllMembers() 393public ICollection<XamlMember> GetAllAttachableMembers() 599internal ICollection<XamlMember> GetAllExcludedReadOnlyMembers() 1000ICollection<PropertyInfo> properties; 1001ICollection<EventInfo> events; 1534private ICollection<XamlMember> LookupAllExcludedReadOnlyMembers() 1542ICollection<XamlMember> allMembers = GetAllMembers();

System\Xaml\XamlXmlWriter.cs (2)

1979var properties = objectXamlType.GetAllMembers(); 1980var readOnlyProperties = objectXamlType.GetAllExcludedReadOnlyMembers();

Templates.Blazor.Tests (2)

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (2)

380var certsFromDisk = GetCertsFromDisk(); 426private static ICollection<X509Certificate2> GetCertsFromDisk()

Templates.Blazor.WebAssembly.Auth.Tests (3)

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (2)

380var certsFromDisk = GetCertsFromDisk(); 426private static ICollection<X509Certificate2> GetCertsFromDisk()

src\Shared\E2ETesting\BrowserFixture.cs (1)

66var browsers = _browsers.Values;

Templates.Blazor.WebAssembly.Tests (3)

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (2)

380var certsFromDisk = GetCertsFromDisk(); 426private static ICollection<X509Certificate2> GetCertsFromDisk()

src\Shared\E2ETesting\BrowserFixture.cs (1)

66var browsers = _browsers.Values;

Templates.Mvc.Tests (3)

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (2)

380var certsFromDisk = GetCertsFromDisk(); 426private static ICollection<X509Certificate2> GetCertsFromDisk()

src\Shared\E2ETesting\BrowserFixture.cs (1)

66var browsers = _browsers.Values;

Templates.Tests (3)

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (2)

380var certsFromDisk = GetCertsFromDisk(); 426private static ICollection<X509Certificate2> GetCertsFromDisk()

src\Shared\E2ETesting\BrowserFixture.cs (1)

66var browsers = _browsers.Values;

xunit.console (4)

common\AssemblyResolution\Microsoft.Extensions.DependencyModel\DependencyContextJsonReader.cs (3)

222var runtimes = targetLibraryJson.ValueAsJsonObject(DependencyContextStrings.RuntimeAssembliesKey)?.Keys; 223var natives = targetLibraryJson.ValueAsJsonObject(DependencyContextStrings.NativeLibrariesKey)?.Keys; 224var compilations = targetLibraryJson.ValueAsJsonObject(DependencyContextStrings.CompileTimeAssembliesKey)?.Keys;

common\Json.cs (1)

727public ICollection<string> Keys