ICollection

27public ICollection<BuildMessageEventArgs> Messages { get; } = new List<BuildMessageEventArgs>(); 28public ICollection<BuildWarningEventArgs> Warnings { get; } = new List<BuildWarningEventArgs>(); 29public ICollection<BuildErrorEventArgs> Errors { get; } = new List<BuildErrorEventArgs>();

Microsoft.Arcade.Test.Common (3)

MockEngine.cs (3)

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.AsyncState (1)

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

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.Core.Test (4)

AuthenticationPropertiesTests.cs (4)

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)

134ICollection<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 (6)

Binding\FormDataMapperTests.cs (1)

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

Builder\RazorComponentsEndpointConventionBuilderExtensionsTest.cs (3)

185var groupEndpoints = Assert.IsAssignableFrom<IEndpointRouteBuilder>(group).DataSources; 211var groupEndpoints = Assert.IsAssignableFrom<IEndpointRouteBuilder>(group).DataSources; 280public ICollection<EndpointDataSource> DataSources { get; } = [];

HotReloadServiceTests.cs (1)

300public ICollection<EndpointDataSource> DataSources => _dataSources;

RazorComponentEndpointDataSourceTest.cs (1)

316public 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)

118private 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)

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

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

Virtualization\VirtualizeTest.cs (1)

111ICollection<TItem> items,

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

WebAssemblyEndpointProvider.cs (1)

57public 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)

385var certsFromDisk = GetCertsFromDisk(); 431private static ICollection<X509Certificate2> GetCertsFromDisk()

Microsoft.AspNetCore.Diagnostics (5)

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

14var tags = feature.Tags; 21var tags = feature.Tags; 28var tags = feature.Tags; 33private static void SetTagCore(string name, object? value, ICollection<KeyValuePair<string, object?>> tags) 62private static bool TryAddTagCore(string name, object? value, ICollection<KeyValuePair<string, object?>> tags)

Microsoft.AspNetCore.Diagnostics.Middleware.Tests (16)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (2)

47public static IEnumerable<T> EmptyIfNull<T>(this ICollection<T>? collection) 112if (enumerable is ICollection<T> c && c.Count == 0)

src\Shared\EmptyCollections\EmptyReadonlyDictionary.cs (8)

src\Shared\EmptyCollections\EmptyReadOnlyList.cs (6)

27void ICollection<T>.CopyTo(T[] array, int arrayIndex) 32bool ICollection<T>.Contains(T item) => false; 33bool ICollection<T>.IsReadOnly => true; 34void ICollection<T>.Add(T item) => throw new NotSupportedException(); 35bool ICollection<T>.Remove(T item) => false; 37void ICollection<T>.Clear()

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

JsonTranscodingServiceMethodProviderTests.cs (1)

246public ICollection<EndpointDataSource> DataSources { get; }

Microsoft.AspNetCore.HeaderParsing (1)

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

67var addresses = serverAddressesFeature?.Addresses;

Microsoft.AspNetCore.Hosting (10)

GenericHost\GenericWebHostService.cs (1)

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 (5)

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)

482public 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)

482public ICollection<EndpointDataSource> DataSources { get; }

Microsoft.AspNetCore.Http.Results (1)

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

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

Microsoft.AspNetCore.Http.Tests (2)

Internal\ItemsDictionaryTests.cs (2)

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)

499/// A collection type is defined as a <see cref="Type"/> which is assignable to <see cref="ICollection{T}"/>. 780var 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)

118var apiResponseTypes = _responseTypeProvider.GetApiResponseTypes(action);

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

ApiResponseTypeProviderTest.cs (17)

EndpointMetadataApiDescriptionProviderTest.cs (1)

1627public 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)

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

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

ApplicationModels\DefaultApplicationModelProviderTest.cs (1)

1832ICollection<IFormFile> formFileCollection,

ApplicationModels\InferParameterBindingInfoConventionTest.cs (1)

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.RazorPages.Test (3)

Builder\PageActionEndpointConventionBuilderResourceCollectionExtensionsTest.cs (3)

166var groupEndpoints = Assert.IsAssignableFrom<IEndpointRouteBuilder>(group).DataSources; 192var groupEndpoints = Assert.IsAssignableFrom<IEndpointRouteBuilder>(group).DataSources; 232public ICollection<EndpointDataSource> DataSources { 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 (17)

AttributeDictionaryTest.cs (2)

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

Builder\ControllerActionEndpointConventionBuilderResourceCollectionExtensionsTest.cs (3)

221var groupEndpoints = Assert.IsAssignableFrom<IEndpointRouteBuilder>(group).DataSources; 256var groupEndpoints = Assert.IsAssignableFrom<IEndpointRouteBuilder>(group).DataSources; 305public ICollection<EndpointDataSource> DataSources { get; } = [];

DefaultHtmlGeneratorTest.cs (12)

Microsoft.AspNetCore.OpenApi.Tests (3)

Services\OpenApiDocumentServiceTestsBase.cs (2)

178public ICollection<EndpointDataSource> DataSources { get; } 348public ICollection<string> Addresses { get; set; }

Transformers\Implementations\OpenApiSchemaReferenceTransformerTests.cs (1)

363public ICollection<Todo> Todos { get; set; } = [];

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)

323((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 (22)

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)

385var certsFromDisk = GetCertsFromDisk(); 431private static ICollection<X509Certificate2> GetCertsFromDisk()

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

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

Http1\Http1ConnectionTests.cs (2)

1200public ICollection<string> Keys => _innerHeaders.Keys; 1201public ICollection<StringValues> Values => _innerHeaders.Values;

HttpResponseHeadersTests.cs (3)

128((ICollection<KeyValuePair<string, StringValues>>)responseHeaders).Add(kvp); 222((ICollection<KeyValuePair<string, StringValues>>)responseHeaders).Add(kvp); 254((ICollection<KeyValuePair<string, StringValues>>)responseHeaders).Add(kvp);

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

Http2\Http2ConnectionBenchmarkBase.cs (1)

200public ICollection<KeyValuePair<string, object>> Tags { get; }

src\Servers\Kestrel\shared\test\Http3\Http3InMemory.cs (1)

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

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)

Microsoft.AspNetCore.StaticFiles (1)

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

Microsoft.AspNetCore.StaticFiles.FunctionalTests (1)

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

Microsoft.AspNetCore.Testing (1)

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

193public ICollection<ProjectPropertyInstance> GlobalProperties => (GlobalPropertiesDictionary == null) ? 194(ICollection<ProjectPropertyInstance>)ReadOnlyEmptyCollection<ProjectPropertyInstance>.Instance : 237public new ICollection<string> TargetNames => base.TargetNames;

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 (292)

BackEnd\BuildManager\BuildParameters.cs (1)

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

BackEnd\BuildManager\BuildRequestData.cs (3)

BackEnd\BuildManager\BuildRequestDataBase.cs (3)

12ICollection<string> targetNames, 33public ICollection<string> TargetNames { get; protected set; } 58ICollection<string> targetNames,

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

102ICollection<ILogger> Loggers 112ICollection<LoggerDescription> LoggerDescriptions 121ICollection<string> RegisteredLoggerTypeNames 130ICollection<string> RegisteredSinkNames 282ICollection<string> GetWarningsAsErrors(BuildEventContext context); 289ICollection<string> GetWarningsNotAsErrors(BuildEventContext context); 296ICollection<string> GetWarningsAsMessages(BuildEventContext context); 330void InitializeNodeLoggers(ICollection<LoggerDescription> loggerDescriptions, IBuildEventSink forwardingLoggerSink, int nodeId);

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

486public ICollection<LoggerDescription> LoggerDescriptions => _loggerDescriptions; 491public ICollection<ILogger> Loggers => _loggers; 654public ICollection<string> GetWarningsAsErrors(BuildEventContext context) 665public ICollection<string> GetWarningsNotAsErrors(BuildEventContext context) 676public ICollection<string> GetWarningsAsMessages(BuildEventContext context) 691private ICollection<string> GetWarningsForProject(BuildEventContext context, IDictionary<WarningsConfigKey, ISet<string>> warningsByProject, ISet<string> warnings) 771public ICollection<string> RegisteredLoggerTypeNames 797public ICollection<string> RegisteredSinkNames 1195public void InitializeNodeLoggers(ICollection<LoggerDescription> descriptions, IBuildEventSink forwardingLoggerSink, int nodeId)

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

154internal ICollection<string> GetWarningsAsErrors() 159internal ICollection<string> GetWarningsNotAsErrors() 164internal ICollection<string> GetWarningsAsMessages()

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

101ICollection<string> requestedTargets, 129ICollection<string> requestedTargets, 163ICollection<string> requestedTargets, 179ICollection<ProjectItemInstance> items = projectInstance.GetItems(ItemTypeNames.ProjectCachePlugin); 198ICollection<string> requestedTargets, 534ICollection<string> requestedTargetsList = buildRequestConfiguration.RequestedTargets as ICollection<string> ?? buildRequestConfiguration.RequestedTargets.ToList();

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

147Dictionary<string, ICollection<ProjectItemInstance>> itemListsToBeBatched = GetItemListsToBeBatched(consumedMetadataReferences, consumedItemReferences, lookup, elementLocation); 206private static Dictionary<string, ICollection<ProjectItemInstance>> GetItemListsToBeBatched( 215var itemListsToBeBatched = new Dictionary<string, ICollection<ProjectItemInstance>>(MSBuildNameIgnoreCaseComparer.Default); 257ICollection<ProjectItemInstance> items = lookup.GetItems(consumedItemName); 302Dictionary<string, ICollection<ProjectItemInstance>> itemListsToBeBatched, 313foreach (KeyValuePair<string, ICollection<ProjectItemInstance>> entry in itemListsToBeBatched) 318ICollection<ProjectItemInstance> items = entry.Value ?? lookup.GetItems(itemName);

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

252ICollection<ProjectItemInstance> group = bucket.Lookup.GetItems(child.ItemType); 299ICollection<ProjectItemInstance> group = bucket.Lookup.GetItems(child.ItemType); 547ICollection<ProjectItemInstance> items, 615ICollection<ProjectItemInstance> group,

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

78ICollection<string> itemNames,

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

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

1028var projectReferenceItems = _buildRequestEntry.RequestConfiguration.Project.GetItems(ItemTypeNames.ProjectReference); 1195ICollection<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)

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

BackEnd\Shared\BuildRequest.cs (1)

177ICollection<string> escapedTargets,

BackEnd\Shared\BuildRequestConfiguration.cs (1)

831var 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; 272void ICollection<KeyValuePair<string, T>>.Add(KeyValuePair<string, T> item) 280bool ICollection<KeyValuePair<string, T>>.Contains(KeyValuePair<string, T> item) 293void ICollection<KeyValuePair<string, T>>.CopyTo(KeyValuePair<string, T>[] array, int arrayIndex) 301bool 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) 216public ICollection<T> GetItems(string itemType) 218ICollection<T> result = this[itemType]; 417private IEnumerator<ICollection<T>> _listEnumerator; 427internal Enumerator(IEnumerable<ICollection<T>> listEnumerable)

Collections\PropertyDictionary.cs (14)

109ICollection<string> IDictionary<string, T>.Keys 124ICollection<T> IDictionary<string, T>.Values 139int ICollection<KeyValuePair<string, T>>.Count => Count; 145bool ICollection<KeyValuePair<string, T>>.IsReadOnly => false; 156return ((ICollection<T>)_properties).Count; 232((ICollection<T>)_properties).Clear(); 395void ICollection<KeyValuePair<string, T>>.Add(KeyValuePair<string, T> item) 403void ICollection<KeyValuePair<string, T>>.Clear() 411bool ICollection<KeyValuePair<string, T>>.Contains(KeyValuePair<string, T> item) 427void ICollection<KeyValuePair<string, T>>.CopyTo(KeyValuePair<string, T>[] array, int arrayIndex) 435bool ICollection<KeyValuePair<string, T>>.Remove(KeyValuePair<string, T> item) 522var dictionary = new Dictionary<string, string>(((ICollection<T>)_properties).Count, MSBuildNameIgnoreCaseComparer.Default); 537foreach (var kvp in (ICollection<T>)_properties) 557foreach (T property in (ICollection<T>)_properties)

Collections\ReadOnlyConvertingDictionary.cs (2)

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

Collections\RetrievableEntryHashSet\RetrievableEntryHashSet.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 1097public ICollection<Project> GetLoadedProjects(string fullPath) 1107internal ICollection<Project> GetLoadedProjects(bool includeExternal, string fullPath = null)

Definition\ProjectItem.cs (2)

288public ICollection<ProjectMetadata> Metadata 329internal ICollection<ProjectMetadata> MetadataCollection

Definition\Toolset.cs (1)

928ICollection<ProjectPropertyInstance> subToolsetProperties = null;

Evaluation\Expander.cs (1)

2012var 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)

628private static IEnumerable<string> GetExpandedMetadataValuesAndConditions(ICollection<ProjectMetadataElement> metadata, Expander<P, I> expander)

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)

130public 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)

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

Instance\ImmutableProjectCollections\ImmutableElementCollectionConverter.cs (2)

43public ICollection<string> Keys => _projectElements.Keys; 45public ICollection<T> Values => _values;

Instance\ImmutableProjectCollections\ImmutableGlobalPropertiesCollectionConverter.cs (2)

64public ICollection<string> Keys => _globalProperties.Keys; 66public ICollection<ProjectPropertyInstance> Values => _values;

Instance\ImmutableProjectCollections\ImmutableItemDictionary.cs (12)

24private readonly IDictionary<string, ICollection<TCached>> _itemsByType; 25private readonly ICollection<TCached> _allCachedItems; 30ICollection<TCached> allItems, 31IDictionary<string, ICollection<TCached>> itemsByType, 47public ICollection<T> this[string itemType] 51if (!_itemsByType.TryGetValue(itemType, out ICollection<TCached>? list)) 64public ICollection<string> ItemTypes => _itemsByType.Keys; 92ICollection<T> items = GetItems(itemType); 151public ICollection<T> GetItems(string itemType) 153if (_itemsByType.TryGetValue(itemType, out ICollection<TCached>? items)) 182private readonly ICollection<TCached> _list; 185public ListConverter(string itemType, ICollection<TCached> list, Func<TCached, T?> getInstance)

Instance\ProjectInstance.cs (16)

Instance\ProjectItemDefinitionInstance.cs (1)

101public 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)

283public 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)

886else 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)

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

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

Construction\ElementLocationPublic_Tests.cs (1)

Definition\ProjectItem_Tests.cs (6)

2218var items = project.GetItems("I"); 2232var metadata = item.Metadata; 2245var metadataElements = items.First().Xml.Metadata; 2278var items = project.GetItems("I"); 2292var metadata = item.Metadata; 2301var 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)

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

WindowsFileSystem.cs (1)

59public ICollection<ILogger> Loggers 123public ICollection<LoggerDescription> LoggerDescriptions 134public ICollection<string> RegisteredLoggerTypeNames 145public ICollection<string> RegisteredSinkNames 306public void InitializeNodeLoggers(ICollection<LoggerDescription> loggerDescriptions, IBuildEventSink forwardingLoggerSink, int nodeId) 667public ICollection<string> GetWarningsAsErrors(BuildEventContext context) 672public ICollection<string> GetWarningsNotAsErrors(BuildEventContext context) 677public ICollection<string> GetWarningsAsMessages(BuildEventContext context)

Microsoft.Build.Engine.UnitTests (113)

BackEnd\IntrinsicTask_Tests.cs (48)

BackEnd\Lookup_Tests.cs (26)

BackEnd\MockLoggingService.cs (8)

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)

258var c = project.ItemsIgnoringCondition;

Definition\ProjectEvaluationContext_Tests.cs (3)

524var actualGlobExpansion = project.GetItems("i"); 595var actualGlobExpansion = project.GetItems("i"); 655var actualGlobExpansion = project.GetItems("i");

Evaluation\Expander_Tests.cs (5)

4799ICollection<ProjectItemInstance> myDirectories = projectInstance.GetItems("MyDirectories"); 4843ICollection<ProjectItemInstance> myDirectories = projectInstance.GetItems("MyDirectories"); 4872ICollection<ProjectItemInstance> squiggles = projectInstance.GetItems("Squiggle"); 4919ICollection<ProjectItemInstance> squiggleItems = projectInstance.GetItems("Compile"); 4960ICollection<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 (82)

BinaryTranslator.cs (4)

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

BuildCheck\EnumerableExtensions.cs (1)

50public static HashSet<T>? ToHashSet<T>(this ICollection<T>? source, IEqualityComparer<T>? equalityComparer = null)

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>;

ProjectStartedEventArgs.cs (1)

479private static void WriteCollection(BinaryWriter writer, ICollection<string>? collection)

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.CodeAnalysis.UnitTests (9)

TargetTests.cs (9)

Microsoft.Build.Tasks.Core (20)

AssemblyDependency\Reference.cs (1)

189internal ICollection<ITaskItem> GetSourceItems()

AssemblyDependency\ReferenceTable.cs (3)

1413ICollection<ITaskItem> dependees = assemblyReference.GetSourceItems(); 1486ICollection<ITaskItem> dependees = assemblyReference.GetSourceItems(); 2700ICollection<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)

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

Microsoft.Build.Tasks.UnitTests (3)

RoslynCodeTaskFactory_Tests.cs (3)

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

Microsoft.Build.UnitTests.Shared (3)

ObjectModelHelpers.cs (3)

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)

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

Microsoft.Cci.Extensions (14)

Experimental\APIClosureTypeReferenceVisitor.cs (4)

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.CodeAnalysis (141)

Binding\AbstractLookupSymbolsInfo.cs (1)

269public ICollection<String> Names => _nameMap.Keys;

Binding\BindingDiagnosticBag.cs (3)

62public readonly ICollection<TAssemblySymbol>? DependenciesBag; 64protected BindingDiagnosticBag(DiagnosticBag? diagnosticBag, ICollection<TAssemblySymbol>? dependenciesBag) 140internal void AddDependencies(ICollection<TAssemblySymbol>? dependencies)

Binding\UseSiteInfo.cs (2)

260public void AddDiagnostics(ICollection<DiagnosticInfo>? diagnostics) 361public void AddDependencies(ICollection<TAssemblySymbol>? dependencies)

Collections\CollectionsExtensions.cs (1)

13internal static bool IsNullOrEmpty<T>([NotNullWhen(returnValue: false)] this ICollection<T>? collection)

Collections\IdentifierCollection.cs (2)

133public ICollection<string> AsCaseSensitiveCollection() 138public ICollection<string> AsCaseInsensitiveCollection()

Collections\UnionCollection.cs (9)

27private readonly ImmutableArray<ICollection<T>> _collections; 30public static ICollection<T> Create(ICollection<T> coll1, ICollection<T> coll2) 48public static ICollection<T> Create<TOrig>(ImmutableArray<TOrig> collections, Func<TOrig, ICollection<T>> selector) 65private UnionCollection(ImmutableArray<ICollection<T>> collections) 85foreach (var c in _collections) 99foreach (var collection in _collections)

Compilation\Compilation.cs (2)

3049ICollection<MethodDefinitionHandle> updatedMethods, 3070ICollection<MethodDefinitionHandle> updatedMethods,

InternalUtilities\ConcurrentSet.cs (1)

93if (items is ICollection<T> collection && collection.Count == 0) 284if (source is ICollection<T> genericCollection) 312public static bool IsEmpty<T>(this ICollection<T> source) 323/// This method is necessary to avoid an ambiguity between <see cref="IsEmpty{T}(IReadOnlyCollection{T})"/> and <see cref="IsEmpty{T}(ICollection{T})"/>. 331/// This method is necessary to avoid an ambiguity between <see cref="IsEmpty{T}(IReadOnlyCollection{T})"/> and <see cref="IsEmpty{T}(ICollection{T})"/>.

InternalUtilities\EnumerableExtensions.cs (5)

InternalUtilities\SpecializedCollections.cs (5)

21public static ICollection<T> EmptyCollection<T>() 68public static ICollection<T> SingletonCollection<T>(T value) 93public static ICollection<T> ReadOnlyCollection<T>(ICollection<T>? collection) 97: new ReadOnly.Collection<ICollection<T>, T>(collection);

InternalUtilities\SpecializedCollections.Empty.Collection.cs (1)

16public static readonly ICollection<T> Instance = new Collection<T>();

InternalUtilities\SpecializedCollections.Empty.Dictionary.cs (2)

39public ICollection<TKey> Keys 61public ICollection<TValue> Values

InternalUtilities\SpecializedCollections.ReadOnly.Collection.cs (1)

43ICollection<TKey> IDictionary<TKey, TValue>.Keys => Keys; 45ICollection<TValue> IDictionary<TKey, TValue>.Values => Values; 47bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => ICollectionCalls<KeyValuePair<TKey, TValue>>.IsReadOnly(ref _builder); 123void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)

SpecialType.cs (1)

161/// Indicates that the type is <see cref="ICollection{T}"/>.

src\Dependencies\Collections\ImmutableSegmentedDictionary`2.cs (8)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+Builder.cs (4)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+Builder+KeyCollection.cs (2)

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

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+Builder+ValueCollection.cs (3)

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

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+KeyCollection.cs (5)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+ValueBuilder.cs (5)

64readonly ICollection<TKey> IDictionary<TKey, TValue>.Keys => throw new NotSupportedException(); 66readonly ICollection<TValue> IDictionary<TKey, TValue>.Values => throw new NotSupportedException(); 68readonly bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => false; 234readonly void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) 235=> ((ICollection<KeyValuePair<TKey, TValue>>)ReadOnlyDictionary).CopyTo(array, arrayIndex);

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+ValueCollection.cs (5)

src\Dependencies\Collections\ImmutableSegmentedHashSet`1.cs (5)

87bool ICollection<T>.IsReadOnly => true; 344void ICollection<T>.CopyTo(T[] array, int arrayIndex) 383void ICollection<T>.Add(T item) 386void ICollection<T>.Clear() 389bool ICollection<T>.Remove(T item)

src\Dependencies\Collections\ImmutableSegmentedHashSet`1+Builder.cs (3)

34bool ICollection<T>.IsReadOnly => ICollectionCalls<T>.IsReadOnly(ref _builder); 115void ICollection<T>.Add(T item) 118void ICollection<T>.CopyTo(T[] array, int arrayIndex)

src\Dependencies\Collections\ImmutableSegmentedHashSet`1+ValueBuilder.cs (5)

58readonly bool ICollection<T>.IsReadOnly => false; 269void ICollection<T>.Add(T item) 270=> ((ICollection<T>)GetOrCreateMutableSet()).Add(item); 272readonly void ICollection<T>.CopyTo(T[] array, int arrayIndex) 273=> ((ICollection<T>)ReadOnlySet).CopyTo(array, arrayIndex);

src\Dependencies\Collections\ImmutableSegmentedList`1.cs (5)

src\Dependencies\Collections\ImmutableSegmentedList`1+Builder.cs (1)

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

src\Dependencies\Collections\ImmutableSegmentedList`1+ValueBuilder.cs (1)

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

src\Dependencies\Collections\Internal\ICollectionCalls`1.cs (4)

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

src\Dependencies\Collections\Internal\ICollectionDebugView`1.cs (2)

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

src\Dependencies\Collections\Internal\IDictionaryDebugView`2.cs (4)

src\Dependencies\Collections\SegmentedArray`1.cs (8)

124int ICollection<T>.Count => Length; 161void ICollection<T>.CopyTo(T[] array, int arrayIndex) 165ICollection<T> collection = _items[i]; 194void ICollection<T>.Add(T value) 209void ICollection<T>.Clear() 226bool ICollection<T>.Contains(T value) 228foreach (ICollection<T> collection in _items) 282bool ICollection<T>.Remove(T value)

src\Dependencies\Collections\SegmentedDictionary`2.cs (17)

138: this((collection as ICollection<KeyValuePair<TKey, TValue>>)?.Count ?? 0, comparer) 232ICollection<TKey> IDictionary<TKey, TValue>.Keys => Keys; 238ICollection<TValue> IDictionary<TKey, TValue>.Values => Values; 268void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> keyValuePair) 271bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> keyValuePair) 282bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> keyValuePair) 868bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => false; 870void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int index) 1339bool ICollection<TKey>.IsReadOnly => true; 1341void ICollection<TKey>.Add(TKey item) 1344void ICollection<TKey>.Clear() 1350bool ICollection<TKey>.Remove(TKey item) 1547bool ICollection<TValue>.IsReadOnly => true; 1549void ICollection<TValue>.Add(TValue item) 1552bool ICollection<TValue>.Remove(TValue item) 1558void ICollection<TValue>.Clear() 1561bool ICollection<TValue>.Contains(TValue item)

src\Dependencies\Collections\SegmentedHashSet`1.cs (8)

118if (collection is ICollection<T> coll) 194void ICollection<T>.Add(T item) => AddIfNotPresent(item, out _); 358bool ICollection<T>.IsReadOnly => false; 444if (other is ICollection<T> otherAsCollection) 583if (other is ICollection<T> otherAsCollection) 632if (other is ICollection<T> otherAsCollection) 676if (other is ICollection<T> otherAsCollection) 769other is ICollection<T> otherAsCollection &&

src\Dependencies\Collections\SegmentedList`1.cs (4)

85if (collection is ICollection<T> c) 184bool ICollection<T>.IsReadOnly => false; 302if (collection is ICollection<T> c) 902if (collection is ICollection<T> c)

Symbols\IAssemblySymbol.cs (2)

46ICollection<string> TypeNames { get; } 51ICollection<string> NamespaceNames { get; }

Syntax\SyntaxList`1.cs (2)

86var collection = nodes as ICollection<TNode>;

Syntax\SyntaxTriviaList.cs (2)

330var triviaCollection = trivia as ICollection<SyntaxTrivia>;

Microsoft.CodeAnalysis.CodeStyle (131)

src\Analyzers\Core\Analyzers\PopulateSwitch\AbstractPopulateSwitchDiagnosticAnalyzer.cs (2)

37protected abstract ICollection<ISymbol> GetMissingEnumMembers(TSwitchOperation operation); 122var missingEnumMembers = GetMissingEnumMembers(operation);

src\Analyzers\Core\Analyzers\PopulateSwitch\AbstractPopulateSwitchExpressionDiagnosticAnalyzer.cs (1)

29protected sealed override ICollection<ISymbol> GetMissingEnumMembers(ISwitchExpressionOperation operation)

src\Analyzers\Core\Analyzers\PopulateSwitch\AbstractPopulateSwitchStatementDiagnosticAnalyzer.cs (1)

29protected sealed override ICollection<ISymbol> GetMissingEnumMembers(ISwitchOperation operation)

src\Analyzers\Core\Analyzers\PopulateSwitch\PopulateSwitchExpressionHelpers.cs (1)

16public static ICollection<ISymbol> GetMissingEnumMembers(ISwitchExpressionOperation operation)

src\Analyzers\Core\Analyzers\PopulateSwitch\PopulateSwitchStatementHelpers.cs (1)

55public static ICollection<ISymbol> GetMissingEnumMembers(ISwitchOperation switchStatement)

src\Compilers\Core\Portable\InternalUtilities\ConcurrentSet.cs (1)

16public static readonly ICollection<T> Instance = new Collection<T>();

src\Compilers\Core\Portable\InternalUtilities\EnumerableExtensions.cs (5)

src\Compilers\Core\Portable\InternalUtilities\SpecializedCollections.cs (5)

src\Compilers\Core\Portable\InternalUtilities\SpecializedCollections.Empty.Collection.cs (1)

src\Compilers\Core\Portable\InternalUtilities\SpecializedCollections.Empty.Dictionary.cs (2)

39public ICollection<TKey> Keys 61public ICollection<TValue> Values

src\Compilers\Core\Portable\InternalUtilities\SpecializedCollections.ReadOnly.Collection.cs (1)

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

src\Dependencies\Collections\ImmutableSegmentedDictionary`2.cs (8)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+Builder.cs (4)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+Builder+KeyCollection.cs (2)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+Builder+ValueCollection.cs (3)

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

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+KeyCollection.cs (5)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+ValueBuilder.cs (5)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+ValueCollection.cs (5)

src\Dependencies\Collections\ImmutableSegmentedHashSet`1.cs (5)

src\Dependencies\Collections\ImmutableSegmentedHashSet`1+Builder.cs (3)

34bool ICollection<T>.IsReadOnly => ICollectionCalls<T>.IsReadOnly(ref _builder); 115void ICollection<T>.Add(T item) 118void ICollection<T>.CopyTo(T[] array, int arrayIndex)

src\Dependencies\Collections\ImmutableSegmentedHashSet`1+ValueBuilder.cs (5)

src\Dependencies\Collections\ImmutableSegmentedList`1.cs (5)

src\Dependencies\Collections\ImmutableSegmentedList`1+Builder.cs (1)

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

src\Dependencies\Collections\ImmutableSegmentedList`1+ValueBuilder.cs (1)

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

src\Dependencies\Collections\Internal\ICollectionCalls`1.cs (4)

src\Dependencies\Collections\Internal\ICollectionDebugView`1.cs (2)

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

src\Dependencies\Collections\Internal\IDictionaryDebugView`2.cs (4)

src\Dependencies\Collections\SegmentedArray`1.cs (8)

src\Dependencies\Collections\SegmentedDictionary`2.cs (17)

src\Dependencies\Collections\SegmentedHashSet`1.cs (8)

src\Dependencies\Collections\SegmentedList`1.cs (4)

85if (collection is ICollection<T> c) 184bool ICollection<T>.IsReadOnly => false; 302if (collection is ICollection<T> c) 902if (collection is ICollection<T> c)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\IAssemblySymbolExtensions.cs (1)

49var typeNames = a.TypeNames;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ICollectionExtensions.cs (3)

27public static void RemoveRange<T>(this ICollection<T> collection, IEnumerable<T>? items) 43public static void AddIfNotNull<T>(this ICollection<T> collection, T? value) where T : struct 49public static void AddIfNotNull<T>(this ICollection<T> collection, T? value) where T : class

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\ICollectionExtensions.cs (5)

14public static void AddRange<T>(this ICollection<T> collection, IEnumerable<T>? values) 30public static void AddRange<T>(this ICollection<T> collection, ArrayBuilder<T>? values) 42public static void AddRange<T>(this ICollection<T> collection, HashSet<T>? values) 54public static void AddRange<TKey, TValue>(this ICollection<TKey> collection, Dictionary<TKey, TValue>.KeyCollection? keyCollection) where TKey : notnull 66public static void AddRange<T>(this ICollection<T> collection, ImmutableArray<T> values)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\IDictionaryExtensions.cs (2)

65where TCollection : ICollection<TValue>, new() 145where TCollection : ICollection<TValue>

Microsoft.CodeAnalysis.CodeStyle.Fixes (3)

src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchCodeFixProvider.cs (1)

40protected abstract ICollection<ISymbol> GetMissingEnumMembers(TSwitchOperation switchOperation);

src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchExpressionCodeFixProvider.cs (1)

46protected sealed override ICollection<ISymbol> GetMissingEnumMembers(ISwitchExpressionOperation switchOperation)

src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchStatementCodeFixProvider.cs (1)

62protected sealed override ICollection<ISymbol> GetMissingEnumMembers(ISwitchOperation switchOperation)

Microsoft.CodeAnalysis.Collections.Package (99)

ImmutableSegmentedDictionary`2.cs (8)

ImmutableSegmentedDictionary`2+Builder.cs (4)

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)

ImmutableSegmentedDictionary`2+ValueBuilder.cs (5)

ImmutableSegmentedDictionary`2+ValueCollection.cs (5)

ImmutableSegmentedHashSet`1.cs (5)

ImmutableSegmentedHashSet`1+Builder.cs (3)

34bool ICollection<T>.IsReadOnly => ICollectionCalls<T>.IsReadOnly(ref _builder); 115void ICollection<T>.Add(T item) 118void ICollection<T>.CopyTo(T[] array, int arrayIndex)

ImmutableSegmentedHashSet`1+ValueBuilder.cs (5)

ImmutableSegmentedList`1.cs (5)

ImmutableSegmentedList`1+Builder.cs (1)

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

ImmutableSegmentedList`1+ValueBuilder.cs (1)

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

Internal\ICollectionCalls`1.cs (4)

Internal\ICollectionDebugView`1.cs (2)

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

Internal\IDictionaryDebugView`2.cs (4)

SegmentedArray`1.cs (8)

SegmentedDictionary`2.cs (17)

SegmentedHashSet`1.cs (8)

SegmentedList`1.cs (4)

85if (collection is ICollection<T> c) 184bool ICollection<T>.IsReadOnly => false; 302if (collection is ICollection<T> c) 902if (collection is ICollection<T> c)

Microsoft.CodeAnalysis.CSharp (43)

Binder\BindingDiagnosticBag.cs (2)

24private BindingDiagnosticBag(DiagnosticBag? diagnosticBag, ICollection<AssemblySymbol>? dependenciesBag) 29private BindingDiagnosticBag(ObjectPool<BindingDiagnosticBag> pool, DiagnosticBag? diagnosticBag, ICollection<AssemblySymbol>? dependenciesBag)

Declarations\DeclarationTable.cs (8)

40private ICollection<string>? _typeNames; 41private ICollection<string>? _namespaceNames; 42private ICollection<ReferenceDirective>? _referenceDirectives; 158private ICollection<string> GetMergedTypeNames() 172private ICollection<string> GetMergedNamespaceNames() 186private ICollection<ReferenceDirective> GetMergedReferenceDirectives() 241public ICollection<string> TypeNames 252public ICollection<string> NamespaceNames

Declarations\MergedTypeDeclaration.cs (3)

25private ICollection<string> _lazyMemberNames; 240public ICollection<string> MemberNames 246var names = UnionCollection<string>.Create(this.Declarations, d => d.MemberNames.Value);

Symbols\AssemblySymbol.cs (2)

584public abstract ICollection<string> TypeNames { get; } 589public abstract ICollection<string> NamespaceNames { get; }

Symbols\Compilation_UsedAssemblies.cs (1)

225internal void AddUsedAssemblies(ICollection<AssemblySymbol>? assemblies)

Symbols\Metadata\PE\PEModuleSymbol.cs (4)

94private ICollection<string> _lazyTypeNames; 97private ICollection<string> _lazyNamespaceNames; 503internal override ICollection<string> TypeNames 516internal override ICollection<string> NamespaceNames

Symbols\Metadata\PE\PENamedTypeSymbol.cs (3)

44private ICollection<string> _lazyMemberNames; 872private static ICollection<string> CreateReadOnlyMemberNames(HashSet<string> names) 1501var memberNames = SpecializedCollections.ReadOnlyCollection(membersDict.Keys);

Symbols\MetadataOrSourceAssemblySymbol.cs (4)

119private ICollection<string> _lazyTypeNames; 120private ICollection<string> _lazyNamespaceNames; 122public override ICollection<string> TypeNames 159public override ICollection<string> NamespaceNames

Symbols\MissingAssemblySymbol.cs (2)

152public override ICollection<string> TypeNames 160public override ICollection<string> NamespaceNames

Symbols\MissingModuleSymbol.cs (2)

130internal override ICollection<string> NamespaceNames 138internal override ICollection<string> TypeNames

Symbols\ModuleSymbol.cs (2)

306internal abstract ICollection<string> TypeNames { get; } 308internal abstract ICollection<string> NamespaceNames { get; }

Symbols\PublicModel\AssemblySymbol.cs (2)

44ICollection<string> IAssemblySymbol.TypeNames => UnderlyingAssemblySymbol.TypeNames; 46ICollection<string> IAssemblySymbol.NamespaceNames => UnderlyingAssemblySymbol.NamespaceNames;

Symbols\Retargeting\RetargetingAssemblySymbol.cs (2)

256public override ICollection<string> TypeNames 264public override ICollection<string> NamespaceNames

Symbols\Retargeting\RetargetingModuleSymbol.cs (2)

260internal override ICollection<string> TypeNames 268internal override ICollection<string> NamespaceNames

Symbols\Source\SourceModuleSymbol.cs (2)

466internal override ICollection<string> TypeNames 474internal override ICollection<string> NamespaceNames

Syntax\SyntaxFactory.cs (2)

1360var collection = nodes as ICollection<TNode>;

Microsoft.CodeAnalysis.CSharp.CodeStyle (1)

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForFluentDiagnosticAnalyzer.cs (1)

53nameof(ICollection<int>),

Microsoft.CodeAnalysis.CSharp.Features (1)

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForFluentDiagnosticAnalyzer.cs (1)

53nameof(ICollection<int>),

Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (1)

Semantics\LookupTests.cs (1)

433var actual_lookupNames = info.Names;

Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (2)

Symbols\MockAssemblySymbol.cs (2)

102public override ICollection<string> TypeNames 110public override ICollection<string> NamespaceNames

Microsoft.CodeAnalysis.CSharp.Workspaces (1)

Rename\CSharpRenameRewriterLanguageService.cs (1)

1089public override void TryAddPossibleNameConflicts(ISymbol symbol, string replacementText, ICollection<string> possibleNameConflicts)

Microsoft.CodeAnalysis.EditorFeatures (1)

Tagging\AbstractAsynchronousTaggerProvider.TagSource_TagsChanged.cs (1)

24ICollection<KeyValuePair<ITextBuffer, DiffResult>> changes, bool highPriority)

Microsoft.CodeAnalysis.ExpressionEvaluator.FunctionResolver (1)

src\Compilers\Core\Portable\SpecialType.cs (1)

161/// Indicates that the type is <see cref="ICollection{T}"/>.

Microsoft.CodeAnalysis.Features (10)

EditAndContinue\EmitSolutionUpdateResults.cs (1)

234bool AddImpactedRunningProjects(ICollection<ProjectId> impactedProjects, Project initialProject)

src\Analyzers\Core\Analyzers\PopulateSwitch\AbstractPopulateSwitchDiagnosticAnalyzer.cs (2)

37protected abstract ICollection<ISymbol> GetMissingEnumMembers(TSwitchOperation operation); 122var missingEnumMembers = GetMissingEnumMembers(operation);

src\Analyzers\Core\Analyzers\PopulateSwitch\AbstractPopulateSwitchExpressionDiagnosticAnalyzer.cs (1)

29protected sealed override ICollection<ISymbol> GetMissingEnumMembers(ISwitchExpressionOperation operation)

src\Analyzers\Core\Analyzers\PopulateSwitch\AbstractPopulateSwitchStatementDiagnosticAnalyzer.cs (1)

29protected sealed override ICollection<ISymbol> GetMissingEnumMembers(ISwitchOperation operation)

src\Analyzers\Core\Analyzers\PopulateSwitch\PopulateSwitchExpressionHelpers.cs (1)

16public static ICollection<ISymbol> GetMissingEnumMembers(ISwitchExpressionOperation operation)

src\Analyzers\Core\Analyzers\PopulateSwitch\PopulateSwitchStatementHelpers.cs (1)

55public static ICollection<ISymbol> GetMissingEnumMembers(ISwitchOperation switchStatement)

src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchCodeFixProvider.cs (1)

40protected abstract ICollection<ISymbol> GetMissingEnumMembers(TSwitchOperation switchOperation);

src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchExpressionCodeFixProvider.cs (1)

46protected sealed override ICollection<ISymbol> GetMissingEnumMembers(ISwitchExpressionOperation switchOperation)

src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchStatementCodeFixProvider.cs (1)

62protected sealed override ICollection<ISymbol> GetMissingEnumMembers(ISwitchOperation switchOperation)

Microsoft.CodeAnalysis.LanguageServer (2)

Testing\TestRunner.TestRunHandler.cs (2)

43public void HandleTestRunComplete(TestRunCompleteEventArgs testRunCompleteArgs, TestRunChangedEventArgs? lastChunkArgs, ICollection<AttachmentSet>? runContextAttachments, ICollection<string>? executorUris)

Microsoft.CodeAnalysis.UnitTests (85)

Collections\HashSet\ISet_Generic_Tests`1.cs (4)

53protected override void AddToCollection(ICollection<T> collection, int numberOfItemsToAdd) 72protected override ICollection<T> GenericICollectionFactory() => GenericISetFactory(); 74protected override ICollection<T> GenericICollectionFactory(int count) => GenericISetFactory(count); 110ICollection<T> collection = GenericICollectionFactory(count);

Collections\IdentifierCollectionTests.cs (7)

38var idcol = new IdentifierCollection(strings).AsCaseSensitiveCollection(); 55var idcol = new IdentifierCollection(strings).AsCaseInsensitiveCollection(); 78private void TestReadOnly(ICollection<string> collection) 86private void AssertContains(ICollection<string> collection, params string[] strings) 91private void AssertContains(ICollection<string> collection, IEnumerable<string> strings) 99private void AssertNotContains(ICollection<string> collection, params string[] strings) 104private void AssertNotContains(ICollection<string> collection, IEnumerable<string> strings)

Collections\ImmutableDictionaryTestBase.cs (2)

130var dictionary = (ICollection<KeyValuePair<string, int>>)Empty<string, int>();

Collections\ImmutableDictionaryTestBase.nonnetstandard.cs (1)

284private static void KeysOrValuesTestHelper<T>(ICollection<T> collection, T containedValue)

Collections\ImmutableSegmentedHashSetBuilderTest.cs (1)

276ICollection<string> builder = ImmutableSegmentedHashSet.Create("a").ToBuilder();

Collections\ImmutableSegmentedListBuilderTest.cs (2)

249ICollection<int> builder = ImmutableSegmentedList.Create<int>().ToBuilder(); 296ICollection<int> builder = ImmutableSegmentedList.Create<int>().ToBuilder();

Collections\ImmutableSetTest.cs (2)

182var set = (ICollection<int>)this.Empty<int>();

Collections\ImmutablesTestBase.cs (2)

44internal static void CollectionAssertAreEquivalent<T>(ICollection<T> expected, ICollection<T> actual)

Collections\List\CollectionAsserts.cs (4)

46public static void Equal<T>(ICollection<T> expected, ICollection<T> actual) 91public static void EqualUnordered<T>(ICollection<T> expected, ICollection<T> actual)

Collections\List\ICollection.Generic.Tests.cs (49)

Collections\List\IList.Generic.Tests.cs (2)

100protected override ICollection<T> GenericICollectionFactory() => GenericIListFactory(); 102protected override ICollection<T> GenericICollectionFactory(int count) => GenericIListFactory(count);

Collections\List\SegmentedList.Generic.Tests.AddRange.cs (1)

149ICollection<T> collection = new CollectionWithLargeCount();

Collections\SegmentedArrayTests.cs (7)

60Assert.Equal(0, ((ICollection<IntPtr>)data).Count); 65Assert.Throws<NullReferenceException>(() => ((ICollection<IntPtr>)data).CopyTo(Array.Empty<IntPtr>(), 0)); 77Assert.Throws<NotSupportedException>(() => ((ICollection<IntPtr>)data).Add(IntPtr.Zero)); 78Assert.Throws<NotSupportedException>(() => ((ICollection<IntPtr>)data).Clear()); 82Assert.Throws<NotSupportedException>(() => ((ICollection<IntPtr>)data).Remove(IntPtr.Zero)); 88Assert.Throws<NullReferenceException>(() => ((ICollection<IntPtr>)data).Contains(IntPtr.Zero)); 132Assert.Equal(length, ((ICollection<IntPtr>)data).Count);

InternalUtilities\SpecializedCollectionsTests.cs (1)

39Assert.Throws<NotSupportedException>(() => ((ICollection<int>)(emptySet)).Add(0));

Microsoft.CodeAnalysis.VisualBasic (8)

Declarations\MergedTypeDeclaration.vb (2)

25Private _memberNames As ICollection(Of String) 175Public ReadOnly Property MemberNames As ICollection(Of String)

Symbols\AssemblySymbol.vb (2)

461Public MustOverride ReadOnly Property TypeNames As ICollection(Of String) Implements IAssemblySymbol.TypeNames 463Public MustOverride ReadOnly Property NamespaceNames As ICollection(Of String) Implements IAssemblySymbol.NamespaceNames

Symbols\Retargeting\RetargetingAssemblySymbol.vb (2)

221Public Overrides ReadOnly Property TypeNames As ICollection(Of String) 227Public Overrides ReadOnly Property NamespaceNames As ICollection(Of String)

Symbols\Retargeting\RetargetingModuleSymbol.vb (2)

241Friend Overrides ReadOnly Property TypeNames As ICollection(Of String) 247Friend Overrides ReadOnly Property NamespaceNames As ICollection(Of String)

Microsoft.CodeAnalysis.Workspaces (127)

Rename\IRenameRewriterLanguageService.cs (2)

38ICollection<string> possibleNameConflicts); 130public abstract void TryAddPossibleNameConflicts(ISymbol symbol, string newName, ICollection<string> possibleNameConflicts);

src\Compilers\Core\Portable\InternalUtilities\ConcurrentSet.cs (1)

16public static readonly ICollection<T> Instance = new Collection<T>();

src\Compilers\Core\Portable\InternalUtilities\EnumerableExtensions.cs (5)

src\Compilers\Core\Portable\InternalUtilities\SpecializedCollections.cs (5)

src\Compilers\Core\Portable\InternalUtilities\SpecializedCollections.Empty.Collection.cs (1)

src\Compilers\Core\Portable\InternalUtilities\SpecializedCollections.Empty.Dictionary.cs (2)

39public ICollection<TKey> Keys 61public ICollection<TValue> Values

src\Compilers\Core\Portable\InternalUtilities\SpecializedCollections.ReadOnly.Collection.cs (1)

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

src\Dependencies\Collections\ImmutableSegmentedDictionary`2.cs (8)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+Builder.cs (4)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+Builder+KeyCollection.cs (2)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+Builder+ValueCollection.cs (3)

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

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+KeyCollection.cs (5)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+ValueBuilder.cs (5)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+ValueCollection.cs (5)

src\Dependencies\Collections\ImmutableSegmentedHashSet`1.cs (5)

src\Dependencies\Collections\ImmutableSegmentedHashSet`1+Builder.cs (3)

34bool ICollection<T>.IsReadOnly => ICollectionCalls<T>.IsReadOnly(ref _builder); 115void ICollection<T>.Add(T item) 118void ICollection<T>.CopyTo(T[] array, int arrayIndex)

src\Dependencies\Collections\ImmutableSegmentedHashSet`1+ValueBuilder.cs (5)

src\Dependencies\Collections\ImmutableSegmentedList`1.cs (5)

src\Dependencies\Collections\ImmutableSegmentedList`1+Builder.cs (1)

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

src\Dependencies\Collections\ImmutableSegmentedList`1+ValueBuilder.cs (1)

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

src\Dependencies\Collections\Internal\ICollectionCalls`1.cs (4)

src\Dependencies\Collections\Internal\ICollectionDebugView`1.cs (2)

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

src\Dependencies\Collections\Internal\IDictionaryDebugView`2.cs (4)

src\Dependencies\Collections\SegmentedArray`1.cs (8)

src\Dependencies\Collections\SegmentedDictionary`2.cs (17)

src\Dependencies\Collections\SegmentedHashSet`1.cs (8)

src\Dependencies\Collections\SegmentedList`1.cs (4)

85if (collection is ICollection<T> c) 184bool ICollection<T>.IsReadOnly => false; 302if (collection is ICollection<T> c) 902if (collection is ICollection<T> c)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\IAssemblySymbolExtensions.cs (1)

49var typeNames = a.TypeNames;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ICollectionExtensions.cs (3)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\ICollectionExtensions.cs (5)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\IDictionaryExtensions.cs (2)

65where TCollection : ICollection<TValue>, new() 145where TCollection : ICollection<TValue>

Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (120)

Build\ProjectBuildManager.cs (1)

88var loadedProjects = projectCollection?.GetLoadedProjects(path);

MSBuild\ProjectFile\Extensions.cs (1)

38var packageReferenceItems = executedProject.GetItems(ItemNames.PackageReference);

MSBuild\ProjectFile\ProjectFile.cs (4)

392var items = _loadedProject.GetItems(ItemNames.Compile); 436var references = _loadedProject.GetItems(ItemNames.Reference); 517var references = _loadedProject.GetItems(ItemNames.ProjectReference); 552var analyzers = _loadedProject.GetItems(ItemNames.Analyzer);

src\Compilers\Core\Portable\InternalUtilities\ConcurrentSet.cs (1)

16public static readonly ICollection<T> Instance = new Collection<T>();

src\Compilers\Core\Portable\InternalUtilities\EnumerableExtensions.cs (5)

src\Compilers\Core\Portable\InternalUtilities\SpecializedCollections.cs (5)

src\Compilers\Core\Portable\InternalUtilities\SpecializedCollections.Empty.Collection.cs (1)

src\Compilers\Core\Portable\InternalUtilities\SpecializedCollections.Empty.Dictionary.cs (2)

39public ICollection<TKey> Keys 61public ICollection<TValue> Values

src\Compilers\Core\Portable\InternalUtilities\SpecializedCollections.ReadOnly.Collection.cs (1)

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

src\Dependencies\Collections\ImmutableSegmentedDictionary`2.cs (8)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+Builder.cs (4)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+Builder+KeyCollection.cs (2)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+Builder+ValueCollection.cs (3)

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

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+KeyCollection.cs (5)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+ValueBuilder.cs (5)

src\Dependencies\Collections\ImmutableSegmentedDictionary`2+ValueCollection.cs (5)

src\Dependencies\Collections\ImmutableSegmentedHashSet`1.cs (5)

src\Dependencies\Collections\ImmutableSegmentedHashSet`1+Builder.cs (3)

34bool ICollection<T>.IsReadOnly => ICollectionCalls<T>.IsReadOnly(ref _builder); 115void ICollection<T>.Add(T item) 118void ICollection<T>.CopyTo(T[] array, int arrayIndex)

src\Dependencies\Collections\ImmutableSegmentedHashSet`1+ValueBuilder.cs (5)

src\Dependencies\Collections\ImmutableSegmentedList`1.cs (5)

src\Dependencies\Collections\ImmutableSegmentedList`1+Builder.cs (1)

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

src\Dependencies\Collections\ImmutableSegmentedList`1+ValueBuilder.cs (1)

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

src\Dependencies\Collections\Internal\ICollectionCalls`1.cs (4)

src\Dependencies\Collections\Internal\ICollectionDebugView`1.cs (2)

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

src\Dependencies\Collections\Internal\IDictionaryDebugView`2.cs (4)

src\Dependencies\Collections\SegmentedArray`1.cs (8)

src\Dependencies\Collections\SegmentedDictionary`2.cs (17)

src\Dependencies\Collections\SegmentedHashSet`1.cs (8)

src\Dependencies\Collections\SegmentedList`1.cs (4)

85if (collection is ICollection<T> c) 184bool ICollection<T>.IsReadOnly => false; 302if (collection is ICollection<T> c) 902if (collection is ICollection<T> c)

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.Data.Analysis (58)

DataFrame.Join.cs (9)

DataFrameColumn.cs (6)

255public virtual Dictionary<TKey, ICollection<long>> GroupColumnValues<TKey>(out HashSet<long> nullIndices) => throw new NotImplementedException(); 263public abstract Dictionary<long, ICollection<long>> GetGroupedOccurrences(DataFrameColumn other, out HashSet<long> otherColumnNullIndices); 272protected Dictionary<long, ICollection<long>> GetGroupedOccurrences<TKey>(DataFrameColumn other, out HashSet<long> otherColumnNullIndices) 278Dictionary<TKey, ICollection<long>> multimap = other.GroupColumnValues<TKey>(out otherColumnNullIndices); 280var ret = new Dictionary<long, ICollection<long>>(); 286if (value != null && multimap.TryGetValue((TKey)value, out ICollection<long> otherRowIndices))

DataFrameColumns\ArrowStringDataFrameColumn.cs (8)

DataFrameColumns\StringDataFrameColumn.cs (10)

384internal static DataFrame ValueCountsImplementation(Dictionary<string, ICollection<long>> groupedValues) 388foreach (KeyValuePair<string, ICollection<long>> keyValuePair in groupedValues) 398Dictionary<string, ICollection<long>> groupedValues = GroupColumnValues<string>(out HashSet<long> _); 404Dictionary<string, ICollection<long>> dictionary = GroupColumnValues<string>(out HashSet<long> _); 408public override Dictionary<TKey, ICollection<long>> GroupColumnValues<TKey>(out HashSet<long> nullIndices) 412Dictionary<string, ICollection<long>> multimap = new Dictionary<string, ICollection<long>>(EqualityComparer<string>.Default); 419bool containsKey = multimap.TryGetValue(str, out ICollection<long> values); 434return multimap as Dictionary<TKey, ICollection<long>>; 534public override Dictionary<long, ICollection<long>> GetGroupedOccurrences(DataFrameColumn other, out HashSet<long> otherColumnNullIndices)

DataFrameColumns\VBufferDataFrameColumn.cs (1)

180public override Dictionary<long, ICollection<long>> GetGroupedOccurrences(DataFrameColumn other, out HashSet<long> otherColumnNullIndices)

GroupBy.cs (15)

PrimitiveDataFrameColumn.cs (9)

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.AI (17)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (2)

47public static IEnumerable<T> EmptyIfNull<T>(this ICollection<T>? collection) 112if (enumerable is ICollection<T> c && c.Count == 0)

src\Shared\EmptyCollections\EmptyReadonlyDictionary.cs (8)

src\Shared\EmptyCollections\EmptyReadOnlyList.cs (6)

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

59bool ICollection<TEmbedding>.IsReadOnly => false;

Microsoft.Extensions.AI.Abstractions (29)

AdditionalPropertiesDictionary{TValue}.cs (11)

Embeddings\GeneratedEmbeddings.cs (1)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (2)

47public static IEnumerable<T> EmptyIfNull<T>(this ICollection<T>? collection) 112if (enumerable is ICollection<T> c && c.Count == 0)

src\Shared\EmptyCollections\EmptyReadonlyDictionary.cs (8)

src\Shared\EmptyCollections\EmptyReadOnlyList.cs (6)

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

38Assert.False(((ICollection<Embedding<float>>)instance).IsReadOnly);

Microsoft.Extensions.AI.Abstractions.Tests (1)

Embeddings\GeneratedEmbeddingsTests.cs (1)

Microsoft.Extensions.AI.AzureAIInference (17)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (2)

47public static IEnumerable<T> EmptyIfNull<T>(this ICollection<T>? collection) 112if (enumerable is ICollection<T> c && c.Count == 0)

src\Shared\EmptyCollections\EmptyReadonlyDictionary.cs (8)

src\Shared\EmptyCollections\EmptyReadOnlyList.cs (6)

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

Microsoft.Extensions.AI.Integration.Tests (1)

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

47public static IEnumerable<T> EmptyIfNull<T>(this ICollection<T>? collection) 112if (enumerable is ICollection<T> c && c.Count == 0)

Microsoft.Extensions.AI.Ollama (17)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (2)

src\Shared\EmptyCollections\EmptyReadonlyDictionary.cs (8)

src\Shared\EmptyCollections\EmptyReadOnlyList.cs (6)

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

47public static IEnumerable<T> EmptyIfNull<T>(this ICollection<T>? collection) 112if (enumerable is ICollection<T> c && c.Count == 0)

Microsoft.Extensions.AI.OpenAI (17)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (2)

src\Shared\EmptyCollections\EmptyReadonlyDictionary.cs (8)

src\Shared\EmptyCollections\EmptyReadOnlyList.cs (6)

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

16public ICollection<string> Keys => _storage.Keys;

Microsoft.Extensions.AI.Tests (1)

TestInMemoryCacheStorage.cs (1)

Microsoft.Extensions.AmbientMetadata.Application (1)

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

Microsoft.Extensions.AsyncState (1)

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

79null or ICollection<string> { Count: 0 } => default, 80ICollection<string> { Count: 1 } => RemoveAsync(keys.First(), cancellationToken), 103null or ICollection<string> { Count: 0 } => default, 104ICollection<string> { Count: 1 } => RemoveByTagAsync(tags.Single(), cancellationToken),

Microsoft.Extensions.Caching.Abstractions (4)

Hybrid\HybridCache.cs (4)

Microsoft.Extensions.Caching.Hybrid (2)

Internal\TagSet.cs (1)

104if (tags is ICollection<string> collection)

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

716private ICollection<KeyValuePair<string, CacheEntry>> StringEntriesCollection => _stringEntries; 717private ICollection<KeyValuePair<object, CacheEntry>> NonStringEntriesCollection => _nonStringEntries;

Microsoft.Extensions.Caching.Memory (2)

MemoryCache.cs (2)

Microsoft.Extensions.Compliance.Abstractions (1)

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

19/// on .NET Framework, while <see cref="System.Collections.Generic.ICollection{T}"/> type is supported only on .NET Core.

Microsoft.Extensions.Compliance.Redaction (2)

src\Shared\Data.Validation\LengthAttribute.cs (1)

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

Microsoft.Extensions.Compliance.Testing (1)

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

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

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)

Microsoft.Extensions.DependencyInjection (2)

ServiceLookup\CallSiteFactory.cs (1)

24public CallSiteFactory(ICollection<ServiceDescriptor> descriptors)

ServiceProvider.cs (1)

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

Microsoft.Extensions.DependencyInjection.Abstractions (1)

ServiceCollection.cs (1)

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

Microsoft.Extensions.DependencyInjection.AutoActivation (1)

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

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

Microsoft.Extensions.Diagnostics (1)

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

Microsoft.Extensions.Diagnostics.ExceptionSummarization (1)

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

42var registrations = _options.Value.Registrations;

Microsoft.Extensions.Diagnostics.HealthChecks (2)

DefaultHealthCheckService.cs (1)

HealthCheckServiceOptions.cs (1)

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

Microsoft.Extensions.Diagnostics.HealthChecks.Common (1)

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

56var registrations = serviceProvider.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value.Registrations;

Microsoft.Extensions.Diagnostics.HealthChecks.Common.Tests (2)

ApplicationLifecycleHealthChecksExtensionsTests.cs (1)

ManualHealthCheckExtensionsTests.cs (1)

51var registrations = serviceProvider.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value.Registrations;

Microsoft.Extensions.Diagnostics.Probes (2)

src\Shared\Data.Validation\LengthAttribute.cs (1)

19/// on .NET Framework, while <see cref="System.Collections.Generic.ICollection{T}"/> type is supported only on .NET Core.

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

19/// on .NET Framework, while <see cref="System.Collections.Generic.ICollection{T}"/> type is supported only on .NET Core.

Microsoft.Extensions.Diagnostics.ResourceMonitoring (2)

src\Shared\Data.Validation\LengthAttribute.cs (1)

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

Microsoft.Extensions.Diagnostics.Testing (1)

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

Microsoft.Extensions.Hosting.Testing (1)

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

47public static IEnumerable<T> EmptyIfNull<T>(this ICollection<T>? collection) 112if (enumerable is ICollection<T> c && c.Count == 0)

Microsoft.Extensions.Http.Diagnostics (16)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (2)

src\Shared\EmptyCollections\EmptyReadonlyDictionary.cs (8)

src\Shared\EmptyCollections\EmptyReadOnlyList.cs (6)

Microsoft.Extensions.Http.Resilience (2)

src\Shared\Data.Validation\LengthAttribute.cs (1)

19/// on .NET Framework, while <see cref="System.Collections.Generic.ICollection{T}"/> type is supported only on .NET Core.

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

Microsoft.Extensions.ObjectPool.DependencyInjection (1)

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

Microsoft.Extensions.Options.Contextual (1)

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

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

Microsoft.Extensions.Options.SourceGeneration (2)

Emitter.cs (1)

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.Extensions.Resilience (1)

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

38var enrichers = _services.BuildServiceProvider().GetRequiredService<IOptions<TelemetryOptions>>().Value.MeteringEnrichers; 48var enrichers = services.BuildServiceProvider().GetRequiredService<IOptions<TelemetryOptions>>().Value.MeteringEnrichers;

Microsoft.Extensions.Resilience.Tests (2)

Resilience\ResilienceServiceCollectionExtensionsTests.cs (2)

Microsoft.Extensions.Telemetry (2)

src\Shared\Data.Validation\LengthAttribute.cs (1)

19/// on .NET Framework, while <see cref="System.Collections.Generic.ICollection{T}"/> type is supported only on .NET Core.

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

Microsoft.Extensions.Telemetry.Abstractions (1)

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

Microsoft.Extensions.TimeProvider.Testing (1)

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

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

Microsoft.Gen.ComplianceReports (1)

src\Generators\Shared\TypeDeclarationSyntaxReceiver.cs (1)

Microsoft.Gen.ComplianceReports.Unit.Tests (16)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (2)

47public static IEnumerable<T> EmptyIfNull<T>(this ICollection<T>? collection) 112if (enumerable is ICollection<T> c && c.Count == 0)

src\Shared\EmptyCollections\EmptyReadonlyDictionary.cs (8)

src\Shared\EmptyCollections\EmptyReadOnlyList.cs (6)

Microsoft.Gen.ContextualOptions.Unit.Tests (16)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (2)

47public static IEnumerable<T> EmptyIfNull<T>(this ICollection<T>? collection) 112if (enumerable is ICollection<T> c && c.Count == 0)

src\Shared\EmptyCollections\EmptyReadonlyDictionary.cs (8)

src\Shared\EmptyCollections\EmptyReadOnlyList.cs (6)

Microsoft.Gen.Logging (2)

src\Generators\Shared\ClassDeclarationSyntaxReceiver.cs (1)

25public ICollection<ClassDeclarationSyntax> ClassDeclarations { get; } = new List<ClassDeclarationSyntax>();

src\Generators\Shared\TypeDeclarationSyntaxReceiver.cs (1)

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

Microsoft.Gen.Logging.Unit.Tests (16)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (2)

47public static IEnumerable<T> EmptyIfNull<T>(this ICollection<T>? collection) 112if (enumerable is ICollection<T> c && c.Count == 0)

src\Shared\EmptyCollections\EmptyReadonlyDictionary.cs (8)

src\Shared\EmptyCollections\EmptyReadOnlyList.cs (6)

Microsoft.Gen.MetadataExtractor (2)

src\Generators\Shared\ClassDeclarationSyntaxReceiver.cs (1)

25public ICollection<ClassDeclarationSyntax> ClassDeclarations { get; } = new List<ClassDeclarationSyntax>();

src\Generators\Shared\TypeDeclarationSyntaxReceiver.cs (1)

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

Microsoft.Gen.MetadataExtractor.Unit.Tests (16)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (2)

47public static IEnumerable<T> EmptyIfNull<T>(this ICollection<T>? collection) 112if (enumerable is ICollection<T> c && c.Count == 0)

src\Shared\EmptyCollections\EmptyReadonlyDictionary.cs (8)

src\Shared\EmptyCollections\EmptyReadOnlyList.cs (6)

Microsoft.Gen.Metrics (2)

src\Generators\Shared\ClassDeclarationSyntaxReceiver.cs (1)

25public ICollection<ClassDeclarationSyntax> ClassDeclarations { get; } = new List<ClassDeclarationSyntax>();

src\Generators\Shared\TypeDeclarationSyntaxReceiver.cs (1)

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

Microsoft.Gen.Metrics.Unit.Tests (16)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (2)

47public static IEnumerable<T> EmptyIfNull<T>(this ICollection<T>? collection) 112if (enumerable is ICollection<T> c && c.Count == 0)

src\Shared\EmptyCollections\EmptyReadonlyDictionary.cs (8)

src\Shared\EmptyCollections\EmptyReadOnlyList.cs (6)

Microsoft.Gen.MetricsReports (1)

src\Generators\Shared\ClassDeclarationSyntaxReceiver.cs (1)

25public ICollection<ClassDeclarationSyntax> ClassDeclarations { get; } = new List<ClassDeclarationSyntax>();

Microsoft.Gen.MetricsReports.Unit.Tests (16)

src\Shared\EmptyCollections\EmptyCollectionExtensions.cs (2)

47public static IEnumerable<T> EmptyIfNull<T>(this ICollection<T>? collection) 112if (enumerable is ICollection<T> c && c.Count == 0)

src\Shared\EmptyCollections\EmptyReadonlyDictionary.cs (8)

src\Shared\EmptyCollections\EmptyReadOnlyList.cs (6)

Microsoft.Interop.SourceGeneration (8)

Marshalling\MarshallerHelpers.cs (1)

120ICollection<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.Maui.Controls (46)

Element\Element.cs (7)

1086 int ICollection<Element>.Count => _inner.Count; 1088 bool ICollection<Element>.IsReadOnly => true; 1090 void ICollection<Element>.Add(Element item) => throw new NotSupportedException(); 1092 void ICollection<Element>.Clear() => throw new NotSupportedException(); 1094 bool ICollection<Element>.Contains(Element item) => _inner.IndexOf(item) != -1; 1096 void ICollection<Element>.CopyTo(Element[] array, int arrayIndex) => throw new NotSupportedException(); 1106 bool ICollection<Element>.Remove(Element item) => throw new NotSupportedException();

Layout\Layout.cs (1)

55 public bool IsReadOnly => ((ICollection<IView>)_children).IsReadOnly;

LegacyLayouts\LayoutOfT.cs (8)

11 int ICollection<IView>.Count => _children.Count; 12 bool ICollection<IView>.IsReadOnly => ((ICollection<IView>)_children).IsReadOnly; 17 void ICollection<IView>.Add(IView child) 25 bool ICollection<IView>.Remove(IView child) 54 void ICollection<IView>.Clear() 59 bool ICollection<IView>.Contains(IView child) 64 void ICollection<IView>.CopyTo(IView[] array, int arrayIndex)

NavigationStepRequest.cs (1)

99 bool ICollection<NavigationStepRequest>.Remove(NavigationStepRequest item)

OrderedDictionary.cs (10)

ResourceDictionary.cs (13)

Shell\ShellNavigationQueryParameters.cs (4)

51 public ICollection<string> Keys => _internal.Keys; 53 public ICollection<object> Values => _internal.Values; 82 => (_internal as ICollection<KeyValuePair<string, object>>)?.CopyTo(array, arrayIndex); 95 return (_internal as ICollection<KeyValuePair<string, object>>).Remove(item);

SynchronizedList.cs (1)

49 bool ICollection<T>.IsReadOnly

TableView\TableSection.cs (1)

70 bool ICollection<T>.IsReadOnly

Microsoft.Maui.Controls.Build.Tasks (4)

SetPropertiesVisitor.cs (2)

1655 var names = context.Cache.GetResourceNamesInUse(parent); 1706 var names = context.Cache.GetResourceNamesInUse(parent);

XamlCache.cs (2)

20 readonly Dictionary<VariableDefinition, ICollection<string>> _resourceNamesInUse = new(); 53 public ICollection<string> GetResourceNamesInUse(VariableDefinition variableDefinition) =>

Microsoft.ML.AutoML (15)

API\BinaryClassificationExperiment.cs (1)

37public ICollection<BinaryClassificationTrainer> Trainers { get; }

API\ColumnInference.cs (5)

97public ICollection<string> CategoricalColumnNames { get; private set; } 104public ICollection<string> NumericColumnNames { get; private set; } 111public ICollection<string> TextColumnNames { get; private set; } 118public ICollection<string> IgnoredColumnNames { get; private set; } 125public ICollection<string> ImagePathColumnNames { get; private set; }

API\MulticlassClassificationExperiment.cs (1)

37public ICollection<MulticlassClassificationTrainer> Trainers { get; }

API\RankingExperiment.cs (1)

28public ICollection<RankingTrainer> Trainers { get; }

API\RecommendationExperiment.cs (1)

27public ICollection<RecommendationTrainer> Trainers { get; }

API\RegressionExperiment.cs (1)

37public ICollection<RegressionTrainer> Trainers { get; }

Experiment\SuggestedPipelineBuilder.cs (3)

13ICollection<SuggestedTransform> transforms, 14ICollection<SuggestedTransform> transformsPostTrainer, 26ICollection<SuggestedTransform> transforms)

PipelineSuggesters\PipelineSuggester.cs (2)

123ICollection<SuggestedTransform> transforms, 124ICollection<SuggestedTransform> transformsPostTrainer,

Microsoft.ML.Core (15)

Utilities\Contracts.cs (13)

79private static int Size<T>(ICollection<T> c) 674public static ICollection<T> CheckNonEmpty<T>(ICollection<T> args, string paramName) 680public static ICollection<T> CheckNonEmpty<T>(this IExceptionContext ctx, ICollection<T> args, string paramName) 686public static ICollection<T> CheckNonEmpty<T>(ICollection<T> args, string paramName, string msg) 692public static ICollection<T> CheckNonEmpty<T>(this IExceptionContext ctx, ICollection<T> args, string paramName, string msg) 967public static void AssertNonEmpty<T>(ICollection<T> args) 973public static void AssertNonEmpty<T>(this IExceptionContext ctx, ICollection<T> args) 980public static void AssertNonEmpty<T>(ICollection<T> args, string msg) 986public static void AssertNonEmpty<T>(this IExceptionContext ctx, ICollection<T> args, string msg)

Utilities\Tree.cs (2)

70public ICollection<TKey> Keys { get { return _children.Keys; } } 74public ICollection<Tree<TKey, TValue>> Values { get { return _children.Values; } }

Microsoft.ML.CpuMath (13)

src\Microsoft.ML.Core\Utilities\Contracts.cs (13)

Microsoft.ML.Data (1)

DataView\DataViewConstructionUtils.cs (1)

701=> (_data as ICollection<TRow>)?.Count;

Microsoft.ML.Fairlearn (1)

Reductions\GridSearchTrialRunner.cs (1)

58var key = lambdas.Keys;

Microsoft.ML.SearchSpace (20)

Option\NestOption.cs (9)

80public ICollection<string> Keys => ((IDictionary<string, OptionBase>)_options).Keys; 83public ICollection<OptionBase> Values => ((IDictionary<string, OptionBase>)_options).Values; 86public int Count => ((ICollection<KeyValuePair<string, OptionBase>>)_options).Count; 89public bool IsReadOnly => ((ICollection<KeyValuePair<string, OptionBase>>)_options).IsReadOnly; 100((ICollection<KeyValuePair<string, OptionBase>>)_options).Add(item); 106((ICollection<KeyValuePair<string, OptionBase>>)_options).Clear(); 112return ((ICollection<KeyValuePair<string, OptionBase>>)_options).Contains(item); 124((ICollection<KeyValuePair<string, OptionBase>>)_options).CopyTo(array, arrayIndex); 142return ((ICollection<KeyValuePair<string, OptionBase>>)_options).Remove(item);

Parameter.cs (2)

250ICollection<Parameter> IDictionary<string, Parameter>.Values 260public ICollection<string> Keys

SearchSpace.cs (9)

83public ICollection<string> Keys => ((IDictionary<string, OptionBase>)_options).Keys; 86public ICollection<OptionBase> Values => ((IDictionary<string, OptionBase>)_options).Values; 89public int Count => ((ICollection<KeyValuePair<string, OptionBase>>)_options).Count; 92public bool IsReadOnly => ((ICollection<KeyValuePair<string, OptionBase>>)_options).IsReadOnly; 337((ICollection<KeyValuePair<string, OptionBase>>)_options).Add(item); 343((ICollection<KeyValuePair<string, OptionBase>>)_options).Clear(); 349return ((ICollection<KeyValuePair<string, OptionBase>>)_options).Contains(item); 355((ICollection<KeyValuePair<string, OptionBase>>)_options).CopyTo(array, arrayIndex); 361return ((ICollection<KeyValuePair<string, OptionBase>>)_options).Remove(item);

Microsoft.ML.Tokenizers (7)

Model\BertTokenizer.cs (6)

299if (tokenIds is ICollection<int> c1) 305capacity += additionalTokenIds is ICollection<int> c2 ? c2.Count + 1 : c1.Count + 1; 410if (tokenIds is ICollection<int> c1) 416capacity += additionalTokenIds is ICollection<int> c2 ? c2.Count + 1 : c1.Count + 1; 566if (tokenIds is ICollection<int> c1) 572capacity += additionalTokenIds is ICollection<int> c2 ? c2.Count + 1 : c1.Count + 1;

Tokenizer.cs (1)

372if (ids is ICollection<int> c)

Microsoft.ML.TorchSharp (3)

Utils\DefaultDictionary.cs (3)

72((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).CopyTo(array, arrayIndex); 104public ICollection<TKey> Keys => _dictionary.Keys; 106public ICollection<TValue> Values => _dictionary.Values;

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)

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)

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

MSBuildTaskHost (28)

BinaryTranslator.cs (4)

CopyOnWriteDictionary.cs (2)

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)

622public ICollection<int> Keys 673public ICollection<ushort> Values

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

89ICollection<string> files;

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

350internal ICollection<XmlLanguage> FamilyMapLanguages

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

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

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

105ICollection<Typeface> GetTypefaces(FontFamilyIdentifier familyIdentifier);

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

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

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

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

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

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

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

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

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

3480private ICollection<IndexedGlyphRun> _indexedGlyphRuns; 3491internal ICollection<IndexedGlyphRun> IndexedGlyphRuns

System\Windows\FreezableCollection.cs (4)

373bool ICollection<T>.IsReadOnly 410return ((ICollection<T>)this).IsReadOnly; 658ICollection<T> enumerableAsICollectionT = enumerable as ICollection<T>;

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

281bool ICollection<TextDecoration>.IsReadOnly 318return ((ICollection<TextDecoration>)this).IsReadOnly; 889ICollection<TextDecoration> icollectionOfT = collection as ICollection<TextDecoration>;

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

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

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

873bool ICollection<Stroke>.IsReadOnly

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

355internal void ReportFrame(ICollection<IManipulator> manipulators) 515private void UpdateManipulators(ICollection<IManipulator> updatedManipulators)

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

280bool ICollection<Timeline>.IsReadOnly 317return ((ICollection<Timeline>)this).IsReadOnly; 897ICollection<Timeline> icollectionOfT = collection as ICollection<Timeline>;

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

252public ICollection<int> Keys 261public ICollection<CharacterMetrics> Values

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

221public ICollection<XmlLanguage> Keys 230public ICollection<string> Values

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

280bool ICollection<BitmapEffect>.IsReadOnly 317return ((ICollection<BitmapEffect>)this).IsReadOnly; 888ICollection<BitmapEffect> icollectionOfT = collection as ICollection<BitmapEffect>;

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

15private ICollection<Typeface> _innerList; 32internal FamilyTypefaceCollection(ICollection<Typeface> innerList)

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

66public ICollection<Uri> GlyphTypefaceUris 83public ICollection<ushort> GetUsedGlyphs(Uri glyphTypeface)

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

244public ICollection<Typeface> GetTypefaces()

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

41public static ICollection<FontFamily> GetFontFamilies(string location) 58public static ICollection<FontFamily> GetFontFamilies(Uri baseUri) 81public static ICollection<FontFamily> GetFontFamilies(Uri baseUri, string location) 134public static ICollection<Typeface> GetTypefaces(string location) 151public static ICollection<Typeface> GetTypefaces(Uri baseUri) 173public static ICollection<Typeface> GetTypefaces(Uri baseUri, string location) 192public static ICollection<FontFamily> SystemFontFamilies 204public static ICollection<Typeface> SystemTypefaces 232private static ICollection<FontFamily> CreateFamilyCollection( 260private static ICollection<FontFamily> CreateDefaultFamilyCollection() 394private static readonly ICollection<FontFamily> _defaultFontCollection = CreateDefaultFamilyCollection();

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

235bool ICollection<double>.IsReadOnly 272return ((ICollection<double>)this).IsReadOnly; 912ICollection<double> icollectionOfT = collection as ICollection<double>;

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

293bool ICollection<Drawing>.IsReadOnly 330return ((ICollection<Drawing>)this).IsReadOnly; 928ICollection<Drawing> icollectionOfT = collection as ICollection<Drawing>;

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

278bool ICollection<GeneralTransform>.IsReadOnly 315return ((ICollection<GeneralTransform>)this).IsReadOnly; 886ICollection<GeneralTransform> icollectionOfT = collection as ICollection<GeneralTransform>;

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

293bool ICollection<Geometry>.IsReadOnly 330return ((ICollection<Geometry>)this).IsReadOnly; 928ICollection<Geometry> icollectionOfT = collection as ICollection<Geometry>;

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

279bool ICollection<GradientStop>.IsReadOnly 316return ((ICollection<GradientStop>)this).IsReadOnly; 990ICollection<GradientStop> icollectionOfT = collection as ICollection<GradientStop>;

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

234bool ICollection<int>.IsReadOnly 271return ((ICollection<int>)this).IsReadOnly; 911ICollection<int> icollectionOfT = collection as ICollection<int>;

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

284bool ICollection<PathFigure>.IsReadOnly 321return ((ICollection<PathFigure>)this).IsReadOnly; 981ICollection<PathFigure> icollectionOfT = collection as ICollection<PathFigure>;

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

278bool ICollection<PathSegment>.IsReadOnly 315return ((ICollection<PathSegment>)this).IsReadOnly; 886ICollection<PathSegment> icollectionOfT = collection as ICollection<PathSegment>;

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

234bool ICollection<Point>.IsReadOnly 271return ((ICollection<Point>)this).IsReadOnly; 913ICollection<Point> icollectionOfT = collection as ICollection<Point>;

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

278bool ICollection<TextEffect>.IsReadOnly 315return ((ICollection<TextEffect>)this).IsReadOnly; 886ICollection<TextEffect> icollectionOfT = collection as ICollection<TextEffect>;

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

293bool ICollection<Transform>.IsReadOnly 330return ((ICollection<Transform>)this).IsReadOnly; 928ICollection<Transform> icollectionOfT = collection as ICollection<Transform>;

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

234bool ICollection<Vector>.IsReadOnly 271return ((ICollection<Vector>)this).IsReadOnly; 913ICollection<Vector> icollectionOfT = collection as ICollection<Vector>;

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

222public byte[] ComputeSubset(ICollection<ushort> glyphs) 1746public ICollection<ushort> Keys 1770public ICollection<double> Values

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

231internal ICollection<IndexedGlyphRun> IndexedGlyphRuns

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

278bool ICollection<GeneralTransform3D>.IsReadOnly 315return ((ICollection<GeneralTransform3D>)this).IsReadOnly; 886ICollection<GeneralTransform3D> icollectionOfT = collection as ICollection<GeneralTransform3D>;

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

293bool ICollection<Material>.IsReadOnly 330return ((ICollection<Material>)this).IsReadOnly; 928ICollection<Material> icollectionOfT = collection as ICollection<Material>;

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

293bool ICollection<Model3D>.IsReadOnly 330return ((ICollection<Model3D>)this).IsReadOnly; 928ICollection<Model3D> icollectionOfT = collection as ICollection<Model3D>;

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

235bool ICollection<Point3D>.IsReadOnly 272return ((ICollection<Point3D>)this).IsReadOnly; 915ICollection<Point3D> icollectionOfT = collection as ICollection<Point3D>;

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

293bool ICollection<Transform3D>.IsReadOnly 330return ((ICollection<Transform3D>)this).IsReadOnly; 928ICollection<Transform3D> icollectionOfT = collection as ICollection<Transform3D>;

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

235bool ICollection<Vector3D>.IsReadOnly 272return ((ICollection<Vector3D>)this).IsReadOnly; 915ICollection<Vector3D> icollectionOfT = collection as ICollection<Vector3D>;

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

291bool ICollection<Visual3D>.IsReadOnly

PresentationFramework (44)

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

472ICollection<AnnotationResource> cargos = annot.Cargos;

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

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

188internal bool IsOverlapping(ICollection<TextSegment> textSegments) 278internal static TextAnchor TrimToRelativeComplement(TextAnchor anchor, ICollection<TextSegment> textSegments) 380internal static TextAnchor TrimToIntersectionWith(TextAnchor anchor, ICollection<TextSegment> textSegments) 590private static ICollection<TextSegment> SortTextSegments(ICollection<TextSegment> textSegments, bool excludeZeroLength)

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

716ICollection<DependencyProperty> usedDPs = this.Values;

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

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

MS\Internal\ListOfObject.cs (7)

55void ICollection<object>.Add(object item) 60void ICollection<object>.Clear() 65bool ICollection<object>.Contains(object item) 70void ICollection<object>.CopyTo(object[] array, int arrayIndex) 75int ICollection<object>.Count 80bool ICollection<object>.IsReadOnly 85bool ICollection<object>.Remove(object item)

MS\Internal\WeakDictionary.cs (2)

201public ICollection<TKey> Keys 234public ICollection<TValue> Values

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

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

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

142void ICollection<Uri>.Add(Uri item) 153void ICollection<Uri>.Clear() 159bool ICollection<Uri>.Contains(Uri item) 164void ICollection<Uri>.CopyTo(Uri[] array, int arrayIndex) 169int ICollection<Uri>.Count 177bool ICollection<Uri>.IsReadOnly 181return ((ICollection<Uri>)_uriList).IsReadOnly; 185bool ICollection<Uri>.Remove(Uri item)

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

69public TextChangedEventArgs(RoutedEvent id, UndoAction action, ICollection<TextChange> changes) : base() 134public ICollection<TextChange> Changes 161private readonly ICollection<TextChange> _changes;

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

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

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

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

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

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

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

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

PresentationUI (4)

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

406ICollection<XpsSignatureDefinition> documentSignatureDefinitionList =

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

662ICollection<ContentGrant> licenseGrants = 1326private ICollection<ContentGrant> GetGrantsFromUnsignedLicense( 1329ICollection<ContentGrant> grants = null;

ReachFramework (13)

packaging\XpsDigitalSignature.cs (2)

309ICollection<Uri> containingCollection, 310ICollection<Uri> containedCollection

Packaging\XpsFixedDocumentReaderWriter.cs (2)

93ICollection<XpsSignatureDefinition> 352ICollection<XpsSignatureDefinition>

Packaging\XpsFixedPageReaderWriter.cs (8)

156ICollection<XpsFont> 162ICollection<XpsColorContext> 168ICollection<XpsResourceDictionary> 174ICollection<XpsImage> 632public ICollection<XpsFont> 645public ICollection<XpsColorContext> 659public ICollection<XpsResourceDictionary> 673public ICollection<XpsImage>

Serialization\XpsFontSubsetter.cs (1)

587ICollection<ushort> glyphs,

Shared (18)

Data.Validation\LengthAttribute.cs (1)

19/// on .NET Framework, while <see cref="System.Collections.Generic.ICollection{T}"/> type is supported only on .NET Core.

EmptyCollections\EmptyCollectionExtensions.cs (2)

47public static IEnumerable<T> EmptyIfNull<T>(this ICollection<T>? collection) 112if (enumerable is ICollection<T> c && c.Count == 0)

EmptyCollections\EmptyReadonlyDictionary.cs (8)

EmptyCollections\EmptyReadOnlyList.cs (6)

Throw\Throw.cs (1)

20EmptyCollectionExtensions.EmptyIfNull((ICollection<T>?)null).Should().BeEmpty(); 29EmptyCollectionExtensions.EmptyIfNull((ICollection<T>)input).Should().BeEmpty().And.NotBeSameAs(input); 39EmptyCollectionExtensions.EmptyIfNull((ICollection<T>)nonempty).Should().BeSameAs(nonempty);

Shared.Tests (10)

EmptyCollections\EmptyCollectionExtensionsTests.cs (3)

EmptyCollections\EmptyReadonlyDictionaryTests.cs (2)

58var coll = EmptyReadOnlyDictionary<int, string>.Instance as ICollection<KeyValuePair<int, string>>;

EmptyCollections\EmptyReadOnlyListTests.cs (2)

55var coll = EmptyReadOnlyList<int>.Instance as ICollection<int>;

Throw\ThrowTest.cs (3)

322ArgumentException exception = Assert.Throws<ArgumentNullException>(() => Throw.IfNullOrEmpty((ICollection<int>?)null, "foo")); 339exception = Assert.Throws<ArgumentException>(() => Throw.IfNullOrEmpty((ICollection<int>?)list, "foo")); 364Assert.Equal(list, Throw.IfNullOrEmpty((ICollection<int>?)list, "foo"));

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 (58)

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

35if (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)

36private readonly ICollection<TKey> _collection; 38public DictionaryKeyCollectionDebugView(ICollection<TKey> collection) 57private readonly ICollection<TValue> _collection; 59public DictionaryValueCollectionDebugView(ICollection<TValue> collection)

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

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

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

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

System\Collections\Generic\OrderedDictionary.cs (19)

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

407var collection = items as ICollection<(TElement Element, TPriority Priority)>; 470if (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 155ICollection<TKey> IDictionary<TKey, TValue>.Keys 173ICollection<TValue> IDictionary<TKey, TValue>.Values 594bool ICollection<TKey>.IsReadOnly 599void ICollection<TKey>.Add(TKey item) 604void ICollection<TKey>.Clear() 614bool ICollection<TKey>.Remove(TKey item) 755bool ICollection<TValue>.IsReadOnly 760void ICollection<TValue>.Add(TValue item) 765void ICollection<TValue>.Clear() 770bool ICollection<TValue>.Contains(TValue item) 775bool 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 (175)

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

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

289ICollection<TKey> IDictionary<TKey, TValue>.Keys => 310ICollection<TValue> IDictionary<TKey, TValue>.Values => 415bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => true; 556bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item) => 606void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item) => throw new NotSupportedException(); 615bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item) => throw new NotSupportedException(); 621void ICollection<KeyValuePair<TKey, TValue>>.Clear() => throw new NotSupportedException();

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

296bool ICollection<T>.IsReadOnly => true; 416void ICollection<T>.Add(T item) => throw new NotSupportedException(); 419void ICollection<T>.Clear() => throw new NotSupportedException(); 422bool 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)

482/// See the <see cref="ICollection{T}"/> interface. 484bool ICollection<T>.IsReadOnly 490/// See the <see cref="ICollection{T}"/> interface. 492void ICollection<T>.CopyTo(T[] array, int arrayIndex) 507void ICollection<T>.Add(T item) 513/// See the <see cref="ICollection{T}"/> interface. 515void ICollection<T>.Clear() 523bool ICollection<T>.Remove(T item)

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

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

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

955void ICollection<T>.Add(T item) => throw new NotSupportedException(); 961void ICollection<T>.Clear() => throw new NotSupportedException(); 964/// Gets a value indicating whether the <see cref="ICollection{T}"/> is read-only. 966/// <returns>true if the <see cref="ICollection{T}"/> is read-only; otherwise, false. 968bool ICollection<T>.IsReadOnly => true; 976bool ICollection<T>.Remove(T item) => throw new NotSupportedException(); 1047/// Gets a value indicating whether the <see cref="ICollection{T}"/> is read-only. 1049/// <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)

706/// See the <see cref="ICollection{T}"/> interface. 708bool ICollection<T>.IsReadOnly 714/// See the <see cref="ICollection{T}"/> interface. 716void ICollection<T>.CopyTo(T[] array, int arrayIndex) 724void ICollection<T>.Add(T item) 730/// See the <see cref="ICollection{T}"/> interface. 732void ICollection<T>.Clear() 740bool ICollection<T>.Remove(T item) 788/// Gets a value indicating whether the <see cref="ICollection{T}"/> is read-only. 790/// <returns>true if the <see cref="ICollection{T}"/> is read-only; otherwise, false.

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

304/// See the <see cref="ICollection{T}"/> interface. 318/// 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.Configuration.ConfigurationManager (11)

System\Configuration\ConfigurationErrorsException.cs (4)

86internal ConfigurationErrorsException(ICollection<ConfigurationException> coll) : 179internal ICollection<ConfigurationException> ErrorsGeneric => (ICollection<ConfigurationException>)Errors; 192private static ConfigurationException GetFirstException(ICollection<ConfigurationException> coll)

System\Configuration\ConfigurationSchemaErrors.cs (1)

88internal void AddSavedLocalErrors(ICollection<ConfigurationException> coll)

System\Configuration\ErrorsHelper.cs (2)

32ICollection<ConfigurationException> col = ce.ErrorsGeneric; 38internal static void AddErrors(ref List<ConfigurationException> errors, ICollection<ConfigurationException> coll)

System\Configuration\FactoryRecord.cs (2)

39ICollection<ConfigurationException> errors) 256internal void AddErrors(ICollection<ConfigurationException> coll)

System\Configuration\LocationSectionRecord.cs (1)

25internal ICollection<ConfigurationException> Errors => _errors;

System\Configuration\SectionInput.cs (1)

53internal ICollection<ConfigurationException> Errors => _errors;

System.Data.Common (2)

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

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

System.Diagnostics.DiagnosticSource (4)

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\Metrics\Measurement.cs (1)

111if (tags is ICollection<KeyValuePair<string, object?>> collection)

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) 97/// count can be determined without enumerating; this includes <see cref="ICollection{T}"/>, 110if (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)

129if (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)

19if (source is ICollection<TSource> collection) 45private static TSource[] ICollectionToArray<TSource>(ICollection<TSource> collection)

System.Linq.AsyncEnumerable (7)

System\Linq\GroupBy.cs (7)

413int ICollection<TElement>.Count => _count; 415bool ICollection<TElement>.IsReadOnly => true; 417void ICollection<TElement>.Add(TElement item) => throw new NotSupportedException(); 419void ICollection<TElement>.Clear() => throw new NotSupportedException(); 421bool ICollection<TElement>.Contains(TElement item) => Array.IndexOf(_elements, item, 0, _count) >= 0; 423void ICollection<TElement>.CopyTo(TElement[] array, int arrayIndex) => 426bool ICollection<TElement>.Remove(TElement item) => throw new NotSupportedException();

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)

42public 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)

61public 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)

713((ICollection<KeyValuePair<object, Task>>)s_tasks).Remove(new KeyValuePair<object, Task>(key!, task!)); 726((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 (83)

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

35if (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) 1457bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => false; 1459void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int index) => 1928bool ICollection<TKey>.IsReadOnly => true; 1930void ICollection<TKey>.Add(TKey item) => 1933void ICollection<TKey>.Clear() => 1939bool ICollection<TKey>.Remove(TKey item) 2123bool ICollection<TValue>.IsReadOnly => true; 2125void ICollection<TValue>.Add(TValue item) => 2128bool ICollection<TValue>.Remove(TValue item) 2134void ICollection<TValue>.Clear() => 2137bool ICollection<TValue>.Contains(TValue item) => _dictionary.ContainsValue(item);

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

103if (collection is ICollection<T> coll) 194void ICollection<T>.Add(T item) => AddIfNotPresent(item, out _); 364bool ICollection<T>.IsReadOnly => false; 832if (other is ICollection<T> otherAsCollection) 936if (other is ICollection<T> otherAsCollection) 972if (other is ICollection<T> otherAsCollection) 1017if (other is ICollection<T> otherAsCollection) 1061if (other is ICollection<T> otherAsCollection) 1136if (other 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)

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

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

58bool ICollection<T>.IsReadOnly => true; 66void ICollection<T>.Add(T value) 71void ICollection<T>.Clear() 81bool ICollection<T>.Remove(T value)

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

src\libraries\System.Private.CoreLib\src\System\Collections\ObjectModel\ReadOnlySet.cs (5)

66void ICollection<T>.CopyTo(T[] array, int arrayIndex) => _set.CopyTo(array, arrayIndex); 72bool ICollection<T>.IsReadOnly => true; 96void ICollection<T>.Add(T item) => throw new NotSupportedException(); 99void ICollection<T>.Clear() => throw new NotSupportedException(); 102bool ICollection<T>.Remove(T item) => throw new NotSupportedException();

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)

5941if (tasks is ICollection<Task> taskCollection) 6248if (tasks is ICollection<Task<TResult>> taskCollection) 6723if (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.Windows.Core (1)

System\Private\Windows\Ole\DataFormatNames.cs (1)

78where T : ICollection<string>

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)

35if (source is ICollection<T> ic)

System.Runtime (1)

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

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

System.Runtime.Serialization.Schema (14)

System\Runtime\Serialization\Schema\CodeExporter.cs (3)

896internal ICollection<CodeTypeReference>? GetKnownTypeReferences(DataContract dataContract) 991ICollection<DataContract> knownTypeContracts = knownContractDictionary.Values; 1231expectedTypeName, expectedTypeNs, GetClrTypeFullName(typeof(IList<>)), GetClrTypeFullName(typeof(ICollection<>)))));

System\Runtime\Serialization\Schema\ImportOptions.cs (4)

19private ICollection<Type>? _referencedTypes; 20private ICollection<Type>? _referencedCollectionTypes; 65public ICollection<Type> ReferencedCollectionTypes => _referencedCollectionTypes ??= new List<Type>(); 70public ICollection<Type> ReferencedTypes => _referencedTypes ??= new List<Type>();

System\Runtime\Serialization\Schema\XsdDataContractImporter.cs (7)

93public void Import(XmlSchemaSet schemas, ICollection<XmlQualifiedName> typeNames) 165public bool CanImport(XmlSchemaSet schemas, ICollection<XmlQualifiedName> typeNames) 266public ICollection<CodeTypeReference>? GetKnownTypeReferences(XmlQualifiedName typeName) 300private IList<XmlQualifiedName>? InternalImport(XmlSchemaSet schemas, ICollection<XmlQualifiedName>? typeNames, ICollection<XmlSchemaElement>? elements) 335private bool InternalCanImport(XmlSchemaSet schemas, ICollection<XmlQualifiedName>? typeNames, ICollection<XmlSchemaElement>? elements)

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.Cryptography.Pkcs (1)

System\Security\Cryptography\Pkcs\RecipientInfoCollection.cs (1)

23internal RecipientInfoCollection(ICollection<RecipientInfo> recipientInfos)

System.Security.Principal.Windows (1)

artifacts\obj\System.Security.Principal.Windows\Debug\net10.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.ServiceModel.Federation (1)

System\ServiceModel\Federation\WsTrustTokenParameters.cs (1)

108public new ICollection<XmlElement> AdditionalRequestParameters { get; } = new Collection<XmlElement>();

System.ServiceModel.NetFramingBase (4)

System\ServiceModel\Channels\ConnectionPool.cs (4)

683readonly Dictionary<string, ICollection<Uri>> _reverseTable = new Dictionary<string, ICollection<Uri>>(); 689ICollection<Uri> uris; 706ICollection<Uri> uris;

System.ServiceModel.Primitives (11)

netstandard.cs (11)

System.Speech (7)

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

System.Text.Json (15)

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\Nodes\JsonArray.IList.cs (2)

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

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

38int capacity = properties is ICollection<KeyValuePair<string, JsonNode?>> propertiesCollection ? propertiesCollection.Count : 0;

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

130bool ICollection<KeyValuePair<string, JsonNode?>>.Contains(KeyValuePair<string, JsonNode?> item) => 150void ICollection<KeyValuePair<string, JsonNode?>>.CopyTo(KeyValuePair<string, JsonNode?>[] array, int index) => 170bool ICollection<KeyValuePair<string, JsonNode?>>.Remove(KeyValuePair<string, JsonNode?> item) => Remove(item.Key); 175ICollection<string> IDictionary<string, JsonNode?>.Keys => Dictionary.Keys; 180ICollection<JsonNode?> IDictionary<string, JsonNode?>.Values => Dictionary.Values; 209bool 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)

112else 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.Windows.Forms (1)

System\Windows\Forms\Controls\DataGridView\DataGridViewComboBoxCell.ObjectCollection.cs (1)

125internal void AddRangeInternal(ICollection<object> items)

System.Windows.Forms.Design (10)

System\ComponentModel\Design\Serialization\ComponentCache.cs (2)

243public ICollection<ResourceEntry>? Metadata => _metadata; 245public ICollection<ResourceEntry>? Resources => _resources;

System\Windows\Forms\Design\Behavior\DropSourceBehavior.cs (1)

931private void InitiateDrag(Point initialMouseLocation, ICollection<IComponent> dragComps)

System\Windows\Forms\Design\ListAdapter.cs (7)

26int ICollection<T>.Count => _list.Count; 28bool ICollection<T>.IsReadOnly => _list.IsReadOnly; 30void ICollection<T>.Add(T item) => _list.Add(item.OrThrowIfNull()); 31void ICollection<T>.Clear() => _list.Clear(); 32bool ICollection<T>.Contains(T item) => _list.Contains(item); 33void ICollection<T>.CopyTo(T[] array, int arrayIndex) => _list.CopyTo(array, arrayIndex); 39bool ICollection<T>.Remove(T item)

System.Windows.Forms.Primitives (1)

System\Windows\Forms\NonNullCollection.cs (1)

34public bool IsReadOnly => ((ICollection<T>)_list).IsReadOnly;

System.Windows.Forms.Tests (3)

System\Windows\Forms\CursorConverterTests.cs (1)

194ICollection<Cursor> values = converter.GetStandardValues().Cast<Cursor>().ToArray();

System\Windows\Forms\ListBindingHelperTests.cs (2)

130yield return new object[] { typeof(ICollection<int>), typeof(ICollection<int>) };

System.Xaml (45)

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

1302public ArrayItemList(ICollection<T> collection) 1989public FrugalStructList(ICollection<T> collection)

System\Xaml\AttachablePropertyServices.cs (1)

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

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

58private ICollection<AssemblyName> _internalsVisibleTo; 59internal ICollection<AssemblyName> InternalsVisibleTo 245ICollection<AssemblyName> LoadInternalsVisibleTo()

System\Xaml\NameScope.cs (2)

221public ICollection<string> Keys 240public ICollection<object> Values

System\Xaml\NameScopeDictionary.cs (9)

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

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

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

225internal ICollection<XamlMember> ExcludedReadOnlyMembers { get; set; } 465internal void LookupAllMembers(out ICollection<PropertyInfo> newProperties, 466out ICollection<EventInfo> newEvents, out List<XamlMember> knownMembers) 549private ICollection<EventInfo> FilterEvents(EventInfo[] eventList, List<XamlMember> knownMembers)

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

20private ICollection<XamlType> _allPublicTypes; 52public ICollection<XamlType> GetAllXamlTypes() => _allPublicTypes ??= LookupAllTypes(); 204private ICollection<XamlType> LookupAllTypes()

System\Xaml\XamlObjectReader.cs (2)

1621var properties = valueXamlType.GetAllMembers(); 1622var readOnlyProperties = valueXamlType.GetAllExcludedReadOnlyMembers();

System\Xaml\XamlSchemaContext.cs (8)

97public virtual ICollection<XamlType> GetAllXamlTypes(string xamlNamespace) 591ICollection<XamlMember> members = type.GetAllMembers(); 785ICollection<AssemblyName> friends = nsInfo.InternalsVisibleTo; 1439void ICollection<T>.Add(T item) 1444bool ICollection<T>.Contains(T item) 1457void ICollection<T>.CopyTo(T[] array, int arrayIndex) 1465bool ICollection<T>.Remove(T item) 1470bool ICollection<T>.IsReadOnly

System\Xaml\XamlType.cs (7)

363public ICollection<XamlMember> GetAllMembers() 412public ICollection<XamlMember> GetAllAttachableMembers() 633internal ICollection<XamlMember> GetAllExcludedReadOnlyMembers() 1067ICollection<PropertyInfo> properties; 1068ICollection<EventInfo> events; 1648private ICollection<XamlMember> LookupAllExcludedReadOnlyMembers() 1656ICollection<XamlMember> allMembers = GetAllMembers();

System\Xaml\XamlXmlWriter.cs (2)

2017var properties = objectXamlType.GetAllMembers(); 2018var readOnlyProperties = objectXamlType.GetAllExcludedReadOnlyMembers();

System.Xaml.Tests (40)

System\Xaml\Schema\XamlTypeInvokerTests.cs (7)

245typeof(ICollection<int>).GetMethod(nameof(ICollection<int>.Add)) 251typeof(ICollection<Array>).GetMethod(nameof(ICollection<Array>.Add)) 297typeof(ICollection<int>).GetMethod(nameof(ICollection<int>.Add)) 464new XamlTypeInvoker(new XamlType(typeof(ICollection<int>), new XamlSchemaContext())),

System\Xaml\XamlTypeTests.cs (33)

Templates.Blazor.Tests (2)

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

385var certsFromDisk = GetCertsFromDisk(); 431private static ICollection<X509Certificate2> GetCertsFromDisk()

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

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

385var certsFromDisk = GetCertsFromDisk(); 431private static ICollection<X509Certificate2> GetCertsFromDisk()

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

Templates.Blazor.WebAssembly.Tests (3)

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

385var certsFromDisk = GetCertsFromDisk(); 431private static ICollection<X509Certificate2> GetCertsFromDisk()

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

Templates.Mvc.Tests (3)

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

385var certsFromDisk = GetCertsFromDisk(); 431private static ICollection<X509Certificate2> GetCertsFromDisk()

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

Templates.Tests (3)

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

385var certsFromDisk = GetCertsFromDisk(); 431private static ICollection<X509Certificate2> GetCertsFromDisk()

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